import { performance as nodePerformance } from "node:perf_hooks";
import { writeFile } from "node:fs/promises";
import type { CDPSession, Page } from "@playwright/test";
import { expect, test } from "../helpers/serve-dist";
import { authorizedPerformanceUrl } from "../helpers/test-build-auth";
import {
  loadAuthenticatedReferenceRun,
  validateObservedReferenceEnvironment,
} from "./reference-run";
import {
  calculatePeakRequestConcurrency,
  evaluateRuntimeTraceBudgetEvidence,
} from "../../scripts/lib/bundle-budgets.mjs";
import {
  calculateCls,
  calculateLabTbt,
  calculateLostPresentationShare,
  evaluateEventToNextPaint,
  evaluateSceneContinuity,
  latestLcpBeforeCutoff,
  nearestRankP95,
  postRunningLongTasks,
  unexpectedLateShifts,
  type ScriptedActionSample,
} from "../../src/testing/performance-instrumentation";

type NamedProfile = "desktop-high" | "mobile-low";

const profileForProject = (
  name: string,
): {
  name: NamedProfile;
  tier: "high" | "low";
  viewport: { width: number; height: number };
  latency: number;
  download: number;
  upload: number;
  sceneCpuP95: number;
  lostShare: number;
} =>
  name === "performance-mobile"
    ? {
        name: "mobile-low",
        tier: "low",
        viewport: { width: 390, height: 844 },
        latency: 150,
        download: 200_000,
        upload: 93_750,
        sceneCpuP95: 24,
        lostShare: 0.1,
      }
    : {
        name: "desktop-high",
        tier: "high",
        viewport: { width: 1_440, height: 900 },
        latency: 40,
        download: 1_250_000,
        upload: 1_250_000,
        sceneCpuP95: 12,
        lostShare: 0.05,
      };

const sleep = (duration: number): Promise<void> =>
  new Promise((resolve) => setTimeout(resolve, duration));

const stableTargetCenter = async (page: Page, selector: string) => {
  const locator = page.locator(selector).filter({ visible: true });
  await expect(locator).toHaveCount(1);
  await expect(locator).toBeEnabled();
  const box = await locator.boundingBox();
  if (box === null) throw new Error(`Trace target is not visible: ${selector}`);
  return { x: box.x + box.width / 2, y: box.y + box.height / 2 };
};

const dispatchPointerAction = async (
  page: Page,
  cdp: CDPSession,
  at: (offset: number) => Promise<void>,
  offset: number,
  id: string,
  selector: string,
) => {
  await at(offset - 50);
  const center = await stableTargetCenter(page, selector);
  const markerSelector = `[data-drive-target="${id}"]`;
  await page
    .locator(selector)
    .filter({ visible: true })
    .evaluate((element, actionId) => {
      element.setAttribute("data-drive-target", actionId);
    }, id);
  await at(offset - 20);
  await cdp.send("Input.dispatchMouseEvent", { type: "mouseMoved", ...center });
  await at(offset);
  await page.evaluate(
    ({ actionId, target }) =>
      window.__PORTFOLIO_PERFORMANCE__?.beginAction(actionId, target),
    { actionId: id, target: markerSelector },
  );
  await cdp.send("Input.dispatchMouseEvent", {
    type: "mousePressed",
    button: "left",
    clickCount: 1,
    ...center,
  });
  await at(offset + 40);
  await cdp.send("Input.dispatchMouseEvent", {
    type: "mouseReleased",
    button: "left",
    clickCount: 1,
    ...center,
  });
};

const dispatchWheelBurst = async (
  page: Page,
  cdp: CDPSession,
  at: (offset: number) => Promise<void>,
  offset: number,
  deltaY: number,
) => {
  const center = await page.evaluate(() => {
    const viewport = window.visualViewport;
    return {
      x: (viewport?.offsetLeft ?? 0) + (viewport?.width ?? innerWidth) / 2,
      y: (viewport?.offsetTop ?? 0) + (viewport?.height ?? innerHeight) / 2,
    };
  });
  for (const deltaOffset of [0, 40, 80, 120, 160, 200]) {
    await at(offset + deltaOffset);
    await cdp.send("Input.dispatchMouseEvent", {
      type: "mouseWheel",
      deltaX: 0,
      deltaY,
      ...center,
    });
  }
};

