background.js

const DEFAULT_CONFIG = {
  patterns: [],
  timeoutMessage: "Time's up. Get back to what matters.",
  defaultDurationMinutes: 20
};

const SESSION_KEY = "activeSessionsByTab";
const CONFIG_KEY = "settings";

async function getConfig() {
  const data = await browser.storage.local.get(CONFIG_KEY);
  return {
    ...DEFAULT_CONFIG,
    ...(data[CONFIG_KEY] || {})
  };
}

function getOrigin(url) {
  try {
    return new URL(url).origin;
  } catch (err) {
    return "";
  }
}

function matchesPattern(url, rawPattern) {
  if (!rawPattern || !rawPattern.trim()) {
    return false;
  }

  const pattern = rawPattern.trim();

  if (pattern.toLowerCase().startsWith("regex:")) {
    const regexBody = pattern.slice("regex:".length).trim();
    try {
      return new RegExp(regexBody).test(url);
    } catch (err) {
      return false;
    }
  }

  try {
    const escaped = pattern.replace(/[.+^${}()|[\\]\\]/g, "\\$&").replace(/\*/g, ".*");
    const regex = new RegExp(`^${escaped}$`);
    return regex.test(url);
  } catch (err) {
    return false;
  }
}

function isConfiguredUrl(url, config) {
  if (!url || !config.patterns.length) {
    return false;
  }

  return config.patterns.some((pattern) => matchesPattern(url, pattern));
}

async function getSessions() {
  const data = await browser.storage.local.get(SESSION_KEY);
  return data[SESSION_KEY] || {};
}

async function saveSessions(sessions) {
  await browser.storage.local.set({ [SESSION_KEY]: sessions });
}

async function createSession(tabId, url, durationSeconds) {
  const sessions = await getSessions();
  const expiresAt = Date.now() + durationSeconds * 1000;

  sessions[String(tabId)] = {
    url,
    origin: getOrigin(url),
    expiresAt
  };

  await saveSessions(sessions);
  await browser.alarms.create(`timer-${tabId}`, {
    when: expiresAt
  });

  return expiresAt;
}

async function clearSession(tabId) {
  const sessions = await getSessions();
  delete sessions[String(tabId)];
  await saveSessions(sessions);
  await browser.alarms.clear(`timer-${tabId}`);
}

async function getSession(tabId) {
  const sessions = await getSessions();
  return sessions[String(tabId)] || null;
}

async function ensureSessionValidity(tabId) {
  const session = await getSession(tabId);
  if (!session) {
    return null;
  }

  if (session.expiresAt <= Date.now()) {
    await clearSession(tabId);
    return null;
  }

  return session;
}

async function handleAlarm(alarm) {
  if (!alarm.name.startsWith("timer-")) {
    return;
  }

  const tabId = Number(alarm.name.replace("timer-", ""));
  if (Number.isNaN(tabId)) {
    return;
  }

  const session = await getSession(tabId);
  if (!session) {
    return;
  }

  const config = await getConfig();

  try {
    const tab = await browser.tabs.get(tabId);
    if (!tab || !tab.url || !isConfiguredUrl(tab.url, config)) {
      await clearSession(tabId);
      return;
    }

    const tabOrigin = getOrigin(tab.url);
    if (!tabOrigin || (session.origin && tabOrigin !== session.origin)) {
      await clearSession(tabId);
      return;
    }

    const messageParam = encodeURIComponent(config.timeoutMessage || DEFAULT_CONFIG.timeoutMessage);
    const redirectUrl = browser.runtime.getURL(`timeout.html?message=${messageParam}`);
    await browser.tabs.update(tabId, { url: redirectUrl });
  } catch (err) {
    // Tab may not exist anymore.
  } finally {
    await clearSession(tabId);
  }
}

browser.runtime.onInstalled.addListener(async () => {
  const data = await browser.storage.local.get(CONFIG_KEY);
  if (!data[CONFIG_KEY]) {
    await browser.storage.local.set({ [CONFIG_KEY]: DEFAULT_CONFIG });
  }
});

const toolbarAction = browser.browserAction || browser.action;
if (toolbarAction?.onClicked) {
  toolbarAction.onClicked.addListener(() => {
    browser.runtime.openOptionsPage();
  });
}

browser.runtime.onMessage.addListener(async (message, sender) => {
  if (!sender.tab || typeof sender.tab.id !== "number") {
    return null;
  }

  const tabId = sender.tab.id;

  if (message?.type === "PAGE_LOADED") {
    const config = await getConfig();
    const url = message.url || sender.tab.url || "";
    const enforced = isConfiguredUrl(url, config);
    let session = await ensureSessionValidity(tabId);

    if (session && session.origin && session.origin !== getOrigin(url)) {
      await clearSession(tabId);
      session = null;
    }

    return {
      enforced,
      hasActiveSession: Boolean(session),
      remainingMs: session ? Math.max(session.expiresAt - Date.now(), 0) : 0,
      defaultDurationMinutes: config.defaultDurationMinutes,
      timeoutMessage: config.timeoutMessage
    };
  }

  if (message?.type === "START_TIMER") {
    const config = await getConfig();
    const url = message.url || sender.tab.url || "";
    if (!isConfiguredUrl(url, config)) {
      return { ok: false, error: "URL is not configured for timer enforcement." };
    }

    const durationSeconds = Number(message.durationSeconds);
    if (!Number.isFinite(durationSeconds) || durationSeconds <= 0) {
      return { ok: false, error: "Invalid timer duration." };
    }

    const expiresAt = await createSession(tabId, url, durationSeconds);
    return { ok: true, expiresAt };
  }

  if (message?.type === "CLEAR_TIMER") {
    await clearSession(tabId);
    return { ok: true };
  }

  return null;
});

browser.tabs.onRemoved.addListener(async (tabId) => {
  await clearSession(tabId);
});

browser.alarms.onAlarm.addListener(handleAlarm);