background.js

// Service worker: orchestrates the hidden helper tab through pahe.win -> kwik -> .mp4.
//
// The MV3 service worker can be terminated between events, so all in-flight state lives in
// chrome.storage.session (re-read on every event) rather than in module variables.
//
// Requests are serialized (one in flight at a time; extra clicks queue) because
// chrome.downloads.onCreated does NOT reliably report the initiating tab — with a single active
// request, matching the new download to its helper tab is unambiguous.
importScripts('config.js');
const CFG = globalThis.APD_CONFIG;
const B = CFG.behavior;

const REG_KEY = 'apd_registry'; // { [helperTabId]: { originTabId, state, startedAt, downloadId } }
const QUEUE_KEY = 'apd_queue'; // [ { paheUrl, originTabId } ]

const getReg = async () => (await chrome.storage.session.get(REG_KEY))[REG_KEY] || {};
const setReg = (reg) => chrome.storage.session.set({ [REG_KEY]: reg });
const getQueue = async () => (await chrome.storage.session.get(QUEUE_KEY))[QUEUE_KEY] || [];
const setQueue = (q) => chrome.storage.session.set({ [QUEUE_KEY]: q });

async function hasActive() {
  return Object.keys(await getReg()).length > 0;
}

async function notify(originTabId, state, detail) {
  if (originTabId == null) return;
  try {
    await chrome.tabs.sendMessage(originTabId, { type: 'APD_STATUS', state, detail });
  } catch (e) {
    /* origin tab gone; ignore */
  }
}

// Start the next queued request if nothing is currently active.
async function pump() {
  if (await hasActive()) return;
  const q = await getQueue();
  if (!q.length) return;
  const next = q.shift();
  await setQueue(q);
  await beginRequest(next);
}

async function beginRequest({ paheUrl, originTabId }) {
  const tab = await chrome.tabs.create({ url: paheUrl, active: false });
  const reg = await getReg();
  reg[tab.id] = { originTabId, state: 'pahe', startedAt: Date.now(), downloadId: null };
  await setReg(reg);
  await notify(originTabId, 'opening');
  // Watchdog: if this request hasn't produced a download in time, reveal/clean it up.
  setTimeout(() => failRequest(tab.id), B.overallTimeoutMs);
}

async function failRequest(tabId) {
  const reg = await getReg();
  const entry = reg[tabId];
  if (!entry || entry.downloadId != null) return; // already resolved / download is underway
  await notify(entry.originTabId, 'manual');
  if (B.revealTabOnFailure) {
    try {
      await chrome.tabs.update(tabId, { active: true });
      const t = await chrome.tabs.get(tabId);
      await chrome.windows.update(t.windowId, { focused: true });
    } catch (e) {
      /* tab gone */
    }
  }
  delete reg[tabId];
  await setReg(reg);
  pump();
}

async function closeHelper(tabId) {
  const reg = await getReg();
  if (!reg[tabId]) return;
  delete reg[tabId];
  await setReg(reg);
  try {
    await chrome.tabs.remove(Number(tabId));
  } catch (e) {
    /* already closed */
  }
  pump();
}

// --- messages from content scripts ---
chrome.runtime.onMessage.addListener((msg, sender) => {
  (async () => {
    if (!msg) return;

    if (msg.type === 'APD_START') {
      const q = await getQueue();
      q.push({ paheUrl: msg.paheUrl, originTabId: sender.tab ? sender.tab.id : null });
      await setQueue(q);
      pump();
      return;
    }

    const tabId = sender.tab ? sender.tab.id : null;
    if (tabId == null) return;
    const reg = await getReg();
    if (!reg[tabId]) return;

    if (msg.type === 'APD_PROGRESS') {
      await notify(reg[tabId].originTabId, msg.stage);
    } else if (msg.type === 'APD_KWIK_READY') {
      reg[tabId].state = 'kwik-submit';
      await setReg(reg);
      await notify(reg[tabId].originTabId, 'submitting', msg.detail);
    } else if (msg.type === 'APD_FAIL') {
      await failRequest(tabId);
    }
  })();
  return false;
});

// --- download lifecycle ---
chrome.downloads.onCreated.addListener((item) => {
  (async () => {
    const reg = await getReg();
    const ids = Object.keys(reg);
    if (!ids.length) return;
    // Serialized => at most one active request. Only attach to the request that just submitted the
    // kwik form (state 'kwik-submit'), so an unrelated download started while our helper tab is still
    // clearing Cloudflare on pahe.win/kwik is never misattributed to us.
    const tabId = ids.find((id) => reg[id].state === 'kwik-submit');
    if (!tabId) return;
    reg[tabId].downloadId = item.id;
    reg[tabId].state = 'downloading';
    await setReg(reg);
    await notify(reg[tabId].originTabId, 'started');
    // Don't close immediately (would abort the in-flight request). Fallback close after a delay.
    setTimeout(() => closeHelper(tabId), B.closeTabAfterMs);
  })();
});

chrome.downloads.onChanged.addListener((delta) => {
  (async () => {
    const reg = await getReg();
    const tabId = Object.keys(reg).find((id) => reg[id].downloadId === delta.id);
    if (!tabId) return;
    const fname = delta.filename && delta.filename.current;
    if (fname) {
      await notify(reg[tabId].originTabId, 'downloading', fname.split(/[\\/]/).pop());
    }
    const done = fname || (delta.state && delta.state.current === 'complete');
    if (done) closeHelper(tabId); // the browser now owns the file; the helper tab can go
  })();
});

// Clean up the registry if a helper tab is closed (by us or the user).
chrome.tabs.onRemoved.addListener((tabId) => {
  (async () => {
    const reg = await getReg();
    if (reg[tabId]) {
      delete reg[tabId];
      await setReg(reg);
      pump();
    }
  })();
});