background.js

// background.js

// Helper function to format a Date object as "YYYY.MM.DD HH:MM:SS"
function formatDateTime(date) {
  const yyyy = date.getFullYear();
  const mm = String(date.getMonth() + 1).padStart(2, '0');
  const dd = String(date.getDate()).padStart(2, '0');
  const hh = String(date.getHours()).padStart(2, '0');
  const mi = String(date.getMinutes()).padStart(2, '0');
  const ss = String(date.getSeconds()).padStart(2, '0');
  return `${yyyy}.${mm}.${dd} ${hh}:${mi}:${ss}`;
}

// Save the current session (all windows and their tab URLs).
// Measures the time required and stores it in the session data as "saveDuration".

// Helper to purge sessions in memory.
// Respects "locked" property: locked sessions are ALWAYS kept.
function purgeSessionsInMemory(sessions, currentDate) {
  // Helper to get YYYY-MM from "YYYY-MM-DD"
  const getMonthStr = (dateStr) => dateStr.substring(0, 7);
  const currentMonth = getMonthStr(currentDate);

  const sessionsByDay = {};
  const sessionsByMonth = {};
  const sessionsToKeepMap = new Map();

  // 1. Identify and keep ALL locked sessions immediately.
  sessions.forEach(session => {
    if (session.locked) {
      sessionsToKeepMap.set(session.id, session);
    }
  });

  // Separate sessions not from today
  const pastSessions = sessions.filter(s => s.date !== currentDate);
  const todaySessions = sessions.filter(s => s.date === currentDate);

  pastSessions.forEach(session => {
    if (!session.date) return; // Guard against missing date
    const sessionMonth = getMonthStr(session.date);
    if (sessionMonth === currentMonth) {
      // For current month, group by day
      if (!sessionsByDay[session.date]) {
        sessionsByDay[session.date] = [];
      }
      sessionsByDay[session.date].push(session);
    } else {
      // For previous months, group by month
      if (!sessionsByMonth[sessionMonth]) {
        sessionsByMonth[sessionMonth] = [];
      }
      sessionsByMonth[sessionMonth].push(session);
    }
  });

  // 2. Keep latest session for each past day of current month
  for (const date in sessionsByDay) {
    const group = sessionsByDay[date];
    if (group.length > 0) {
      const lastSession = group.reduce((a, b) => (a.id > b.id ? a : b));
      sessionsToKeepMap.set(lastSession.id, lastSession);
    }
  }

  // 3. Keep latest session for each previous month
  for (const month in sessionsByMonth) {
    const group = sessionsByMonth[month];
    if (group.length > 0) {
      const lastSession = group.reduce((a, b) => (a.id > b.id ? a : b));
      sessionsToKeepMap.set(lastSession.id, lastSession);
    }
  }

  // 4. Keep all sessions from today
  todaySessions.forEach(session => {
    sessionsToKeepMap.set(session.id, session);
  });

  // Convert Map back to array
  const newSessions = Array.from(sessionsToKeepMap.values());

  // Sort by ID to keep storage tidy
  newSessions.sort((a, b) => a.id - b.id);

  return newSessions;
}

// Perform a manual purge (Daily or Monthly) on ALL sessions.
function performManualPurge(sessions, type) {
  const sessionsToKeepMap = new Map();
  const getMonthStr = (dateStr) => dateStr ? dateStr.substring(0, 7) : "unknown";

  // 1. Keep ALL locked sessions
  sessions.forEach(session => {
    if (session.locked) {
      sessionsToKeepMap.set(session.id, session);
    }
  });

  const groups = {};

  // 2. Group sessions
  sessions.forEach(session => {
    if (!session.date) return;
    let key;
    if (type === 'daily') {
      key = session.date; // Group by YYYY-MM-DD
    } else if (type === 'monthly') {
      key = getMonthStr(session.date); // Group by YYYY-MM
    }

    if (!groups[key]) {
      groups[key] = [];
    }
    groups[key].push(session);
  });

  // 3. Keep latest for each group
  for (const key in groups) {
    const group = groups[key];
    if (group.length > 0) {
      const lastSession = group.reduce((a, b) => (a.id > b.id ? a : b));
      sessionsToKeepMap.set(lastSession.id, lastSession);
    }
  }

  const newSessions = Array.from(sessionsToKeepMap.values());
  newSessions.sort((a, b) => a.id - b.id);
  return newSessions;
}

// Global timer for debouncing auto-saves
let autoSaveTimer = null;
const AUTO_SAVE_DELAY = 5000; // 5 seconds

// State to track if we are currently restoring a session or starting up
let isRestoring = false;
let restoringTimer = null;
const RESTORE_PAUSE_DURATION = 15 * 60 * 1000; // 15 Minutes

// Helper to set restoring state
function setRestoringState() {
  isRestoring = true;
  console.log("Pausing auto-save for restore/startup for 15 minutes...");

  if (restoringTimer) {
    clearTimeout(restoringTimer);
  }

  // If there was a pending auto-save, cancel it
  if (autoSaveTimer) {
    clearTimeout(autoSaveTimer);
    autoSaveTimer = null;
  }

  restoringTimer = setTimeout(() => {
    isRestoring = false;
    console.log("Resuming auto-save capability.");
    restoringTimer = null;
  }, RESTORE_PAUSE_DURATION);
}

// Trigger an auto-save with debounce.
function triggerAutoSave() {
  if (isRestoring) {
    console.log("Auto-save ignored because session is restoring or browser just started.");
    return;
  }

  if (autoSaveTimer) {
    clearTimeout(autoSaveTimer);
  }
  autoSaveTimer = setTimeout(() => {
    saveSession();
    autoSaveTimer = null;
  }, AUTO_SAVE_DELAY);
}

