import { readFile, writeFile } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import { join } from 'node:path';
import { preview } from 'vite';
import puppeteer from 'puppeteer';
import { discoverAllRoutes } from '../pages/discoverRoutes.js';

const allRoutes = discoverAllRoutes();

const DIST = 'dist/client';
const CONCURRENCY = Number(process.env.PRERENDER_CONCURRENCY) || 6;
const PAGE_TIMEOUT = 30000;
const RENDER_SETTLE_MS = 300;
const SELECTOR_TIMEOUT = 8000;
const RETRY =
  process.env.PRERENDER_RETRY === '1' || process.argv.includes('--retry');

function routeToFile(route) {
  if (route === '/') return join(DIST, 'index.html');
  return join(DIST, route.replace(/^\//, ''), 'index.html');
}

function fmtMs(ms) {
  if (ms < 1000) return `${ms}ms`;
  return `${(ms / 1000).toFixed(2)}s`;
}

function fmtSec(ms) {
  const s = ms / 1000;
  if (s < 60) return `${s.toFixed(2)}s`;
  const m = Math.floor(s / 60);
  return `${m}m ${(s - m * 60).toFixed(1)}s`;
}

async function crawlOne(browser, baseUrl, route) {
  const t0 = Date.now();
  const target = baseUrl + route;
  const file = routeToFile(route);
  if (!existsSync(file))
    return { route, skipped: 'no prerendered shell', ms: Date.now() - t0 };

  const page = await browser.newPage();
  try {
    const consoleErrors = [];
    // Images, fonts and media are aborted below to keep the crawl fast. The
    // browser reports every one of those as a failed load, so counting them
    // would just be counting our own optimisation — track what we blocked and
    // drop those messages, or the tally is pure noise that swings run to run.
    const blocked = new Set();
    page.on('console', (m) => {
      if (m.type() !== 'error') return;
      const url = m.location()?.url;
      if (url && blocked.has(url)) return;
      consoleErrors.push(m.text());
    });
    page.on('pageerror', (e) => consoleErrors.push(`page error: ${e.message}`));
    await page.setRequestInterception(true);
    page.on('request', (req) => {
      const t = req.resourceType();
      if (t === 'image' || t === 'font' || t === 'media') {
        blocked.add(req.url());
        return req.abort();
      }
      req.continue();
    });
    await page.goto(target, {
      waitUntil: 'domcontentloaded',
      timeout: PAGE_TIMEOUT,
    });
    try {
      await page.waitForSelector('#react-root > *', {
        timeout: SELECTOR_TIMEOUT,
      });
    } catch {
      return {
        route,
        skipped: `no children rendered within ${SELECTOR_TIMEOUT}ms`,
        ms: Date.now() - t0,
      };
    }
    await new Promise((r) => setTimeout(r, RENDER_SETTLE_MS));

    const rendered = await page.evaluate(() => {
      const root = document.getElementById('react-root');
      return root ? root.innerHTML : '';
    });

    if (!rendered)
      return { route, skipped: 'empty root after render', ms: Date.now() - t0 };

    const shell = await readFile(file, 'utf8');
    const replaced = shell.replace(
      /<div id="react-root"><\/div>/,
      `<div id="react-root">${rendered}</div>`,
    );
    if (replaced === shell) {
      return {
        route,
        skipped: 'root placeholder not found',
        ms: Date.now() - t0,
      };
    }
    await writeFile(file, replaced, 'utf8');
    return {
      route,
      bytes: rendered.length,
      errors: consoleErrors.length,
      messages: consoleErrors,
      ms: Date.now() - t0,
    };
  } catch (e) {
    return { route, error: e.message, ms: Date.now() - t0 };
  } finally {
    await page.close().catch(() => {});
  }
}

async function warmUp(baseUrl) {
  const deadline = Date.now() + 10000;
  while (Date.now() < deadline) {
    try {
      const res = await fetch(baseUrl + '/');
      if (res.ok) return Date.now();
    } catch {}
    await new Promise((r) => setTimeout(r, 200));
  }
  throw new Error('preview server did not respond within 10s');
}

function logRoute(r) {
  const t = fmtMs(r.ms ?? 0);
  if (r.error) {
    console.log(`  x ${r.route}: ${r.error} (${t})`);
  } else if (r.skipped) {
    console.log(`  - ${r.route}: ${r.skipped} (${t})`);
  } else {
    console.log(
      `  . ${r.route}  (${r.bytes} bytes, ${r.errors} console errors, ${t})`,
    );
  }
}

async function main() {
  const tStart = Date.now();
  console.log(
    `prerender-crawl: ${allRoutes.length} routes, concurrency ${CONCURRENCY}`,
  );

  const server = await preview({
    preview: { port: 4287, strictPort: true, host: '127.0.0.1' },
  });
  const url =
    server.resolvedUrls?.local?.[0]?.replace(/\/$/, '') ||
    'http://127.0.0.1:4287';
  console.log(`preview up at ${url}`);

  const warmStart = Date.now();
  await warmUp(url);
  console.log(`warm-up: preview responded in ${fmtMs(Date.now() - warmStart)}`);

  const browser = await puppeteer.launch({
    args: ['--no-sandbox', '--disable-setuid-sandbox'],
  });

  const results = [];
  const queue = [...allRoutes];
  const workers = Array.from({ length: CONCURRENCY }, async () => {
    while (queue.length) {
      const route = queue.shift();
      const r = await crawlOne(browser, url, route);
      results.push(r);
      logRoute(r);
    }
  });
  await Promise.all(workers);

  if (RETRY) {
    const flaky = results
      .filter((r) => r.skipped && /within \d+ms|empty root/.test(r.skipped))
      .map((r) => r.route);
    if (flaky.length) {
      console.log(
        `\nprerender-crawl: retrying ${flaky.length} flaky route(s) sequentially...`,
      );
      const retryResults = new Map();
      for (const route of flaky) {
        const r = await crawlOne(browser, url, route);
        retryResults.set(route, r);
        logRoute({ ...r, route: `${route} [retry]` });
      }
      for (let i = 0; i < results.length; i++) {
        const r = results[i];
        if (retryResults.has(r.route)) {
          const next = retryResults.get(r.route);
          if (next.bytes || next.error) results[i] = next;
        }
      }
    }
  }

  await browser.close();
  await new Promise((resolve) => server.httpServer.close(resolve));

  const total = results.length;
  const ok = results.filter((r) => r.bytes).length;
  const errs = results.filter((r) => r.error).length;
  const skipped = results.filter((r) => r.skipped).length;
  const routeTimes = results.map((r) => r.ms || 0);
  const avgMs = routeTimes.length
    ? routeTimes.reduce((a, b) => a + b, 0) / routeTimes.length
    : 0;
  const maxMs = routeTimes.length ? Math.max(...routeTimes) : 0;
  const pct = total ? ((ok / total) * 100).toFixed(1) : '0.0';
  const elapsed = Date.now() - tStart;

  console.log(
    `\nprerender-crawl: ${ok}/${total} rendered (${pct}% success), ${skipped} skipped, ${errs} errored`,
  );
  console.log(
    `prerender-crawl: per-route avg ${fmtMs(Math.round(avgMs))}, max ${fmtMs(maxMs)}`,
  );
  console.log(`prerender-crawl: total elapsed ${fmtSec(elapsed)}`);

  // Say what the errors actually were. A bare count sends anyone reading this
  // log guessing, which is exactly how the blocked-resource noise above went
  // unexplained for so long.
  const byMessage = new Map();
  for (const r of results) {
    for (const m of r.messages || []) {
      const key = m.slice(0, 140);
      const hit = byMessage.get(key) || { n: 0, routes: [] };
      hit.n += 1;
      if (hit.routes.length < 5 && !hit.routes.includes(r.route)) {
        hit.routes.push(r.route);
      }
      byMessage.set(key, hit);
    }
  }
  const noisy = results.filter((r) => (r.errors || 0) > 0).length;
  if (byMessage.size) {
    console.log(`
prerender-crawl: ${noisy} route(s) logged console errors`);
    [...byMessage.entries()]
      .sort((a, b) => b[1].n - a[1].n)
      .slice(0, 12)
      .forEach(([msg, hit]) => {
        console.log(`  ${String(hit.n).padStart(4)}x  ${msg}`);
        console.log(`        on ${hit.routes.join(', ')}`);
      });
  } else {
    console.log('prerender-crawl: no console errors');
  }

  try {
    const home = await readFile(join(DIST, 'index.html'), 'utf8');
    await writeFile(join(DIST, '404.html'), home, 'utf8');
  } catch {}

  // Exit explicitly instead of waiting for the event loop to drain. Puppeteer
  // can leave an orphaned renderer or crashpad handler holding the pipe it
  // inherited, and build.mjs then blocks forever on a crawl that has already
  // written every page. Flush stdout first so the summary above is not cut off.
  const code = errs > 0 ? 1 : 0;
  await new Promise((resolve) => process.stdout.write('', resolve));
  process.exit(code);
}

await main();