/**
 * Electron Cold Startup Benchmark
 *
 * Launches the Electron app N times and measures per-phase startup timings by
 * parsing the electron-log file for [AionUi:ready] / [AionUi:init] /
 * [AionUi:process] marks, plus `ready-to-show` / `did-finish-load` /
 * time-to-interactive (chat input visible).
 *
 * Optional `--with-memory` mode samples RSS / heap in the main and renderer
 * processes at three checkpoints (idle, afterConversation, afterClose) to
 * estimate per-conversation memory pressure and leaks.
 *
 * Usage:
 *   bunx tsx scripts/benchmark-startup.ts [--iterations 5] [--cooldown 2000]
 *   bunx tsx scripts/benchmark-startup.ts --with-memory
 */
import { _electron as electron, type ElectronApplication, type Page } from 'playwright';
import path from 'path';
import fs from 'fs';
import os from 'os';

// ── CLI args ────────────────────────────────────────────────────────────────

type Args = {
  iterations: number;
  cooldownMs: number;
  launchTimeoutMs: number;
  interactiveTimeoutMs: number;
  outputJson: string | null;
  withMemory: boolean;
};

function parseArgs(): Args {
  const argv = process.argv.slice(2);
  const args: Args = {
    iterations: 5,
    cooldownMs: 2_000,
    launchTimeoutMs: 90_000,
    interactiveTimeoutMs: 60_000,
    outputJson: null,
    withMemory: false,
  };

  for (let i = 0; i < argv.length; i++) {
    const flag = argv[i];
    const next = argv[i + 1];
    if (flag === '--iterations' && next) {
      args.iterations = parseInt(next, 10);
      i++;
    } else if (flag === '--cooldown' && next) {
      args.cooldownMs = parseInt(next, 10);
      i++;
    } else if (flag === '--launch-timeout' && next) {
      args.launchTimeoutMs = parseInt(next, 10);
      i++;
    } else if (flag === '--interactive-timeout' && next) {
      args.interactiveTimeoutMs = parseInt(next, 10);
      i++;
    } else if (flag === '--output' && next) {
      args.outputJson = next;
      i++;
    } else if (flag === '--with-memory') {
      args.withMemory = true;
    }
  }

  if (!Number.isFinite(args.iterations) || args.iterations < 1) args.iterations = 5;
  return args;
}

// ── Types ───────────────────────────────────────────────────────────────────

type MainMemorySample = {
  rss: number;
  heapTotal: number;
  heapUsed: number;
  external: number;
  arrayBuffers: number;
};

type RendererMemorySample = {
  usedSize: number;
  totalSize: number;
};

type MemorySnapshot = {
  main: MainMemorySample | null;
  renderer: RendererMemorySample | null;
  takenAt: string;
};

type MemoryProfile = {
  idle: MemorySnapshot | null;
  afterConversation: MemorySnapshot | null;
  afterClose: MemorySnapshot | null;
  // Leak estimate = afterClose - idle (main RSS + renderer usedSize)
  leakMainRssBytes: number;
  leakRendererUsedBytes: number;
  // Convenience deltas (afterConversation - idle)
  openDeltaMainRssBytes: number;
  openDeltaRendererUsedBytes: number;
};

type StartupTiming = {
  iteration: number;
  timestamp: string;
  failed: boolean;
  failureReason: string | null;
  // Wall-clock measurements from Playwright side
  wallFirstWindowMs: number;
  wallDomContentLoadedMs: number;
  wallTimeToInteractiveMs: number;
  wallTotalMs: number;
  // Parsed from [AionUi:ready] marks
  readyInitializeProcessMs: number;
  readyInitializeZoomFactorMs: number;
  readyCreateWindowMs: number;
  readyInitializeAcpDetectorMs: number;
  // Parsed from [AionUi:init] marks
  initTotalMs: number;
  // Parsed from [AionUi:process] marks
  processInitStorageMs: number;
  processExtensionRegistryMs: number;
  processChannelManagerMs: number;
  // Parsed from window lifecycle logs
  logRendererDidFinishLoadPresent: boolean;
  logWindowReadyToShowPresent: boolean;
  logShowingMainWindowPresent: boolean;
  // Optional memory profile (only when --with-memory is passed)
  memory: MemoryProfile | null;
};