// 1. Chrome Startup Handler
chrome.runtime.onStartup.addListener(() => {
  setRestoringState();
});

// Save the current session (all windows and their tab URLs).
// Measures the time required and stores it in the session data as "saveDuration".
function saveSession(callback) {
  // If a manual save (or any save) happens, clear any pending auto-save to avoid double saving.
  if (autoSaveTimer) {
    clearTimeout(autoSaveTimer);
    autoSaveTimer = null;
  }

  const startTime = performance.now();
  const now = new Date();
  const currentDate = now.toISOString().split("T")[0]; // e.g., "2025-03-05"

  // Get all windows with their tabs.
  chrome.windows.getAll({ populate: true }, function (windows) {
    // Process each window: store only each tab's URL.
    const processedWindows = windows.map(win => ({
      tabs: win.tabs.map(tab => ({ url: tab.url }))
    }));

    // Build the session data.
    const sessionData = {
      id: now.getTime(),               // Unique session ID.
      timestamp: formatDateTime(now),    // Formatted date/time string.
      date: currentDate,               // Used for purging.
      windows: processedWindows,
      saveDuration: 0,                 // Placeholder.
      locked: false                    // Default locked state
    };

    chrome.storage.local.get({ savedSessions: [] }, function (result) {
      let sessions = result.savedSessions;

      // Push the new session data.
      sessions.push(sessionData);

      // Purge sessions in memory immediately.
      sessions = purgeSessionsInMemory(sessions, currentDate);

      // First, store the session array.
      chrome.storage.local.set({ savedSessions: sessions }, function () {
        // Now measure the duration.
        const endTime = performance.now();
        const duration = endTime - startTime;

        // Update the duration on the session object (reference is preserved in the array).
        sessionData.saveDuration = duration.toFixed(2);

        // Save the updated sessions array.
        chrome.storage.local.set({ savedSessions: sessions }, function () {
          console.log("Session saved at", sessionData.timestamp, "in", sessionData.saveDuration, "ms");
          console.log("Total sessions kept:", sessions.length);

          if (typeof callback === "function") {
            callback(sessionData);
          }
        });
      });
    });
  });
}

// Helper to check if a URL is a "new tab" URL or internal page to ignore
// Helper to check if a URL is a "new tab" URL or internal page to ignore
function isNewTabUrl(url) {
  if (!url) return true;
  return url === 'about:blank' ||
    url === 'edge://newtab/' ||
    url.startsWith('chrome://') ||
    url.startsWith('chrome-extension://');
}

// Auto-save the session when a new tab or window is explicitly created.
// Update: Ignore "newtab" creation to prevent spamming sessions with just an empty tab.
chrome.tabs.onCreated.addListener((tab) => {
  // Check if the tab is a "new tab" page.
  // Note: tab.url requires "tabs" permission (which we have).
  // pendingUrl is often set for tabs that are about to navigate.
  const urlToCheck = tab.pendingUrl || tab.url;

  if (isNewTabUrl(urlToCheck)) {
    console.log("Skipping auto-save for new empty tab (onCreated):", tab.id);
    return;
  }

  triggerAutoSave();
});

// Auto-save when a tab is updated (e.g. navigation finished).
// REMOVED as per user request to reduce save frequency. 
// Old behavior: Only save on creation.
/*
chrome.tabs.onUpdated.addListener((tabId, changeInfo, tab) => {
  // Only save when loading is complete to avoid partial states
  if (changeInfo.status === 'complete') {
    if (!isNewTabUrl(tab.url)) {
      triggerAutoSave();
    }
  }
});
*/

chrome.windows.onCreated.addListener(triggerAutoSave);

// Listen for messages from the popup.
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
  if (message.action === "manualSaveSession") {
    saveSession((sessionData) => {
      sendResponse({ status: "success", session: sessionData });
    });
    return true; // Indicates asynchronous response.
  } else if (message.action === "purgeDaily") {
    chrome.storage.local.get({ savedSessions: [] }, function (result) {
      const newSessions = performManualPurge(result.savedSessions, 'daily');
      chrome.storage.local.set({ savedSessions: newSessions }, function () {
        sendResponse({ status: "success", count: newSessions.length });
      });
    });
    return true;
  } else if (message.action === "purgeMonthly") {
    chrome.storage.local.get({ savedSessions: [] }, function (result) {
      const newSessions = performManualPurge(result.savedSessions, 'monthly');
      chrome.storage.local.set({ savedSessions: newSessions }, function () {
        sendResponse({ status: "success", count: newSessions.length });
      });
    });
    return true;
  } else if (message.action === "purgeDuplicates") {
    chrome.storage.local.get({ savedSessions: [] }, function (result) {
      let sessions = result.savedSessions;
      let removedCount = 0;

      sessions.forEach(session => {
        if (session.locked) return;

        const seenUrls = new Set();

        session.windows.forEach(win => {
          if (!win.tabs) return;

          const originalLength = win.tabs.length;
          win.tabs = win.tabs.filter(tab => {
            const url = tab.url;
            if (seenUrls.has(url)) {
              return false; // Duplicate
            }
            seenUrls.add(url);
            return true;
          });
          removedCount += (originalLength - win.tabs.length);
        });

        // Cleanup empty windows
        session.windows = session.windows.filter(win => win.tabs && win.tabs.length > 0);
      });

      // Cleanup empty sessions (optional)
      // sessions = sessions.filter(s => s.locked || (s.windows && s.windows.length > 0)); 

      chrome.storage.local.set({ savedSessions: sessions }, function () {
        sendResponse({ status: "success", count: removedCount });
      });
    });
    return true;
  }
});

console.log("Background script for Tab Session Manager initialized.");