background.js

// Background service worker for browsing time tracking

let activeTabId = null;
let activeTabStartTime = null;
let activeTabDomain = null;
let isIdle = false;
let idleStartTime = null;

const IDLE_THRESHOLD = 60; // 60 seconds to trigger idle state

// Initialize on extension load
chrome.runtime.onStartup.addListener(() => {
  checkAndResetDailyData();
  initializeTracking();
});

chrome.runtime.onInstalled.addListener(() => {
  checkAndResetDailyData();
  initializeTracking();
});

// Initialize tracking
async function initializeTracking() {
  // Get currently active tab
  const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
  if (tabs.length > 0) {
    handleTabActivated(tabs[0]);
  }
  
  // Set up idle detection
  chrome.idle.setDetectionInterval(IDLE_THRESHOLD);
  chrome.idle.onStateChanged.addListener(handleIdleStateChange);
}

// Check if we need to reset data for a new day
async function checkAndResetDailyData() {
  const today = new Date().toISOString().split('T')[0];
  const data = await chrome.storage.local.get(['lastResetDate', 'siteData']);
  
  if (data.lastResetDate !== today) {
    // Reset for new day
    await chrome.storage.local.set({
      siteData: {},
      lastResetDate: today
    });
    console.log('Data reset for new day:', today);
  }
}

// Handle tab activation
chrome.tabs.onActivated.addListener(async (activeInfo) => {
  if (isIdle) return; // Don't track when idle
  
  // Save time for previous tab
  await saveActiveTabTime();
  
  // Get the newly activated tab
  const tab = await chrome.tabs.get(activeInfo.tabId);
  handleTabActivated(tab);
});

// Handle tab updates (URL changes)
chrome.tabs.onUpdated.addListener(async (tabId, changeInfo, tab) => {
  if (isIdle) return;
  if (tabId !== activeTabId) return;
  if (!changeInfo.url) return;
  
  // Save time for previous URL
  await saveActiveTabTime();
  
  // Start tracking new URL
  handleTabActivated(tab);
});

// Handle tab removal
chrome.tabs.onRemoved.addListener(async (tabId) => {
  if (tabId === activeTabId) {
    await saveActiveTabTime();
    activeTabId = null;
    activeTabStartTime = null;
    activeTabDomain = null;
  }
});

// Handle window focus changes
chrome.windows.onFocusChanged.addListener(async (windowId) => {
  if (isIdle) return;
  
  if (windowId === chrome.windows.WINDOW_ID_NONE) {
    // Window lost focus, save current tab time
    await saveActiveTabTime();
    activeTabId = null;
    activeTabStartTime = null;
    activeTabDomain = null;
  } else {
    // Window gained focus, get active tab
    const tabs = await chrome.tabs.query({ active: true, windowId: windowId });
    if (tabs.length > 0) {
      await saveActiveTabTime();
      handleTabActivated(tabs[0]);
    }
  }
});

// Handle idle state changes
async function handleIdleStateChange(newState) {
  console.log('Idle state changed:', newState);
  
  if (newState === 'active') {
    // User is active again
    if (isIdle && idleStartTime) {
      const idleDuration = Date.now() - idleStartTime;
      console.log('User was idle for:', Math.round(idleDuration / 1000), 'seconds');
    }
    isIdle = false;
    idleStartTime = null;
    
    // Resume tracking
    const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
    if (tabs.length > 0) {
      handleTabActivated(tabs[0]);
    }
  } else {
    // User is idle or locked
    isIdle = true;
    idleStartTime = Date.now();
    
    // Save current tab time
    await saveActiveTabTime();
    activeTabId = null;
    activeTabStartTime = null;
    activeTabDomain = null;
  }
}

// Extract domain from URL
function getDomainFromUrl(url) {
  if (!url) return null;
  
  try {
    const urlObj = new URL(url);
    return urlObj.hostname.replace(/^www\./, '');
  } catch (e) {
    return null;
  }
}

// Handle tab activation
function handleTabActivated(tab) {
  if (!tab || !tab.url) return;
  
  const domain = getDomainFromUrl(tab.url);
  if (!domain) return;
  
  // Ignore chrome:// and extension:// URLs
  if (tab.url.startsWith('chrome://') || 
      tab.url.startsWith('chrome-extension://') ||
      tab.url.startsWith('edge://') ||
      tab.url.startsWith('about:') ||
      tab.url.startsWith('file://')) {
    return;
  }
  
  activeTabId = tab.id;
  activeTabStartTime = Date.now();
  activeTabDomain = domain;
  
  console.log('Tracking started for:', domain);
}

// Save time for active tab
async function saveActiveTabTime() {
  if (!activeTabId || !activeTabStartTime || !activeTabDomain) return;
  
  const endTime = Date.now();
  const duration = Math.round((endTime - activeTabStartTime) / 1000); // Convert to seconds
  
  if (duration < 1) return; // Ignore very short visits
  
  // Get current data
  const data = await chrome.storage.local.get(['siteData']);
  const siteData = data.siteData || {};
  
  // Add time to domain
  siteData[activeTabDomain] = (siteData[activeTabDomain] || 0) + duration;
  
  // Save updated data
  await chrome.storage.local.set({ siteData });
  
  console.log(`Saved ${duration}s for ${activeTabDomain}. Total: ${siteData[activeTabDomain]}s`);
}

// Message handler for popup
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
  if (request.type === 'GET_DATA') {
    chrome.storage.local.get(['siteData', 'lastResetDate']).then(data => {
      // Include current active tab time if any
      let currentExtraTime = 0;
      if (activeTabDomain && activeTabStartTime && !isIdle) {
        currentExtraTime = Math.round((Date.now() - activeTabStartTime) / 1000);
      }
      
      sendResponse({
        siteData: data.siteData || {},
        lastResetDate: data.lastResetDate,
        currentDomain: activeTabDomain,
        currentExtraTime: currentExtraTime,
        isIdle: isIdle
      });
    });
    return true; // Keep message channel open for async
  }
  
  if (request.type === 'EXPORT_CSV') {
    exportToCSV().then(csv => {
      sendResponse({ csv });
    });
    return true;
  }
  
  if (request.type === 'RESET_DATA') {
    chrome.storage.local.set({
      siteData: {},
      lastResetDate: new Date().toISOString().split('T')[0]
    }).then(() => {
      sendResponse({ success: true });
    });
    return true;
  }
});

// Export data to CSV
async function exportToCSV() {
  const data = await chrome.storage.local.get(['siteData', 'lastResetDate']);
  const siteData = data.siteData || {};
  const date = data.lastResetDate || new Date().toISOString().split('T')[0];
  
  let csv = 'Domain,Time (HH:MM),Total Seconds\n';
  
  // Sort by time spent (descending)
  const sortedDomains = Object.entries(siteData)
    .sort((a, b) => b[1] - a[1]);
  
  for (const [domain, seconds] of sortedDomains) {
    const hours = Math.floor(seconds / 3600);
    const mins = Math.floor((seconds % 3600) / 60);
    const timeStr = `${hours.toString().padStart(2, '0')}:${mins.toString().padStart(2, '0')}`;
    csv += `"${domain}","${timeStr}",${seconds}\n`;
  }
  
  return { csv, date };
}

// Periodically save active tab time (every 30 seconds)
setInterval(async () => {
  if (activeTabId && activeTabStartTime && !isIdle) {
    await saveActiveTabTime();
    activeTabStartTime = Date.now(); // Reset start time
  }
}, 30000);

// Check for daily reset every hour
setInterval(() => {
  checkAndResetDailyData();
}, 3600000);