// ── Selectors ───────────────────────────────────────────────────────────────

const GUID_INPUT = '.guid-input-card-shell textarea';
const AGENT_PILL = '[data-agent-pill="true"]';

// ── Log file helpers ────────────────────────────────────────────────────────

function getLogFilePath(): string {
  const today = new Date().toISOString().slice(0, 10);
  const candidates: string[] = [];
  if (process.platform === 'darwin') {
    candidates.push(
      path.join(os.homedir(), 'Library', 'Logs', 'AionUi-Dev', `${today}.log`),
      path.join(os.homedir(), 'Library', 'Logs', 'AionUi', `${today}.log`)
    );
  } else if (process.platform === 'win32') {
    const appData = process.env.APPDATA ?? path.join(os.homedir(), 'AppData', 'Roaming');
    candidates.push(path.join(appData, 'AionUi', 'logs', `${today}.log`));
  } else {
    candidates.push(path.join(os.homedir(), '.config', 'AionUi', 'logs', `${today}.log`));
  }
  return candidates.find((p) => fs.existsSync(p)) ?? candidates[0];
}

function getLogFileSize(logPath: string): number {
  try {
    return fs.statSync(logPath).size;
  } catch {
    return 0;
  }
}

function readNewLogLines(logPath: string, offset: number): string[] {
  try {
    const currentSize = fs.statSync(logPath).size;
    if (currentSize <= offset) return [];
    const fd = fs.openSync(logPath, 'r');
    const buf = Buffer.alloc(currentSize - offset);
    fs.readSync(fd, buf, 0, buf.length, offset);
    fs.closeSync(fd);
    return buf.toString('utf-8').split('\n');
  } catch {
    return [];
  }
}

// ── Log parsing ─────────────────────────────────────────────────────────────

// Matches: [AionUi:ready] <label> +<ms>ms
// Matches: [AionUi:init]  <label> +<ms>ms
// Matches: [AionUi:process] <label> +<ms>ms
const MARK_REGEX = /\[AionUi:(ready|init|process)\]\s+([^+]+?)\s+\+(\d+)ms/;

type ParsedMarks = {
  ready: Map<string, number>;
  init: Map<string, number>;
  process: Map<string, number>;
  logs: { rendererDidFinishLoad: boolean; windowReadyToShow: boolean; showingMainWindow: boolean };
};

function parseStartupLog(lines: string[]): ParsedMarks {
  const marks: ParsedMarks = {
    ready: new Map(),
    init: new Map(),
    process: new Map(),
    logs: { rendererDidFinishLoad: false, windowReadyToShow: false, showingMainWindow: false },
  };

  for (const line of lines) {
    const m = MARK_REGEX.exec(line);
    if (m) {
      const [, scope, label, msStr] = m;
      const ms = parseInt(msStr, 10);
      const key = label.trim();
      if (scope === 'ready') marks.ready.set(key, ms);
      else if (scope === 'init') marks.init.set(key, ms);
      else if (scope === 'process') marks.process.set(key, ms);
      continue;
    }

    if (line.includes('[AionUi] Renderer did-finish-load')) marks.logs.rendererDidFinishLoad = true;
    else if (line.includes('[AionUi] Window ready-to-show')) marks.logs.windowReadyToShow = true;
    else if (line.includes('[AionUi] Showing main window')) marks.logs.showingMainWindow = true;
  }

  return marks;
}

// ── App launch ──────────────────────────────────────────────────────────────

function getProjectRoot(): string {
  // In a git worktree, __dirname points to the worktree which has no build output.
  // Resolve the main repo root via git's common dir so Electron can find out/main/index.js.
  try {
    const { execSync } = require('child_process');
    const commonDir = execSync('git rev-parse --git-common-dir', {
      encoding: 'utf-8',
      cwd: path.resolve(__dirname, '..'),
    }).trim();
    const mainRoot = path.resolve(commonDir, '..');
    if (fs.existsSync(path.join(mainRoot, 'out/main/index.js'))) {
      return mainRoot;
    }
  } catch {
    // not in a worktree or git not available
  }
  return path.resolve(__dirname, '..');
}

