// Browser games that actually work offline — test harness.
//
// For each game: open it once online in a fresh Chrome profile and give it time
// to install any offline support; reload once so a service worker can take
// control; then cut the network and reload. Record what loads online and
// offline, whether the game appears offline, whether it can be installed, and
// every outside request made while online. The HTTP cache is cleared before
// the offline reload (see below). Nothing is clicked except
// itch.io's own "Run game" button (see pressPlay).
//
//   node offline-test.cjs games.tsv out/ [settleSeconds=20]
//
// games.tsv: label<TAB>url[<TAB>...] per line; # comments allowed. candidates.tsv
// works too: its header is skipped, and so is any row whose fifth column is not OK.
// Writes out/<label>.json and out/<label>-offline.png.
//
// Process hygiene: one browser at a time, closed in finally and on
// SIGTERM/SIGINT, killed on exit; every test has a hard timeout.
const fs = require('node:fs');
const path = require('node:path');
const { chromium } = require(process.env.PLAYWRIGHT || 'playwright');

const [, , listFile, outDir, settleArg] = process.argv;
const SETTLE_MS = (Number(settleArg) || 20) * 1000;
const TEST_TIMEOUT_MS = SETTLE_MS * 2 + 90_000;
const CHROME = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';

let browser = null;
process.on('SIGTERM', async () => { try { await browser?.close(); } catch {} process.exit(1); });
process.on('SIGINT', async () => { try { await browser?.close(); } catch {} process.exit(1); });
process.on('exit', () => { try { browser?.process?.()?.kill('SIGKILL'); } catch {} });

// itch.io web games start only after the player presses "Run game". Pressing the
// site's own play button is the one click this test makes, and it is made after
// every load, online and offline, so each game is judged on the game itself.
async function pressPlay(page, url) {
  if (!/\.itch\.io$/.test(new URL(url).hostname)) return false;
  const btn = await page.$('.load_iframe_btn').catch(() => null);
  if (!btn) return false;
  await btn.click().catch(() => {});
  await page.waitForTimeout(8000);
  return true;
}

const race = (p, ms, fallback) => Promise.race([p, new Promise((r) => setTimeout(() => r(fallback), ms))]);

// What is on screen: enough to tell a game from an error page or an empty shell.
async function snapshot(page) {
  const frames = [];
  for (const f of page.frames().slice(0, 20)) {
    const info = await race(f.evaluate(() => ({
      canvases: [...document.querySelectorAll('canvas')].filter((c) => c.width * c.height > 10000).length,
      text: (document.body?.innerText || '').trim().length,
      title: document.title,
    })).catch(() => null), 3000, null);
    frames.push({ url: f.url().slice(0, 300), error: f.url().startsWith('chrome-error://'), ...(info || {}) });
  }
  return { url: page.url(), title: await page.title().catch(() => null), frames,
    error_page: page.url().startsWith('chrome-error://') };
}

async function test(label, url) {
  browser = await chromium.launch({ executablePath: CHROME, headless: true,
    args: ['--disable-blink-features=AutomationControlled'] });
  try {
    const major = browser.version().split('.')[0];
    const ctx = await browser.newContext({
      viewport: { width: 1280, height: 800 }, locale: 'en-US', timezoneId: 'America/New_York',
      userAgent: `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36`,
    });
    const online = [];
    let offlinePhase = false;
    const offline = [];
    ctx.on('requestfinished', (req) => (offlinePhase ? offline : online).push({ url: req.url(), type: req.resourceType(), ok: true }));
    ctx.on('requestfailed', (req) => (offlinePhase ? offline : online).push({ url: req.url(), type: req.resourceType(), ok: false, error: req.failure()?.errorText || null }));
    const page = await ctx.newPage();
    let status = null, error = null;
    try { const r = await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 45_000 }); status = r?.status() ?? null; }
    catch (e) { error = String(e.message || e).slice(0, 200); }
    const pressed = await pressPlay(page, url);
    await page.waitForTimeout(SETTLE_MS);
    await page.reload({ waitUntil: 'domcontentloaded', timeout: 45_000 }).catch(() => {});
    await page.waitForTimeout(5000);
    await pressPlay(page, url);
    const onlineView = await snapshot(page);
    const install = await race(page.evaluate(async () => {
      const link = document.querySelector('link[rel="manifest"]');
      let manifest = null;
      if (link) { try { manifest = await (await fetch(link.href)).json(); } catch { manifest = 'unreadable'; } }
      const regs = navigator.serviceWorker ? await navigator.serviceWorker.getRegistrations() : [];
      return { manifest_url: link?.href || null, manifest,
        service_workers: regs.length, controlled: !!navigator.serviceWorker?.controller };
    }).catch(() => null), 8000, null);

    // Clear the ordinary HTTP cache before going offline, so a game only passes on
    // what it deliberately stored for offline use (service worker caches, app
    // storage), not on copies that would expire minutes later. Without this, a
    // reload seconds after the visit can be served from short-lived cache.
    const cdp = await ctx.newCDPSession(page);
    await cdp.send('Network.clearBrowserCache').catch(() => {});
    offlinePhase = true;
    await ctx.setOffline(true);
    let offlineError = null;
    try { await page.reload({ waitUntil: 'domcontentloaded', timeout: 30_000 }); }
    catch (e) { offlineError = String(e.message || e).slice(0, 200); }
    await pressPlay(page, url);
    await page.waitForTimeout(10_000);
    const offlineView = await snapshot(page);
    await page.screenshot({ path: path.join(outDir, `${label}-offline.png`) }).catch(() => {});
    return { label, url, tested_at: new Date().toISOString(), chrome: browser.version(), status, error,
      settle_s: SETTLE_MS / 1000, pressed_play: pressed, install, online_view: onlineView, offline_view: offlineView,
      offline_error: offlineError, online_requests: online, offline_requests: offline };
  } finally {
    await browser.close().catch(() => {});
    browser = null;
  }
}

(async () => {
  fs.mkdirSync(outDir, { recursive: true });
  const games = fs.readFileSync(listFile, 'utf8').split('\n').map((l) => l.trim())
    .filter((l) => l && !l.startsWith('#')).map((l) => l.split('\t'))
    .filter((c) => c[0] !== 'label' && (c.length < 5 || c[4].startsWith('OK')));
  for (const [label, url] of games) {
    const out = path.join(outDir, `${label}.json`);
    if (fs.existsSync(out)) continue;
    let timer;
    try {
      const r = await Promise.race([test(label, url),
        new Promise((_, rej) => { timer = setTimeout(() => rej(new Error('test timeout')), TEST_TIMEOUT_MS); })]);
      fs.writeFileSync(out, JSON.stringify(r));
      const on = r.online_view.frames.reduce((a, f) => a + (f.canvases || 0), 0);
      const off = r.offline_view.frames.reduce((a, f) => a + (f.canvases || 0), 0);
      console.log(`${label}: online canvases ${on}, offline canvases ${off}, offline error page ${r.offline_view.error_page}, sw ${r.install?.service_workers ?? '?'}, manifest ${r.install?.manifest ? 'yes' : 'no'}`);
    } catch (e) {
      console.log(`FAIL ${label}: ${String(e.message || e).slice(0, 160)}`);
      try { await browser?.close(); } catch {} browser = null;
    } finally { clearTimeout(timer); }
  }
  process.exit(0);
})();