background.js

// Background Service Worker (Manifest V3) - LinkedIn Lead Scraper Engine

const DEFAULT_CONFIG = {
  DAILY_VISIT_LIMIT: 120, // Rate limit for profile visits
  DAILY_SCRAPE_LIMIT: 50, // Rate limit for successfully scraped leads
  BACKEND_URL: 'http://localhost:5000/api',
  AUTO_RESUME_HOURS: 24
};

// Initial state
let scraperState = {
  status: 'IDLE', // 'IDLE', 'RUNNING', 'PAUSED', 'SAFETY_PAUSE'
  todayScrapedCount: 0,
  todayVisitCount: 0,
  lastResetTimestamp: Date.now(),
  queue: [],
  visitedUrls: new Set(),
  currentProfileIndex: 0,
  safetyPauseReason: ''
};

// Initialize Chrome Storage state on install
chrome.runtime.onInstalled.addListener(() => {
  chrome.storage.local.set({
    status: 'IDLE',
    todayScrapedCount: 0,
    todayVisitCount: 0,
    lastResetTimestamp: Date.now(),
    queue: [],
    visitedUrls: []
  });
  console.log('[Background Worker] Installed and initialized state.');
});

// Daily rate limit reset alarm check
chrome.alarms.create('checkDailyReset', { periodInMinutes: 10 });
chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === 'checkDailyReset') {
    syncCountsFromBackend();
  }
});

async function checkAndResetDailyLimit() {
  // Legacy function stub - now gracefully defers to syncCountsFromBackend
  // We keep this to avoid breaking callers, but it no longer manually zeros the counts.
  await syncCountsFromBackend();
}

async function syncCountsFromBackend() {
  try {
    const res = await fetch(`${DEFAULT_CONFIG.BACKEND_URL}/stats`);
    const data = await res.json();
    if (data.success) {
      await chrome.storage.local.set({
        todayScrapedCount: data.todayScrapedCount || 0,
        todayVisitCount: data.todayVisitCount || 0
      });
      console.log(`[Background Worker] Synced limits from DB: ${data.todayVisitCount} Visited, ${data.todayScrapedCount} Scraped`);
    }
  } catch (err) {
    console.warn('[Background Worker] Failed to sync limits from DB. Using local cache fallback.', err.message);
  }
}

// Message handler for Popup UI and Content Script
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  (async () => {
    try {
      if (request.action === 'GET_STATUS') {
        const state = await chrome.storage.local.get([
          'status', 'todayScrapedCount', 'todayVisitCount', 'queue', 'safetyPauseReason', 'lastResetTimestamp'
        ]);
        sendResponse({ success: true, state });
      } else if (request.action === 'START_SCRAPING') {
        await checkAndResetDailyLimit();
        await syncCountsFromBackend();
        const data = await chrome.storage.local.get(['todayScrapedCount', 'todayVisitCount']);
        
        if ((data.todayVisitCount || 0) >= DEFAULT_CONFIG.DAILY_VISIT_LIMIT) {
          await chrome.storage.local.set({
            status: 'SAFETY_PAUSE',
            safetyPauseReason: `Daily visit limit (${DEFAULT_CONFIG.DAILY_VISIT_LIMIT}) reached. Auto-resumes in 24h.`
          });
          return sendResponse({ success: false, message: 'Daily visit limit reached.' });
        }
        
        if ((data.todayScrapedCount || 0) >= DEFAULT_CONFIG.DAILY_SCRAPE_LIMIT) {
          await chrome.storage.local.set({
            status: 'SAFETY_PAUSE',
            safetyPauseReason: `Daily scrape limit (${DEFAULT_CONFIG.DAILY_SCRAPE_LIMIT} leads) reached. Auto-resumes in 24h.`
          });
          return sendResponse({ success: false, message: 'Daily scrape limit reached.' });
        }

        await chrome.storage.local.set({ status: 'RUNNING', safetyPauseReason: '' });
        
        // Find or navigate to LinkedIn
        const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
        if (tab && tab.url && tab.url.includes('linkedin.com')) {
          chrome.tabs.sendMessage(tab.id, { action: 'START_DOM_SCRAPER' }).catch(err => {
            console.log('[Background Worker] Content script not yet attached or connection standby:', err.message);
          });
        } else {
          // Open 1st degree connections page as starting point
          const newTab = await chrome.tabs.create({ 
            url: 'https://www.linkedin.com/mynetwork/invite-connect/connections/' 
          });
        }
        sendResponse({ success: true, status: 'RUNNING' });
      } else if (request.action === 'PAUSE_SCRAPING') {
        await chrome.storage.local.set({ status: 'PAUSED' });
        sendResponse({ success: true, status: 'PAUSED' });
      } else if (request.action === 'TRIGGER_SAFETY_PAUSE') {
        await chrome.storage.local.set({
          status: 'SAFETY_PAUSE',
          safetyPauseReason: request.reason || 'Safety Brake Triggered (CAPTCHA/429 throttling detected).'
        });
        sendResponse({ success: true });
      } else if (request.action === 'RECORD_VISIT') {
        const data = await chrome.storage.local.get(['todayVisitCount']);
        const newCount = (data.todayVisitCount || 0) + 1;
        await chrome.storage.local.set({ todayVisitCount: newCount });

        if (newCount >= DEFAULT_CONFIG.DAILY_VISIT_LIMIT) {
          await chrome.storage.local.set({
            status: 'SAFETY_PAUSE',
            safetyPauseReason: 'Daily visit limit reached. Safety pause engaged.'
          });
        }
        sendResponse({ success: true, todayVisitCount: newCount });
      } else if (request.action === 'RECORD_LEAD_SUCCESS') {
        const data = await chrome.storage.local.get(['todayScrapedCount']);
        const newCount = (data.todayScrapedCount || 0) + 1;
        await chrome.storage.local.set({ todayScrapedCount: newCount });

        if (newCount >= DEFAULT_CONFIG.DAILY_SCRAPE_LIMIT) {
          await chrome.storage.local.set({
            status: 'SAFETY_PAUSE',
            safetyPauseReason: 'Daily scrape limit reached. Safety pause engaged.'
          });
        }
        sendResponse({ success: true, todayScrapedCount: newCount });
      } else if (request.action === 'NAVIGATE_TO_URL') {
        const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
        if (tab) {
          await chrome.tabs.update(tab.id, { url: request.url });
        } else {
          await chrome.tabs.create({ url: request.url });
        }
        sendResponse({ success: true });
      }
    } catch (err) {
      console.error('[Background Message Error]', err);
      sendResponse({ success: false, error: err.message });
    }
  })();
  return true; // Asynchronous response support
});