async function launchApp(timeoutMs: number, withMemory: boolean): Promise<ElectronApplication> {
  const projectRoot = getProjectRoot();

  // Ensure production build exists
  const mainEntry = path.join(projectRoot, 'out/main/index.js');
  if (!fs.existsSync(mainEntry)) {
    console.log('[bench:startup] Building production bundle (electron-vite build)...');
    const { execSync } = require('child_process');
    execSync('npx electron-vite build', { cwd: projectRoot, stdio: 'inherit' });
  }

  const launchArgs = withMemory ? [mainEntry, '--js-flags=--expose-gc'] : [mainEntry];
  return electron.launch({
    args: launchArgs,
    cwd: projectRoot,
    env: {
      ...process.env,
      AIONUI_DISABLE_AUTO_UPDATE: '1',
      AIONUI_E2E_TEST: '1',
      AIONUI_DISABLE_DEVTOOLS: '1',
      AIONUI_CDP_PORT: '0',
      NODE_ENV: 'production',
    },
    timeout: timeoutMs,
  });
}

async function resolveMainWindow(app: ElectronApplication, timeoutMs: number): Promise<Page> {
  const existing = app.windows().find((w) => !w.url().startsWith('devtools://'));
  if (existing) {
    await existing.waitForLoadState('domcontentloaded');
    return existing;
  }

  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    const remaining = Math.max(250, deadline - Date.now());
    const win = await app.waitForEvent('window', { timeout: Math.min(1_000, remaining) }).catch(() => null);
    if (win && !win.url().startsWith('devtools://')) {
      await win.waitForLoadState('domcontentloaded');
      return win;
    }
  }
  throw new Error('Failed to resolve main window within timeout');
}

// ── Memory sampling ─────────────────────────────────────────────────────────

async function sampleMainMemory(app: ElectronApplication): Promise<MainMemorySample | null> {
  try {
    return await app.evaluate(async () => {
      const gc = (globalThis as { gc?: () => void }).gc;
      if (typeof gc === 'function') {
        gc();
        gc();
      }
      const m = process.memoryUsage();
      return {
        rss: m.rss,
        heapTotal: m.heapTotal,
        heapUsed: m.heapUsed,
        external: m.external,
        arrayBuffers: m.arrayBuffers,
      };
    });
  } catch {
    return null;
  }
}

async function sampleRendererMemory(page: Page): Promise<RendererMemorySample | null> {
  try {
    const client = await page.context().newCDPSession(page);
    try {
      await client.send('HeapProfiler.enable').catch(() => {});
      await client.send('HeapProfiler.collectGarbage').catch(() => {});
      const heap = (await client.send('Runtime.getHeapUsage')) as { usedSize: number; totalSize: number };
      return { usedSize: heap.usedSize, totalSize: heap.totalSize };
    } finally {
      await client.detach().catch(() => {});
    }
  } catch {
    return null;
  }
}

async function takeSnapshot(app: ElectronApplication, page: Page): Promise<MemorySnapshot> {
  // Let pending microtasks settle before sampling
  await new Promise((r) => setTimeout(r, 500));
  const [main, renderer] = await Promise.all([sampleMainMemory(app), sampleRendererMemory(page)]);
  return { main, renderer, takenAt: new Date().toISOString() };
}

function computeMemoryDeltas(
  idle: MemorySnapshot | null,
  afterConversation: MemorySnapshot | null,
  afterClose: MemorySnapshot | null
): Pick<
  MemoryProfile,
  'leakMainRssBytes' | 'leakRendererUsedBytes' | 'openDeltaMainRssBytes' | 'openDeltaRendererUsedBytes'