test("drive-trace.v1 runs on current Chromium with fail-closed reference authentication", async ({
  browser,
  page,
  distUrl,
}, testInfo) => {
  test.setTimeout(75_000);
  const profile = profileForProject(testInfo.project.name);
  const referenceRun = await loadAuthenticatedReferenceRun(profile.name);
  await page.setViewportSize(profile.viewport);
  const cdp = await page.context().newCDPSession(page);
  await cdp.send("Network.enable");
  await cdp.send("Network.clearBrowserCache");
  await cdp.send("Network.emulateNetworkConditions", {
    offline: false,
    latency: profile.latency,
    downloadThroughput: profile.download,
    uploadThroughput: profile.upload,
  });
  await page.emulateMedia({ reducedMotion: "no-preference" });
  await page.goto("about:blank");
  const startedFromAboutBlank = page.url() === "about:blank";
  const loadStarted = nodePerformance.now();
  await page.goto(authorizedPerformanceUrl(distUrl, profile.tier), {
    waitUntil: "load",
    timeout: 10_000,
  });
  const loadDuration = nodePerformance.now() - loadStarted;
  expect(loadDuration).toBeLessThanOrEqual(10_000);
  await expect
    .poll(
      () =>
        page.evaluate(
          () => window.__PORTFOLIO_PERFORMANCE__?.snapshot().lcp.length ?? 0,
        ),
      { timeout: 10_000 },
    )
    .toBeGreaterThan(0);
  await expect(page.locator(".journey-world")).toHaveAttribute(
    "data-scene-state",
    "running",
    { timeout: 5_000 },
  );
  await expect
    .poll(() =>
      page.evaluate(
        () =>
          window.__PORTFOLIO_PERFORMANCE__?.snapshot().runtimeAllocation
            ?.tier ?? null,
      ),
    )
    .toBe(profile.tier);
  if (referenceRun !== null) {
    const observed = await page.evaluate(() => ({
      viewport: { width: innerWidth, height: innerHeight },
      visible: document.visibilityState === "visible",
      reducedMotion: matchMedia("(prefers-reduced-motion: reduce)").matches
        ? ("reduce" as const)
        : ("no-preference" as const),
      saveData: Boolean(
        (navigator as Navigator & { connection?: { saveData?: boolean } })
          .connection?.saveData,
      ),
      pageZoom: visualViewport?.scale ?? 1,
      devicePixelRatio,
    }));
    validateObservedReferenceEnvironment(referenceRun, {
      ...observed,
      browserName: "Chromium",
      browserVersion: browser.version(),
      startedFromAboutBlank,
    });
  }

  const warmupRafs = await page.evaluate(
    () =>
      new Promise<number[]>((resolve) => {
        const samples: number[] = [];
        const frame = (now: number): void => {
          samples.push(now);
          if (samples.length === 121) resolve(samples);
          else requestAnimationFrame(frame);
        };
        requestAnimationFrame(frame);
      }),
  );
  const warmupIntervals = warmupRafs
    .slice(1)
    .map((stamp, index) => stamp - warmupRafs[index]!);
  const warmupMedian = [...warmupIntervals].sort((a, b) => a - b)[
    Math.floor(warmupIntervals.length / 2)
  ]!;
  const validReferenceCadence = Math.abs(warmupMedian - 16.667) <= 1;
  if (process.env.PORTFOLIO_REFERENCE_LAB === "1")
    expect(validReferenceCadence).toBe(true);

  await page.evaluate(() => window.__PORTFOLIO_PERFORMANCE__?.startTrace());
  const nodeTraceStart = nodePerformance.now();
  const at = async (offset: number): Promise<void> => {
    const remaining = nodeTraceStart + offset - nodePerformance.now();
    if (remaining > 0) await sleep(remaining);
  };

  await dispatchPointerAction(
    page,
    cdp,
    at,
    1_000,
    "start",
    'button:has-text("PLAY SOUNDTRACK")',
  );
  await dispatchWheelBurst(page, cdp, at, 1_500, 100);
  await at(2_350);
  await page.getByRole("button", { name: "Drive settings" }).click();
  await at(2_400);
  const volumeSlider = page.getByRole("slider", { name: "Sound volume" });
  await expect(volumeSlider).toBeVisible();
  await volumeSlider.focus();
  await expect(volumeSlider).toBeFocused();
  await page.evaluate(() =>
    window.__PORTFOLIO_PERFORMANCE__?.beginAction(
      "volume",
      'input[aria-label="Sound volume level"]',
    ),
  );
  await cdp.send("Input.dispatchKeyEvent", {
    type: "keyDown",
    key: "ArrowLeft",
    code: "ArrowLeft",
    windowsVirtualKeyCode: 37,
  });
  await at(2_440);
  await cdp.send("Input.dispatchKeyEvent", {
    type: "keyUp",
    key: "ArrowLeft",
    code: "ArrowLeft",
    windowsVirtualKeyCode: 37,
  });
  await expect(page.getByRole("slider", { name: "Sound volume" })).toHaveValue(
    "0.35",
  );
  await dispatchWheelBurst(page, cdp, at, 2_800, 100);
  await dispatchPointerAction(
    page,
    cdp,
    at,
    3_700,
    "mute",
    'button[aria-label="Mute sound"]',
  );
  await expect(
    page.getByRole("button", { name: "Unmute sound" }),
  ).toBeVisible();
  await dispatchWheelBurst(page, cdp, at, 4_100, 100);
  await dispatchPointerAction(
    page,
    cdp,
    at,
    5_000,
    "unmute",
    'button[aria-label="Unmute sound"]',
  );
  await dispatchWheelBurst(page, cdp, at, 5_400, 100);
  await dispatchPointerAction(
    page,
    cdp,
    at,
    6_300,
    "pause",
    'button[aria-label="Pause motion"]',
  );
  await dispatchWheelBurst(page, cdp, at, 6_700, 100);
  await dispatchPointerAction(
    page,
    cdp,
    at,
    7_600,
    "resume",
    'button[aria-label="Resume motion"]',
  );
  await dispatchWheelBurst(page, cdp, at, 8_000, 100);
  await at(8_800);
  await page.evaluate(() =>
    window.__PORTFOLIO_PERFORMANCE__?.armNavigationSettlementBarrier(),
  );
  await dispatchPointerAction(
    page,
    cdp,
    at,
    8_900,
    "toolkit",
    'nav a[href="#toolkit"]',
  );
  await dispatchWheelBurst(page, cdp, at, 9_300, -100);
  await dispatchWheelBurst(page, cdp, at, 10_600, -100);
  await dispatchWheelBurst(page, cdp, at, 11_900, 100);
  await dispatchWheelBurst(page, cdp, at, 13_200, 100);
  await dispatchPointerAction(
    page,
    cdp,
    at,
    14_500,
    "contact",
    'nav a[href="#contact"]',
  );
  await at(20_000);
  await page.evaluate(() => window.__PORTFOLIO_PERFORMANCE__?.endTrace());

  await expect(page).toHaveURL(/#contact$/u);
  await expect(page.locator("#contact > h2")).toBeFocused();
  const snapshot = await page.evaluate(() =>
    window.__PORTFOLIO_PERFORMANCE__?.snapshot(),
  );
  if (
    snapshot === undefined ||
    snapshot.traceStart === null ||
    snapshot.traceEnd === null ||
    snapshot.firstSceneFrame === null
  ) {
    throw new Error("The authenticated performance snapshot is incomplete.");
  }
  if (snapshot.runtimeAllocation === null)
    throw new Error(
      "The production scene did not emit an actual allocation ledger.",
    );
  expect(snapshot.runtimeAllocation.tier).toBe(profile.tier);
  const expectedPeriod = warmupMedian;
  const fcp = await page.evaluate(
    () =>
      performance.getEntriesByName("first-contentful-paint")[0]?.startTime ??
      null,
  );
  const lcp = latestLcpBeforeCutoff(snapshot.lcp, snapshot.cutoff);
  const cls = calculateCls(snapshot.layoutShifts);
  const tbt = calculateLabTbt(snapshot.longTasks, fcp, snapshot.traceStart);
  const postRunning = postRunningLongTasks(
    snapshot.longTasks,
    snapshot.traceStart,
    snapshot.traceEnd,
  );
  const eventToPaint = evaluateEventToNextPaint(
    snapshot.actions as ScriptedActionSample[],
  );
  const continuity = evaluateSceneContinuity(
    snapshot.sceneIntervals,
    snapshot.sceneFrames,
    expectedPeriod,
  );
  const lost = calculateLostPresentationShare(
    snapshot.pageRafs,
    expectedPeriod,
    Math.floor(20_000 / expectedPeriod) - 3,
  );
  const lateShifts = unexpectedLateShifts(
    snapshot.layoutShifts,
    snapshot.firstSceneFrame,
    snapshot.traceEnd,
  );
  const sceneCpuP95 = nearestRankP95(
    snapshot.sceneFrames.map((frame) => frame.end - frame.start),
  );
  const resourceTimings = await page.evaluate(() =>
    performance.getEntriesByType("resource").map((entry) => {
      const resource = entry as PerformanceResourceTiming;
      return {
        name: resource.name,
        initiatorType: resource.initiatorType,
        startTime: resource.startTime,
        responseEnd: resource.responseEnd,
      };
    }),
  );
  const peakRequests = calculatePeakRequestConcurrency(resourceTimings);
  const runtimeBudgetEvidence = {
    schema: "portfolio-runtime-trace-evidence/v1",
    peakRequests,
    allocation: snapshot.runtimeAllocation,
  };
  const runtimeBudget = evaluateRuntimeTraceBudgetEvidence(
    runtimeBudgetEvidence,
  );
  const runtimeResourcePass = !runtimeBudget.violations.some((item) =>
    [
      "mobileTextureDimension",
      "lowTierGpuEstimate",
      "highTierGpuEstimate",
    ].includes(item.budget),
  );
  const requestConcurrencyPass = !runtimeBudget.violations.some((item) =>
    ["imageSceneConcurrency", "videoConcurrency"].includes(item.budget),
  );

  const budgetResults = {
    lcp: lcp <= 3_000,
    cls: cls <= 0.1,
    tbt: tbt <= 300,
    postRunningLongTasks: postRunning.length === 0,
    eventToNextPaint: eventToPaint.p95 <= 200,
    sceneCpu: sceneCpuP95 <= profile.sceneCpuP95,
    continuity: continuity.passes,
    lostPresentation:
      lost.hasSufficientCoverage && lost.share <= profile.lostShare,
    lateShifts: lateShifts.length === 0,
    runtimeResources: runtimeResourcePass,
    requestConcurrency: requestConcurrencyPass,
  };
  if (process.env.PORTFOLIO_REFERENCE_LAB === "1") {
    expect(Object.values(budgetResults).every(Boolean)).toBe(true);
  }
  expect(snapshot.navigationBarrier.cancelledEpoch).not.toBeNull();

  const report = {
    schema: "drive-trace.v1",
    evidenceKind:
      referenceRun === null
        ? "current-chromium-developer-machine-non-reference"
        : "validated-reference-candidate-unsigned",
    gatingReferenceResult: false,
    referenceCandidateValidated: referenceRun !== null,
    ...(referenceRun === null
      ? {}
      : {
          referenceRun: {
            runId: referenceRun.runId,
            runIndex: referenceRun.runIndex,
            attestationDigest: referenceRun.attestationDigest,
          },
        }),
    profile: profile.name,
    tier: profile.tier,
    browser: testInfo.project.name,
    metrics: {
      warmupMedian,
      lcp,
      cls,
      tbt,
      postRunningLongTaskCount: postRunning.length,
      eventToNextPaintP95: eventToPaint.p95,
      sceneCpuP95,
      continuity,
      lostPresentationShare: lost.share,
      lateShiftCount: lateShifts.length,
    },
    runtimeBudgetEvidence,
    runtimeBudgetSummary: runtimeBudget.tier,
    budgetResults,
    referenceBudgetsPass:
      validReferenceCadence && Object.values(budgetResults).every(Boolean),
    validReferenceCadence,
    pendingPhysicalReferenceRuns: referenceRun === null ? 5 : 0,
  };
  await writeFile(
    testInfo.outputPath("drive-trace.v1.json"),
    `${JSON.stringify(report, null, 2)}\n`,
  );
});