// ApiKeyManager.js - Core rotation logic
class ApiKeyManager {
  constructor(config) {
    this.keyPools = new Map();
    
    // Initialize key pools for each service
    Object.entries(config.services).forEach(([serviceName, serviceConfig]) => {
      const keys = serviceConfig.keys.filter(Boolean);
      this.keyPools.set(serviceName, new KeyPool(serviceName, keys, serviceConfig));
    });
  }

  getNextKey(service) {
    const pool = this.keyPools.get(service);
    return pool?.getNextKey();
  }

  reportFailure(service, key, errorType) {
    const pool = this.keyPools.get(service);
    pool?.markFailure(key, errorType);
  }
}

// DataFetch.jsx - Caching implementation
const newsCache = new Map();
const CACHE_DURATION = 10 * 60 * 1000; // 10 minutes

const fetchNews = async (pageNum = 1) => {
  const cacheKey = `news-${category || 'general'}-page${pageNum}`;
  const cached = newsCache.get(cacheKey);
  
  // Return cached data if still valid
  if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
    console.log(`[Cache] ✓ Using cached data`);
    return cached.data;
  }
  
  // Fetch fresh data and cache it
  const freshData = await fetchFromAPI();
  newsCache.set(cacheKey, {
    data: freshData,
    timestamp: Date.now()
  });
  
  return freshData;
};

// Duplicate detection using title + URL hashing
const removeDuplicates = (articles) => {
  const seen = new Map();
  const unique = [];
  
  articles.forEach(article => {
    if (!article.title) return;
    
    // Create unique key from title + url
    const titleKey = article.title.toLowerCase().trim().slice(0, 50);
    const urlKey = article.url || '';
    const uniqueKey = `${titleKey}|${urlKey}`;
    
    if (!seen.has(uniqueKey)) {
      seen.set(uniqueKey, true);
      unique.push(article);
    }
  });
  
  return unique;
};

/* src/utils/useTTS.jsx */
const startReading = () => {
   // ...
   speechRef.current = new SpeechSynthesisUtterance();
   speechRef.current.voice = voicesRef.current.find(v => v.name === "Google US English");
   speechRef.current.text = `Article ${currentIndex + 1}: ${articles[currentIndex].title}`;
   window.speechSynthesis.speak(speechRef.current);
};

// useTTS.jsx - Text-to-speech hook
const useTTS = () => {
  const [isSpeaking, setIsSpeaking] = useState(false);
  
  const speak = (text) => {
    if ('speechSynthesis' in window) {
      const utterance = new SpeechSynthesisUtterance(text);
      utterance.rate = 1.0;
      utterance.pitch = 1.0;
      
      utterance.onstart = () => setIsSpeaking(true);
      utterance.onend = () => setIsSpeaking(false);
      
      window.speechSynthesis.speak(utterance);
    }
  };
  
  const stop = () => {
    window.speechSynthesis.cancel();
    setIsSpeaking(false);
  };
  
  return { speak, stop, isSpeaking };
};

// Fallback chain in DataFetch.jsx
const [newsAPIArticles, gNewsArticles] = await Promise.allSettled([
  fetchNewsAPI(pageNum),
  fetchGNews()
]);

// Extract successful results only
const newsAPIData = newsAPIArticles.status === 'fulfilled' 
  ? newsAPIArticles.value : [];
const gNewsData = gNewsArticles.status === 'fulfilled' 
  ? gNewsArticles.value : [];

// Continue with whatever data we got
const allArticles = [...newsAPIData, ...gNewsData];

class KeyMetadata {
  constructor(key) {
    this.key = key;
    this.status = 'unknown';        // working | rate-limited | failed
    this.usageCount = 0;            // Total API calls
    this.successCount = 0;          // Successful calls
    this.failureCount = 0;          // Failed calls
    this.lastUsed = null;           // Timestamp
    this.lastFailure = null;        // Last failure time
    this.cooldownUntil = null;      // When key becomes available
    this.errorType = null;          // rate-limit | auth | network
  }
  