> {
  const idleRss = idle?.main?.rss ?? 0;
  const idleRenderer = idle?.renderer?.usedSize ?? 0;
  const convRss = afterConversation?.main?.rss ?? 0;
  const convRenderer = afterConversation?.renderer?.usedSize ?? 0;
  const closeRss = afterClose?.main?.rss ?? 0;
  const closeRenderer = afterClose?.renderer?.usedSize ?? 0;

  return {
    leakMainRssBytes: closeRss > 0 && idleRss > 0 ? closeRss - idleRss : 0,
    leakRendererUsedBytes: closeRenderer > 0 && idleRenderer > 0 ? closeRenderer - idleRenderer : 0,
    openDeltaMainRssBytes: convRss > 0 && idleRss > 0 ? convRss - idleRss : 0,
    openDeltaRendererUsedBytes: convRenderer > 0 && idleRenderer > 0 ? convRenderer - idleRenderer : 0,
  };
}

// ── Conversation open/close actions ─────────────────────────────────────────

/**
 * Open a conversation by clicking the first available agent pill on the guid page.
 * Does not send a message; waits until the pill enters the `data-agent-selected`
 * state. Returns true if a pill was successfully selected.
 */
async function openConversation(page: Page, timeoutMs: number): Promise<boolean> {
  try {
    const pill = page.locator(AGENT_PILL).first();
    await pill.waitFor({ state: 'visible', timeout: timeoutMs });
    await pill.click();
    // Wait for the selected state to indicate the agent is ready
    await page.waitForSelector(`${AGENT_PILL}[data-agent-selected="true"]`, { timeout: timeoutMs }).catch(() => {});
    // Also wait for the textarea to become interactive (agent probe finished)
    await page
      .locator(GUID_INPUT)
      .first()
      .waitFor({ state: 'visible', timeout: timeoutMs })
      .catch(() => {});
    return true;
  } catch {
    return false;
  }
}

/**
 * Close the current conversation by navigating back to the guid landing page.
 * This mirrors the user gesture of returning to "new chat" without picking an agent.
 */
async function closeConversation(page: Page): Promise<void> {
  await page.evaluate(() => window.location.assign('#/guid'));
  await page.waitForFunction(() => window.location.hash === '#/guid', undefined, { timeout: 5_000 }).catch(() => {});
  await new Promise((r) => setTimeout(r, 500));
}

// ── Single iteration ────────────────────────────────────────────────────────

