import { test, expect, type APIRequestContext, type Page } from "@playwright/test";
import { readFileSync } from "node:fs";
import path from "node:path";
import { caps, NO_ASR_CORPUS } from "./capabilities";

// THE WHOLE FILE SKIPS WITHOUT THE CORPUS. Everything below derives its
// expected answer from what the corpus actually returned, so with no `asr/`
// there is nothing to derive from: the console is empty and every assertion is
// either vacuous or red. File-scope `test.skip` rather than ten per-test ones,
// because "this file needs the ASR corpus" is one fact, and the header below
// already says it.
test.skip(!caps.asr, NO_ASR_CORPUS);

// The phrase console, against the REAL ASR corpus -- the suite symlinks asr/
// rather than synthesising one, because 300 files of genuine parakeet output is
// the only thing that exercises the chunk seams, the multi-word tokens and the
// confidence spread this page is built around.
//
// That means no assertion here may hardcode a count. Every one is a SHAPE, a
// MECHANISM, or an INVARIANT with a true answer whatever the corpus holds --
// derived at runtime from what the corpus actually returned. A test that said
// `the` is 23,081 hits would go red the first time an episode was re-cut, and
// would have been testing the corpus rather than the code.

const CHUNK_STEP = 237;
const CHUNK_OVERLAP = 3.5;
const LEAD_PAD = 0.35;

type Hit = {
  id: string;
  video: string;
  start: number;
  from: number;
  suspect: boolean;
  after: string;
  text: string;
  confMin: number | null;
};
type Result = {
  hits: Hit[];
  total: number;
  collapsed: number;
  suppressed: number;
};

const find = async (request: APIRequestContext, qs: string): Promise<Result> => {
  const r = await request.get(`/api/phrases?${qs}`);
  expect(r.ok(), `GET /api/phrases?${qs} -> ${r.status()}`).toBe(true);
  return (await r.json()) as Result;
};

/** The word the whole suite hangs off. Common enough to page, in every episode. */
const COMMON = "the";

const attr = async (page: Page, sel: string, name: string): Promise<string> =>
  (await page.locator(sel).first().getAttribute(name)) ?? "";

// ---------------------------------------------------------------------------
// 1. The route itself.
// ---------------------------------------------------------------------------

// A STATIC segment inside app/browse/[song]/'s territory. When this regresses
// the page still renders perfectly on its own and only the URL stops working,
// which is the failure mode that goes unnoticed longest.
test("/browse/find is not swallowed by the [song] route", async ({ page }) => {
  const res = await page.goto("/browse/find");
  expect(res?.status()).toBe(200);
  await expect(page.getByRole("navigation", { name: "Breadcrumb" })).toContainText("find");
  await expect(page.locator("#phrase-q")).toBeVisible();
});

// ---------------------------------------------------------------------------
// 2. No query builds no index.
// ---------------------------------------------------------------------------

// Building 105 MB of blob to draw an empty search box would be the whole cost
// of the feature paid for nothing. This reads what THIS RENDER built, not what
// happens to be in memory -- otherwise it would pass or fail on test order.
test("an empty console does not build the index", async ({ page }) => {
  await page.goto("/browse/find");
  expect(await attr(page, "[data-find]", "data-corpus-built")).toBe("0");

  await page.goto(`/browse/find?q=${COMMON}`);
  expect(Number(await attr(page, "[data-find]", "data-corpus-built"))).toBeGreaterThan(0);
});

// ---------------------------------------------------------------------------
// 3-5. What a page of results is, and what a row promises.
// ---------------------------------------------------------------------------

test("paging is honest: same total, disjoint pages, more held than shown", async ({ page }) => {
  await page.goto(`/browse/find?q=${COMMON}`);
  const total = await attr(page, "[data-find]", "data-total");
  const shown = await attr(page, "[data-find]", "data-shown");
  expect(Number(total)).toBeGreaterThan(Number(shown));

  const ids1 = await page.locator("[data-hit]").evaluateAll((els) =>
    els.map((e) => e.getAttribute("data-hit")),
  );

  await page.goto(`/browse/find?q=${COMMON}&page=2`);
  expect(await attr(page, "[data-find]", "data-total")).toBe(total);
  const ids2 = await page.locator("[data-hit]").evaluateAll((els) =>
    els.map((e) => e.getAttribute("data-hit")),
  );

  expect(ids2.length).toBeGreaterThan(0);
  const first = new Set(ids1);
  expect(ids2.filter((id) => first.has(id))).toEqual([]);
});