  isAvailable() {
    // Check cooldown period
    if (this.cooldownUntil && Date.now() < this.cooldownUntil) {
      return false;
    }
    // Allow retry if under 5 failures
    return this.status !== 'failed' || this.failureCount < 5;
  }
  
  getSuccessRate() {
    return this.usageCount === 0 ? 0 : this.successCount / this.usageCount;
  }
}

markFailure(key, errorType) {
  const keyMetadata = this.keys.find(k => k.key === key);
  keyMetadata.failureCount++;
  
  if (errorType === 'rate-limited') {
    // 1 hour cooldown for rate limits
    keyMetadata.cooldownUntil = Date.now() + 3600000;
  } else {
    // Exponential backoff: 5min, 10min, 20min, 40min (max)
    const backoffMultiplier = Math.min(
      Math.pow(2, keyMetadata.failureCount - 1), 
      8
    );
    keyMetadata.cooldownUntil = Date.now() + (300000 * backoffMultiplier);
  }
}

// GET /api/health
app.get('/api/health', (req, res) => {
  const apiStatus = apiKeyManager.getAllStatus();
  
  res.json({ 
    status: 'ok', 
    timestamp: new Date().toISOString(),
    services: {
      newsapi: {
        available: apiStatus.newsapi.available,
        totalKeys: apiStatus.newsapi.totalKeys,
        workingKeys: apiStatus.newsapi.workingKeys
      }
    }
  });
});

{
  "status": "ok",
  "timestamp": "2025-12-28T04:00:00.000Z",
  "services": {
    "newsapi": {
      "available": true,
      "totalKeys": 3,
      "workingKeys": 2
    }
  }
}

// server.js - CORS configuration
app.use(cors({
  origin: '*',
  methods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
  credentials: false,
  maxAge: 86400
}));

const hasFetched = useRef(false);

const fetchNews = async () => {
  // Prevent duplicate calls in React StrictMode
  if (hasFetched.current) return;
  hasFetched.current = true;
  
  // Actual fetch logic...
};

{
  "rewrites": [
    {
      "source": "/((?!api).*)",
      "destination": "/index.html"
    }
  ]
}

// NewsCard.jsx - Schema normalization
const imageUrl = article.urlToImage || article.image || FALLBACK_IMAGE;
const sourceName = article.source?.name || article.source || 'Unknown';

{
  "buildCommand": "npm run build",
  "outputDirectory": "dist",
  "rewrites": [
    {
      "source": "/((?!api).*)",
      "destination": "/index.html"
    }
  ],
  "headers": [
    {
      "source": "/api/(.*)",
      "headers": [
        { "key": "Access-Control-Allow-Origin", "value": "*" },
        { "key": "Access-Control-Allow-Methods", "value": "GET, POST, PUT, DELETE, OPTIONS" },
        { "key": "Access-Control-Allow-Headers", "value": "Content-Type, Authorization" }
      ]
    }
  ]
}

# NewsAPI Keys (3 keys for rotation)
VITE_NEWS_API_KEY_1=your_key_1
VITE_NEWS_API_KEY_2=your_key_2
VITE_NEWS_API_KEY_3=your_key_3

# GNews Keys (3 keys for rotation)
VITE_GNEWS_API_KEY_1=your_key_1
VITE_GNEWS_API_KEY_2=your_key_2
VITE_GNEWS_API_KEY_3=your_key_3

# YouTube Keys (2 keys for rotation)
VITE_YT_API_KEY_1=your_key_1
VITE_YT_API_KEY_2=your_key_2

# YouTube Keys (3 keys for rotation)
VITE_YT_API_KEY_1=your_key_1
VITE_YT_API_KEY_2=your_key_2
VITE_YT_API_KEY_3=your_key_3

# Clone and install
git clone https://github.com/AmanSuryavanshi-1/AV-News-Stream.git
cd AV-News-Stream
npm install

# Development (both servers)
npm run dev

# Backend only (port 3001)
npm run dev:server

# Frontend only (port 5173)
npm run dev:client

# Production build
npm run build
npm run preview