async function runOneIteration(iteration: number, args: Args): Promise<StartupTiming> {
  const logPath = getLogFilePath();
  const logOffset = getLogFileSize(logPath);
  const timestamp = new Date().toISOString();

  let failed = false;
  let failureReason: string | null = null;
  let app: ElectronApplication | null = null;
  let memory: MemoryProfile | null = null;

  const wallStart = Date.now();
  let wallFirstWindow = 0;
  let wallDomContentLoaded = 0;
  let wallInteractive = 0;
  let wallTotal = 0;

  try {
    app = await launchApp(args.launchTimeoutMs, args.withMemory);
    const page = await resolveMainWindow(app, args.launchTimeoutMs);
    wallFirstWindow = Date.now() - wallStart;

    await page.waitForLoadState('domcontentloaded', { timeout: args.interactiveTimeoutMs });
    wallDomContentLoaded = Date.now() - wallStart;

    // Chat input visible = time-to-interactive (app is usable)
    await page.locator(GUID_INPUT).first().waitFor({ state: 'visible', timeout: args.interactiveTimeoutMs });
    wallInteractive = Date.now() - wallStart;

    // Give async init (ACP detector, etc.) a brief window to finish and flush logs
    await new Promise((r) => setTimeout(r, 1_000));
    wallTotal = Date.now() - wallStart;

    if (args.withMemory) {
      // 1. Idle — wait longer so background tasks (ACP detection, tray, i18n) settle
      await new Promise((r) => setTimeout(r, 5_000));
      const idle = await takeSnapshot(app, page);

      // 2. After opening a conversation (agent pill selected, no message sent)
      let afterConversation: MemorySnapshot | null = null;
      const opened = await openConversation(page, 15_000);
      if (opened) {
        await new Promise((r) => setTimeout(r, 2_000));
        afterConversation = await takeSnapshot(app, page);
      }

      // 3. After closing / navigating back to guid
      await closeConversation(page);
      await new Promise((r) => setTimeout(r, 2_000));
      const afterClose = await takeSnapshot(app, page);

      memory = {
        idle,
        afterConversation,
        afterClose,
        ...computeMemoryDeltas(idle, afterConversation, afterClose),
      };
    }
  } catch (err) {
    failed = true;
    failureReason = err instanceof Error ? err.message : String(err);
    wallTotal = Date.now() - wallStart;
  } finally {
    if (app) {
      try {
        await app.evaluate(async ({ app: a }) => a.exit(0));
      } catch {
        // ignore
      }
      await app.close().catch(() => {});
    }
  }

  // Wait briefly for the log file to flush after process exit
  await new Promise((r) => setTimeout(r, 500));
  const logLines = readNewLogLines(logPath, logOffset);
  const marks = parseStartupLog(logLines);

  return {
    iteration,
    timestamp,
    failed,
    failureReason,
    wallFirstWindowMs: wallFirstWindow,
    wallDomContentLoadedMs: wallDomContentLoaded,
    wallTimeToInteractiveMs: wallInteractive,
    wallTotalMs: wallTotal,
    readyInitializeProcessMs: marks.ready.get('initializeProcess') ?? 0,
    readyInitializeZoomFactorMs: marks.ready.get('initializeZoomFactor') ?? 0,
    readyCreateWindowMs: marks.ready.get('createWindow') ?? 0,
    readyInitializeAcpDetectorMs: marks.ready.get('initializeAcpDetector') ?? 0,
    initTotalMs: marks.init.get('done') ?? 0,
    processInitStorageMs: marks.process.get('initStorage') ?? 0,
    processExtensionRegistryMs: marks.process.get('ExtensionRegistry') ?? 0,
    processChannelManagerMs: marks.process.get('ChannelManager') ?? 0,
    logRendererDidFinishLoadPresent: marks.logs.rendererDidFinishLoad,
    logWindowReadyToShowPresent: marks.logs.windowReadyToShow,
    logShowingMainWindowPresent: marks.logs.showingMainWindow,
    memory,
  };
}

// ── Statistics ──────────────────────────────────────────────────────────────

type Stats = { count: number; mean: number; median: number; p95: number; min: number; max: number };

function computeStats(values: number[]): Stats {
  const sorted = [...values].filter((v) => v > 0).sort((a, b) => a - b);
  if (sorted.length === 0) return { count: 0, mean: 0, median: 0, p95: 0, min: 0, max: 0 };
  const sum = sorted.reduce((a, b) => a + b, 0);
  const mean = Math.round(sum / sorted.length);
  const median = sorted[Math.floor(sorted.length / 2)];
  const p95 = sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * 0.95))];
  return { count: sorted.length, mean, median, p95, min: sorted[0], max: sorted[sorted.length - 1] };
}

// ── Memory summary ──────────────────────────────────────────────────────────

type MemorySummary = {
  idleMainRss: Stats;
  idleMainHeapUsed: Stats;
  idleRendererUsed: Stats;
  afterConversationMainRss: Stats;
  afterConversationRendererUsed: Stats;
  afterCloseMainRss: Stats;
  afterCloseRendererUsed: Stats;
  leakMainRssBytes: Stats;
  leakRendererUsedBytes: Stats;
  openDeltaMainRssBytes: Stats;
  openDeltaRendererUsedBytes: Stats;
};

function computeMemorySummary(results: StartupTiming[]): MemorySummary | null {
  const withMem = results.filter((r) => !r.failed && r.memory);
  if (withMem.length === 0) return null;

  const pick = <T>(snapGet: (m: MemoryProfile) => number): Stats =>
    computeStats(withMem.map((r) => (r.memory ? snapGet(r.memory) : 0)));

  return {
    idleMainRss: pick((m) => m.idle?.main?.rss ?? 0),
    idleMainHeapUsed: pick((m) => m.idle?.main?.heapUsed ?? 0),
    idleRendererUsed: pick((m) => m.idle?.renderer?.usedSize ?? 0),
    afterConversationMainRss: pick((m) => m.afterConversation?.main?.rss ?? 0),
    afterConversationRendererUsed: pick((m) => m.afterConversation?.renderer?.usedSize ?? 0),
    afterCloseMainRss: pick((m) => m.afterClose?.main?.rss ?? 0),
    afterCloseRendererUsed: pick((m) => m.afterClose?.renderer?.usedSize ?? 0),
    leakMainRssBytes: pick((m) => m.leakMainRssBytes),
    leakRendererUsedBytes: pick((m) => m.leakRendererUsedBytes),
    openDeltaMainRssBytes: pick((m) => m.openDeltaMainRssBytes),
    openDeltaRendererUsedBytes: pick((m) => m.openDeltaRendererUsedBytes),
  };
}

