background.js

let activeTabId = null;
let activeUrl = null;
let activeHostname = null;
let startTime = null;
let trackingInterval = null;

// Track active tab changes
chrome.tabs.onActivated.addListener(async (activeInfo) => {
  await handleTabChange(activeInfo.tabId);
});

// Track URL changes within tabs
chrome.tabs.onUpdated.addListener(async (tabId, changeInfo, tab) => {
  if (tabId === activeTabId && changeInfo.url) {
    await updateTimeSpent();
    setActiveTab(tabId, tab.url);
  }
});

// Track when Chrome becomes active/inactive
chrome.windows.onFocusChanged.addListener(async (windowId) => {
  if (windowId === chrome.windows.WINDOW_ID_NONE) {
    // Chrome lost focus
    await updateTimeSpent();
    resetActiveTab();
    stopTrackingInterval();
  } else {
    // Chrome gained focus
    const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
    if (tabs.length > 0) {
      await handleTabChange(tabs[0].id);
    }
  }
});

// Set up persistent tracking using intervals
function startTrackingInterval() {
  if (trackingInterval) {
    clearInterval(trackingInterval);
  }
  
  // Update time spent every 5 seconds to ensure accuracy
  trackingInterval = setInterval(async () => {
    await updateTimeSpent();
    // Reset start time to current time without changing the active site
    if (activeHostname) {
      startTime = Date.now();
    }
  }, 5000);
}

function stopTrackingInterval() {
  if (trackingInterval) {
    clearInterval(trackingInterval);
    trackingInterval = null;
  }
}

// Set up daily reset alarm at midnight
chrome.alarms.create("dailyReset", {
  periodInMinutes: 1440, // 24 hours
  when: getNextMidnight()
});

// Listen for the alarm
chrome.alarms.onAlarm.addListener((alarm) => {
  if (alarm.name === "dailyReset") {
    handleDailyReset();
  }
});

// Get the timestamp for the next midnight
function getNextMidnight() {
  const now = new Date();
  const midnight = new Date(now);
  midnight.setHours(24, 0, 0, 0);
  return midnight.getTime();
}

// Reset daily stats and update weekly/monthly as needed
async function handleDailyReset() {
  // First update any active session
  await updateTimeSpent();

  const today = new Date();
  const data = await getStoredData();
  
  // Store yesterday's data in history
  const yesterday = new Date(today);
  yesterday.setDate(yesterday.getDate() - 1);
  const dateStr = formatDate(yesterday);
  
  if (!data.history) data.history = {};
  data.history[dateStr] = { ...data.daily };
  
  // Reset daily stats
  data.daily = {};
  
  // Check if we need to reset weekly stats (on Mondays)
  if (today.getDay() === 1) { // Monday
    data.weekly = {};
  } else {
    // Update weekly from daily data
    await updateAggregateStats(data.daily, data.weekly);
  }
  
  // Check if we need to reset monthly stats (on the 1st)
  if (today.getDate() === 1) {
    data.monthly = {};
  } else {
    // Update monthly from daily data
    await updateAggregateStats(data.daily, data.monthly);
  }
  
  await chrome.storage.local.set({ data });
}

// Update aggregate (weekly/monthly) stats
async function updateAggregateStats(sourceData, targetData) {
  Object.keys(sourceData).forEach(hostname => {
    if (!targetData[hostname]) {
      targetData[hostname] = sourceData[hostname];
    } else {
      targetData[hostname] += sourceData[hostname];
    }
  });
}

// Format date as YYYY-MM-DD
function formatDate(date) {
  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')}`;
}

// Handle tab change
async function handleTabChange(tabId) {
  await updateTimeSpent();
  
  try {
    const tab = await chrome.tabs.get(tabId);
    if (tab.active) {
      setActiveTab(tabId, tab.url);
      startTrackingInterval(); // Start tracking interval when tab changes
    }
  } catch (error) {
    console.error("Error getting tab info:", error);
    resetActiveTab();
    stopTrackingInterval();
  }
}

// Set active tab information
function setActiveTab(tabId, url) {
  try {
    activeTabId = tabId;
    activeUrl = url;
    
    // Extract hostname
    if (url && url.startsWith('http')) {
      const urlObj = new URL(url);
      activeHostname = urlObj.hostname;
    } else {
      activeHostname = "chrome://";
    }
    
    startTime = Date.now();
  } catch (error) {
    console.error("Error setting active tab:", error);
    resetActiveTab();
  }
}

// Reset active tab tracking
function resetActiveTab() {
  activeTabId = null;
  activeUrl = null;
  activeHostname = null;
  startTime = null;
}

// Update time spent on current site
async function updateTimeSpent() {
  if (activeHostname && startTime) {
    const timeSpent = Date.now() - startTime;
    
    // Only log if more than 1 second was spent
    if (timeSpent > 1000) {
      const data = await getStoredData();
      
      // Update daily stats
      if (!data.daily[activeHostname]) {
        data.daily[activeHostname] = 0;
      }
      data.daily[activeHostname] += timeSpent;
      
      // Update weekly stats
      if (!data.weekly[activeHostname]) {
        data.weekly[activeHostname] = 0;
      }
      data.weekly[activeHostname] += timeSpent;
      
      // Update monthly stats
      if (!data.monthly[activeHostname]) {
        data.monthly[activeHostname] = 0;
      }
      data.monthly[activeHostname] += timeSpent;
      
      await chrome.storage.local.set({ data });
      
      // For debugging - log to console
      console.log(`Updated ${activeHostname}: +${formatTime(timeSpent)} (total: ${formatTime(data.daily[activeHostname])})`);
    }
  }
}

// Format milliseconds into human-readable time for logging
function formatTime(milliseconds) {
  const seconds = Math.floor(milliseconds / 1000);
  
  if (seconds < 60) {
    return `${seconds}s`;
  }
  
  const minutes = Math.floor(seconds / 60);
  const remainingSeconds = seconds % 60;
  
  if (minutes < 60) {
    return `${minutes}m ${remainingSeconds}s`;
  }
  
  const hours = Math.floor(minutes / 60);
  const remainingMinutes = minutes % 60;
  return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
}

// Get stored time data
async function getStoredData() {
  const result = await chrome.storage.local.get('data');
  if (!result.data) {
    return {
      daily: {},
      weekly: {},
      monthly: {},
      history: {}
    };
  }
  return result.data;
}

// Initialize tracking when extension starts
chrome.runtime.onStartup.addListener(async () => {
  const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
  if (tabs.length > 0) {
    await handleTabChange(tabs[0].id);
  }
});

// Start tracking when extension is installed or updated
chrome.runtime.onInstalled.addListener(async () => {
  const tabs = await chrome.tabs.query({ active: true, currentWindow: true });
  if (tabs.length > 0) {
    await handleTabChange(tabs[0].id);
  }
});