// A hit's identity is `<video>#<wordIndex>`, never a timestamp: about one pair
// per 100k words shares a `start`, so a time-keyed id would collide and a
// starred pick would silently address a different word. A time-keyed id would
// also contain a `.`, which this pattern rejects.
test("every hit id is word-keyed and unique on the page", async ({ page }) => {
  await page.goto(`/browse/find?q=${COMMON}`);
  const ids = await page.locator("[data-hit]").evaluateAll((els) =>
    els.map((e) => e.getAttribute("data-hit") ?? ""),
  );
  expect(ids.length).toBeGreaterThan(0);
  for (const id of ids) expect(id).toMatch(/^[\w-]+#\d+$/);
  expect(new Set(ids).size).toBe(ids.length);
});

// THE ONE TEST THAT CATCHES SOMEONE SIMPLIFYING TRAP 2 AWAY.
//
// Parakeet timestamps a word's START LATE by 25-290ms, so a preview that seeks
// to word.start clips the first phoneme -- and it does it quietly, sounding
// like the archive is wrong rather than like the window is. The pad is the fix
// and it has to be on EVERY row, clamped at zero for a hit near the top of an
// episode.
test("every row's preview window opens a lead-in before the word", async ({ page }) => {
  await page.goto(`/browse/find?q=${COMMON}`);
  const rows = await page.locator("[data-hit]").evaluateAll((els) =>
    els.map((e) => ({
      start: Number(e.getAttribute("data-start")),
      from: Number(e.getAttribute("data-from")),
    })),
  );
  expect(rows.length).toBeGreaterThan(0);
  for (const r of rows) {
    expect(r.from).toBeCloseTo(Math.max(0, r.start - LEAD_PAD), 3);
  }
});

// ---------------------------------------------------------------------------
// 6-8. The retrieval invariants, all derived from what the corpus returned.
// ---------------------------------------------------------------------------

test("a two-word phrase is strictly adjacent, so it is rarer than its first word", async ({
  request,
}) => {
  const one = await find(request, `q=${COMMON}`);
  expect(one.hits.length).toBeGreaterThan(0);

  // The next word of a real hit's context, so the phrase is guaranteed to exist
  // at least once. No hardcoded pair, no hardcoded count.
  const next = one.hits[0].after.split(/\s+/)[0];
  expect(next, "the first hit has context after it").toBeTruthy();

  const two = await find(request, `q=${encodeURIComponent(`${COMMON} ${next}`)}`);
  expect(two.total).toBeGreaterThan(0);
  expect(two.total).toBeLessThan(one.total);
});

// The fold is a STATED delta, never a silent truncation -- the same rule
// ROW_LIMIT follows. If `collapsed` ever stopped matching what went missing,
// the page would be quietly hiding hits while claiming a total.
test("folding chunk twins removes exactly what it says it removed", async ({ request }) => {
  const raw = await find(request, `q=${COMMON}&dupes=0`);
  const folded = await find(request, `q=${COMMON}&dupes=1`);
  expect(raw.collapsed).toBe(0);
  expect(folded.collapsed).toBeGreaterThan(0);
  expect(raw.total - folded.total).toBe(folded.collapsed);
});

// The discriminator itself. In a deduped result no two hits in one episode may
// sit within 0.6s of each other with the later one inside a transcription seam:
// that combination IS the artefact. Genuine stutters live outside the band and
// must survive, which is why the rule is a conjunction and not a time window.
test("no chunk-seam twin survives a deduped result", async ({ request }) => {
  const seen: { video: string; start: number }[] = [];
  for (let p = 1; p <= 4; p += 1) {
    const r = await find(request, `q=${COMMON}&per=200&page=${p}`);
    if (!r.hits.length) break;
    seen.push(...r.hits.map((h) => ({ video: h.video, start: h.start })));
  }
  expect(seen.length).toBeGreaterThan(200);

  const bad = seen.filter((h, i) => {
    if (i === 0) return false;
    const prev = seen[i - 1];
    return (
      prev.video === h.video && h.start - prev.start < 0.6 && h.start % CHUNK_STEP < CHUNK_OVERLAP
    );
  });
  expect(bad).toEqual([]);
});

// ---------------------------------------------------------------------------
// 9-10. What the page is allowed to spawn, and what it asks for.
// ---------------------------------------------------------------------------

// /api/clip/[key]/video spawns an ffmpeg per window. 50 mounted players would
// be 50 processes on a navigation, on a machine that is usually also running a
// transcription -- so the picture mounts for the focused hit, after `v`, and
// never before.
test("no picture is decoded until it is asked for", async ({ page }) => {
  const videoCalls: string[] = [];
  page.on("request", (r) => {
    if (/\/api\/clip\/.*\/video/.test(r.url())) videoCalls.push(r.url());
  });

  await page.goto(`/browse/find?q=${COMMON}`);
  await expect(page.locator("[data-hit]").first()).toBeVisible();
  expect(videoCalls).toEqual([]);

  // Focus a row that actually has media/ behind it, then ask for the picture.
  const rows = page.locator("[data-hit]");
  let asked = false;
  for (let i = 0; i < Math.min(5, await rows.count()); i += 1) {
    await rows.nth(i).locator("[data-context]").click();
    const button = rows.nth(i).getByRole("button", { name: /^picture/ });
    const has = await button
      .waitFor({ state: "visible", timeout: 3000 })
      .then(() => true)
      .catch(() => false);
    if (!has) continue;
    await page.keyboard.press("v");
    await expect(rows.nth(i).locator("video")).toBeVisible();
    asked = true;
    break;
  }
  expect(asked, "at least one of the first five hits has media/").toBe(true);

  // One player, one window, one ffmpeg.
  expect(new Set(videoCalls).size).toBe(1);
});

// The preview reuses the clip route rather than growing a media route of its
// own, and it must ask for the window the row PROMISED -- the lead-in is only
// real if the request carries it.
test("the audition asks the clip route for the window the row advertises", async ({ page }) => {
  const audio: URL[] = [];
  page.on("request", (r) => {
    if (/\/api\/clip\/.*\/audio/.test(r.url())) audio.push(new URL(r.url()));
  });

  await page.goto(`/browse/find?q=${COMMON}`);
  const row = page.locator("[data-hit]").first();
  const from = await row.getAttribute("data-from");
  const video = await row.getAttribute("data-video");

  await row.locator("[data-context]").click();
  await page.keyboard.press("Enter");
  await expect.poll(() => audio.length).toBeGreaterThan(0);

  expect(Number(audio[0].searchParams.get("from"))).toBeCloseTo(Number(from), 3);
  // The key is a media ADDRESS -- `<video>@<start>` -- not the hit's identity.
  expect(decodeURIComponent(audio[0].pathname)).toContain(`/api/clip/${video}@`);
});

// ---------------------------------------------------------------------------
// 11. The shortlist.
// ---------------------------------------------------------------------------

test("a starred moment round-trips, and reorder is all-or-nothing", async ({ page, request }) => {
  const name = `spec ${test.info().workerIndex}`;
  const made = await request.post("/api/shortlist", { data: { op: "create", name } });
  expect(made.ok()).toBe(true);
  const slug = (await made.json()).list.slug as string;

  await page.goto(`/browse/find?q=${COMMON}&list=${slug}`);
  const rows = page.locator("[data-hit]");

  // Star the first three, in the order they were starred -- which is the order
  // the list must come back in, because the order IS the edit.
  const starred: { id: string; start: number; from: number }[] = [];
  for (let i = 0; i < 3; i += 1) {
    const row = rows.nth(i);
    await row.locator("[data-context]").click();
    await page.keyboard.press("s");
    await expect(row).toHaveAttribute("data-starred", "1");
    starred.push({
      id: (await row.getAttribute("data-hit")) ?? "",
      start: Number(await row.getAttribute("data-start")),
      from: Number(await row.getAttribute("data-from")),
    });
  }

  const read = async () =>
    (await (await request.get(`/api/shortlist?list=${slug}`)).json()).list as {
      picks: { id: string; start: number; from: number; text: string; q: string }[];
    };

  // A pick is a SNAPSHOT: it carries the window and the query, so a
  // re-transcription that moved the word can be DETECTED rather than silently
  // followed.
  let list = await read();
  expect(list.picks.map((p) => p.id)).toEqual(starred.map((s) => s.id));
  for (const [i, p] of list.picks.entries()) {
    expect(p.start).toBeCloseTo(starred[i].start, 3);
    expect(p.from).toBeCloseTo(starred[i].from, 3);
    expect(p.q).toBe(COMMON);
    expect(p.text.length).toBeGreaterThan(0);
  }

  // A WHOLE PERMUTATION, and it is honoured exactly.
  const reversed = [...starred].reverse().map((s) => s.id);
  const ok = await request.post("/api/shortlist", {
    data: { op: "reorder", list: slug, ids: reversed },
  });
  expect(ok.ok()).toBe(true);
  list = await read();
  expect(list.picks.map((p) => p.id)).toEqual(reversed);

  // Anything that is not a permutation is a disagreement about what the list
  // HOLDS, so it is refused rather than reconciled into an order nobody asked
  // for -- and the list is left exactly as it was.
  for (const ids of [reversed.slice(0, 2), [...reversed, "nope#1"], [reversed[0], reversed[0], reversed[1]]]) {
    const bad = await request.post("/api/shortlist", { data: { op: "reorder", list: slug, ids } });
    expect(bad.status(), JSON.stringify(ids)).toBe(400);
  }
  expect((await read()).picks.map((p) => p.id)).toEqual(reversed);

  // Unstarring from the row takes it back off.
  await rows.nth(0).locator("[data-context]").click();
  await page.keyboard.press("s");
  await expect(rows.nth(0)).toHaveAttribute("data-starred", "0");
  expect((await read()).picks.map((p) => p.id)).not.toContain(starred[0].id);

  expect((await request.get("/api/shortlist?list=does-not-exist")).status()).toBe(404);
  expect(
    (await request.post("/api/shortlist", { data: { op: "reorder", list: "does-not-exist", ids: [] } }))
      .status(),
  ).toBe(404);

  await request.post("/api/shortlist", { data: { op: "delete", list: slug } });
});

// ---------------------------------------------------------------------------
// The flagged-source filter, which was untestable until make-fixture seeded it.
// ---------------------------------------------------------------------------

// suspect-sources.json is DERIVED into the fixture, never copied -- the real
// file holds 116 human judgements about who is speaking. The spec reads the
// seed back rather than guessing which episode it names.
test("hiding flagged sources hides that episode and says how much it hid", async ({ request }) => {
  const seed = JSON.parse(
    readFileSync(path.join(process.cwd(), ".e2e-song", "code", "suspect-sources.json"), "utf8"),
  ) as { k: string }[];
  expect(seed.length, "make-fixture seeded a flagged source").toBeGreaterThan(0);
  const video = seed[0].k.slice(0, seed[0].k.lastIndexOf("@"));

  const scoped = await find(request, `q=${COMMON}&video=${video}`);
  expect(scoped.total).toBeGreaterThan(0);
  expect(scoped.hits.every((h) => h.suspect)).toBe(true);

  const clean = await find(request, `q=${COMMON}&clean=1`);
  expect(clean.hits.every((h) => !h.suspect)).toBe(true);
  // Stated, not silent: what the filter removed is reported as a number.
  expect(clean.suppressed).toBeGreaterThan(0);
  expect(clean.total).toBeLessThan((await find(request, `q=${COMMON}`)).total);
});

// ---------------------------------------------------------------------------
// The mechanism surface, and its refusals.
// ---------------------------------------------------------------------------

test("/api/phrases refuses what it cannot answer", async ({ request }) => {
  expect((await request.get("/api/phrases")).status()).toBe(400);
  // Punctuation only: there is nothing searchable in it, and returning the
  // whole corpus would be worse than saying so.
  expect((await request.get("/api/phrases?q=...")).status()).toBe(400);
  expect((await request.get("/api/phrases?q=a+b+c+d+e+f+g+h+i")).status()).toBe(400);
  expect((await request.get(`/api/phrases?q=${COMMON}&per=500`)).status()).toBe(400);
  expect((await request.get(`/api/phrases?q=${COMMON}&video=no-such-episode`)).status()).toBe(404);
});

// Trap 1, and the console has to say it out loud. The ASR barely transcribes
// fillers -- `um` is 2 occurrences in 623,079 tokens -- which is exactly why the
// palette was mined acoustically. The first search anyone runs will be this one,
// and without the note it reads as the tool being broken.
test("a filler query explains itself and points at /sort", async ({ page }) => {
  await page.goto("/browse/find?q=um");
  await expect(page.locator("[data-note]").first()).toContainText("ACOUSTICALLY");
  await expect(page.getByRole("link", { name: /fillers are in \/sort/i })).toHaveAttribute(
    "href",
    "/sort",
  );
});