// ── Reporting ───────────────────────────────────────────────────────────────

function formatMb(bytes: number): string {
  if (bytes === 0) return '0MB';
  const mb = bytes / (1024 * 1024);
  return `${mb.toFixed(1)}MB`;
}

function printTerminalReport(results: StartupTiming[]): void {
  const successful = results.filter((r) => !r.failed);
  const failed = results.filter((r) => r.failed);

  console.log('\n' + '='.repeat(80));
  console.log('  Electron Cold Startup Benchmark — Summary');
  console.log('='.repeat(80));
  console.log(`  Iterations: ${results.length} (successful: ${successful.length}, failed: ${failed.length})`);
  console.log('-'.repeat(80));

  const rows: [string, Stats][] = [
    ['Wall: first window', computeStats(successful.map((r) => r.wallFirstWindowMs))],
    ['Wall: DOM loaded', computeStats(successful.map((r) => r.wallDomContentLoadedMs))],
    ['Wall: interactive', computeStats(successful.map((r) => r.wallTimeToInteractiveMs))],
    ['Wall: total', computeStats(successful.map((r) => r.wallTotalMs))],
    ['ready: initializeProcess', computeStats(successful.map((r) => r.readyInitializeProcessMs))],
    ['ready: createWindow', computeStats(successful.map((r) => r.readyCreateWindowMs))],
    ['ready: initAcpDetector', computeStats(successful.map((r) => r.readyInitializeAcpDetectorMs))],
    ['init: done (storage)', computeStats(successful.map((r) => r.initTotalMs))],
    ['process: initStorage', computeStats(successful.map((r) => r.processInitStorageMs))],
    ['process: ExtensionReg', computeStats(successful.map((r) => r.processExtensionRegistryMs))],
    ['process: ChannelMgr', computeStats(successful.map((r) => r.processChannelManagerMs))],
  ];

  const pad = 26;
  console.log(
    `  ${'Phase'.padEnd(pad)} ${'Mean'.padStart(8)} ${'Median'.padStart(8)} ${'P95'.padStart(8)} ${'Min'.padStart(8)} ${'Max'.padStart(8)} ${'N'.padStart(4)}`
  );
  console.log('-'.repeat(80));
  for (const [label, s] of rows) {
    console.log(
      `  ${label.padEnd(pad)} ${(s.mean + 'ms').padStart(8)} ${(s.median + 'ms').padStart(8)} ${(s.p95 + 'ms').padStart(8)} ${(s.min + 'ms').padStart(8)} ${(s.max + 'ms').padStart(8)} ${String(s.count).padStart(4)}`
    );
  }

  const memSummary = computeMemorySummary(successful);
  if (memSummary) {
    console.log('-'.repeat(80));
    console.log('  Memory Profile (median across runs)');
    console.log('-'.repeat(80));
    const memRows: [string, number][] = [
      ['Idle — main RSS', memSummary.idleMainRss.median],
      ['Idle — main heapUsed', memSummary.idleMainHeapUsed.median],
      ['Idle — renderer used', memSummary.idleRendererUsed.median],
      ['After conv — main RSS', memSummary.afterConversationMainRss.median],
      ['After conv — renderer', memSummary.afterConversationRendererUsed.median],
      ['After close — main RSS', memSummary.afterCloseMainRss.median],
      ['After close — renderer', memSummary.afterCloseRendererUsed.median],
      ['Leak — main RSS', memSummary.leakMainRssBytes.median],
      ['Leak — renderer used', memSummary.leakRendererUsedBytes.median],
      ['Δopen — main RSS', memSummary.openDeltaMainRssBytes.median],
      ['Δopen — renderer used', memSummary.openDeltaRendererUsedBytes.median],
    ];
    for (const [label, bytes] of memRows) {
      console.log(`  ${label.padEnd(pad)} ${formatMb(bytes).padStart(10)}`);
    }
  }

  if (failed.length > 0) {
    console.log('-'.repeat(80));
    console.log('  Failed iterations:');
    for (const r of failed) {
      console.log(`    #${r.iteration}: ${r.failureReason ?? 'unknown'}`);
    }
  }

  console.log('='.repeat(80) + '\n');
}

