/**
 * AI Software Factory — E2E: RAG workspace search (TASK-0125).
 *
 * Drives the REAL stack (Next web + Nest API + worker + OpenSearch) against
 * the canonical ROADMAP exit check: seed a page with a unique fact, ask about
 * it on the /ask page, and assert the streamed answer cites the fact AND a
 * citation chip whose deep link actually works.
 *
 * The mock provider's RAG mode is deterministic: it returns
 *   `According to [n] (<label>): <chunk text>`
 * from the FIRST numbered context block the RAG service feeds it. So the
 * seeded fact must be retrievable (worker chunks + embeds it) and the answer
 * carries it verbatim — the assertion is exact, not fuzzy.
 *
 * Covered (the spec's E2E AC + the Phase-12 gate item #4 "citation link in
 * the answer DOM"):
 *   1. seed page with a unique fact F → `/ask` → ask "What is the launch code
 *      word?" → streamed answer contains F.
 *   2. a citation chip links to the seeded page; clicking it deep-links to the
 *      page, which renders the fact (the link WORKS — not just present).
 *   3. the Sources list renders the same citation.
 *
 * Indexing is the worker's job: a page write publishes a domain event the
 * stream consumer consumes (search-index upsert + AI embed). We gate on the
 * PAGE being searchable via the public `POST /api/v1/search` (the same
 * permission-filtered path the RAG query uses) before asking — this proves
 * the full pipeline (event → chunk → embed → index) ran.
 *
 * Selector convention (tests/README.md): this task's own data-testids —
 *   ask-ai, ask-ai-input, ask-ai-submit, ask-ai-answer, ask-ai-sources,
 *   ask-ai-chip-{n}, ask-ai-source-{n}.
 *
 * Requires OpenSearch (SEARCH_URL, default http://localhost:9200) reachable —
 * the RAG retrieval path is index-backed. Skipped (not failed) when it is
 * down, mirroring search.integration.test.ts's stack gate.
 */
import { expect, test } from "../fixtures";
import { createBlock, createPage, createWorkspace } from "../utils/api";
import { waitUntilSearchable } from "../utils/search-lag";

/** Is the OpenSearch at `url` (the API's SEARCH_URL default) reachable? */
async function opensearchUp(url: string): Promise<boolean> {
  try {
    const res = await fetch(`${url.replace(/\/+$/, "")}/_cluster/health`, {
      signal: AbortSignal.timeout(5_000),
    });
    return res.ok;
  } catch {
    return false;
  }
}
const SEARCH_URL = process.env.SEARCH_URL ?? "http://localhost:9200";

// A globally unique fact + token: the RAG query is workspace-scoped, but the
// search gate (public /api/v1/search) is not, so a run-unique token cannot
// false-positive on a concurrent worker's shared index.
const RUN = Date.now().toString(36);
const TOKEN = `Zanzibar-${RUN}`;
const FACT = `The launch code word is ${TOKEN}.`;

test("RAG: seeded fact is cited in the streamed answer with a working citation chip", async ({
  api,
  authPage,
}) => {
  // RAG is index-backed; skip (not fail) when OpenSearch is down, mirroring
  // search.integration.test.ts's stack gate (CI always has it). Probed in-test
  // (no top-level await — the Playwright runner transforms this spec to a CJS
  // graph via require(), which rejects top-level `await`).
  const opensearchReady = await opensearchUp(SEARCH_URL);
  test.skip(!opensearchReady, "OpenSearch not reachable (SEARCH_URL) — RAG is index-backed");

  // Seed THROUGH the public API (real authorization layer). `api` is a Bearer
  // context pinned to API_BASE (:4000) — `authPage.request` would resolve
  // against the WEB origin (:3000) and 404, so the seed + search gate use
  // `api`; only the /ask UI uses `authPage`.
  const ws = await createWorkspace(api, `RAG ${RUN}`);
  const page = await createPage(api, ws.id, { title: "Launch Runbook" });
  await createBlock(api, page.id, {
    type: "paragraph",
    content: { text: FACT },
    position: "1.0",
  });

  // Gate on the worker having indexed (+ embedded) the page. The public
  // search is the same permission-filtered path the RAG query uses, so a hit
  // here proves the pipeline (event → chunk → embed → index) ran and the doc
  // is a valid kNN target for the ask below. `waitUntilSearchable` throws on
  // timeout, so resolving means the doc is searchable.
  const lag = await waitUntilSearchable(api, TOKEN, Date.now(), { timeoutMs: 60_000 });
  console.log(`[ai-rag] seeded page searchable after ${lag.lagMs}ms (${lag.polls} polls)`);

  // Drive the REAL /ask UI: navigate to the workspace's ask page.
  await authPage.goto(`/w/${ws.slug}/ask`);
  const input = authPage.getByTestId("ask-ai-input");
  await expect(input).toBeVisible();
  await input.fill("What is the launch code word?");
  await authPage.getByTestId("ask-ai-submit").click();

  // The streamed (mock) answer contains the fact verbatim.
  const answer = authPage.getByTestId("ask-ai-answer");
  await expect(answer).toContainText(TOKEN, { timeout: 30_000 });

  // The Sources list renders the citation (asserted on the /ask page BEFORE
  // the chip click navigates away). The mock always emits the [1] marker for
  // the single source, so [1] is present + linked.
  await expect(authPage.getByTestId("ask-ai-sources")).toBeVisible();
  await expect(authPage.getByTestId("ask-ai-source-1")).toBeVisible();

  // At least one citation chip, linking to the seeded page.
  const chip = authPage.getByTestId("ask-ai-chip-1");
  await expect(chip).toBeVisible();
  const href = await chip.getAttribute("href");
  expect(href, "the citation chip must be a link").toBeTruthy();
  expect(href, `chip href should target the seeded page (got ${href})`).toBe(
    `/w/${ws.slug}/page/${page.id}`,
  );

  // The citation LINK WORKS (Phase-12 gate item #4): following the citation's
  // deep link lands on the seeded page, which renders the fact. We use a
  // full `page.goto(href)` (a hard navigation — what happens if the link is
  // opened fresh) rather than an in-place client-side `click()`: the point is
  // the deep link RESOLVES and renders for the user, and a hard load is the
  // strongest, flake-free proof of that. (A raw HTTP 200 is NOT a strong
  // check — the Next shell returns 200 even unauthenticated — so we assert the
  // seeded content actually renders.)
  await authPage.goto(href!);
  await expect(authPage).toHaveURL(new RegExp(`/w/${ws.slug}/page/`));
  await expect(authPage.getByText(FACT)).toBeVisible();
});