function writeJsonReport(results: StartupTiming[], outputPath: string | null): string {
  const outputDir = path.join(__dirname, 'benchmark-results');
  if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
  const now = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
  const resolved = outputPath ?? path.join(outputDir, `startup-${now}.json`);

  const successful = results.filter((r) => !r.failed);
  const summary = {
    generatedAt: new Date().toISOString(),
    iterations: results.length,
    successful: successful.length,
    failed: results.length - successful.length,
    stats: {
      wallTimeToInteractive: computeStats(successful.map((r) => r.wallTimeToInteractiveMs)),
      wallTotal: computeStats(successful.map((r) => r.wallTotalMs)),
      readyInitializeProcess: computeStats(successful.map((r) => r.readyInitializeProcessMs)),
      readyCreateWindow: computeStats(successful.map((r) => r.readyCreateWindowMs)),
      readyInitializeAcpDetector: computeStats(successful.map((r) => r.readyInitializeAcpDetectorMs)),
      initTotal: computeStats(successful.map((r) => r.initTotalMs)),
      processInitStorage: computeStats(successful.map((r) => r.processInitStorageMs)),
      processExtensionRegistry: computeStats(successful.map((r) => r.processExtensionRegistryMs)),
      processChannelManager: computeStats(successful.map((r) => r.processChannelManagerMs)),
    },
    memorySummary: computeMemorySummary(successful),
    results,
  };

  fs.writeFileSync(resolved, JSON.stringify(summary, null, 2), 'utf-8');
  return resolved;
}

// ── Main ────────────────────────────────────────────────────────────────────

async function main(): Promise<void> {
  const args = parseArgs();
  console.log(
    `[bench:startup] iterations=${args.iterations} cooldown=${args.cooldownMs}ms launchTimeout=${args.launchTimeoutMs}ms withMemory=${args.withMemory}`
  );

  const results: StartupTiming[] = [];
  for (let i = 1; i <= args.iterations; i++) {
    console.log(`\n[bench:startup] --- iteration ${i}/${args.iterations} ---`);
    const timing = await runOneIteration(i, args);
    results.push(timing);

    if (timing.failed) {
      console.log(`[bench:startup] #${i} FAILED: ${timing.failureReason}`);
    } else {
      const memSuffix = timing.memory
        ? ` idleRss=${formatMb(timing.memory.idle?.main?.rss ?? 0)} leakRss=${formatMb(timing.memory.leakMainRssBytes)}`
        : '';
      console.log(
        `[bench:startup] #${i} interactive=${timing.wallTimeToInteractiveMs}ms ` +
          `domLoaded=${timing.wallDomContentLoadedMs}ms ` +
          `createWindow=${timing.readyCreateWindowMs}ms ` +
          `initProcess=${timing.readyInitializeProcessMs}ms ` +
          `acp=${timing.readyInitializeAcpDetectorMs}ms` +
          memSuffix
      );
    }

    if (i < args.iterations && args.cooldownMs > 0) {
      await new Promise((r) => setTimeout(r, args.cooldownMs));
    }
  }

  printTerminalReport(results);
  const reportPath = writeJsonReport(results, args.outputJson);
  console.log(`[bench:startup] JSON report: ${reportPath}`);
}

main().catch((err) => {
  console.error('[bench:startup] Fatal error:', err);
  process.exit(1);
});