/**
 * TASK-0125 — RAG citation post-processor (the mock's deterministic `rag`
 * mode).
 *
 * The RAG app layer (rag.service) sends the retrieved, numbered context as
 * `[n] Source: <label>\n<chunk text>` blocks + a `Question: <q>` line and
 * opts in with `metadata: { mode: "rag" }`. The mock plays the "model" end of
 * that REAL contract: it parses the first source block (`parseRagSource`) and
 * streams a deterministic, CITED answer. These tests pin that contract — the
 * citation post-processor's boundary cases the spec calls out:
 *   - a well-formed single/multi-source prompt → the right `[n]` + label;
 *   - a multi-source prompt cites the FIRST block (the deterministic rule);
 *   - the answer text is truncated to 200 chars of the chunk (no leak);
 *   - a missing/malformed marker → null → the "no results" answer (never the
 *     literal `[[…]]`);
 *   - nested brackets / brackets that are not a source header are not
 *     mis-parsed as a source.
 */
import { describe, expect, it } from "vitest";

import { MockProvider, parseRagSource } from "./index.js";
import type { ChatRequest } from "../types.js";

function ragReq(context: string, question: string): ChatRequest {
  return {
    model: "mock",
    messages: [
      { role: "system", content: "Cite with [n]. Use only the sources." },
      { role: "user", content: `${context}\n\nQuestion: ${question}` },
    ],
    metadata: { mode: "rag" },
  };
}

async function answerText(req: ChatRequest): Promise<string> {
  const p = new MockProvider("openai", 8);
  let text = "";
  for await (const chunk of p.chat(req as never)) {
    const c = chunk as { delta?: string; done?: boolean; finishReason?: string };
    if (c.delta) text += c.delta;
  }
  return text;
}

describe("parseRagSource (the citation post-processor)", () => {
  it("parses a single well-formed source block (n, label, text)", () => {
    const src = parseRagSource(
      "[1] Source: Launch Plan\nThe launch code word is Zanzibar-7.\n\nQuestion: What is the code?",
    );
    expect(src).toEqual({ n: 1, label: "Launch Plan", text: "The launch code word is Zanzibar-7." });
  });

  it("parses a multi-source prompt and cites the FIRST block", () => {
    const src = parseRagSource(
      "[1] Source: Alpha\nfirst chunk\n[2] Source: Beta\nsecond chunk\n\nQuestion: q?",
    );
    expect(src?.n).toBe(1);
    expect(src?.label).toBe("Alpha");
    expect(src?.text).toBe("first chunk");
  });

  it("trims the label and the chunk text", () => {
    const src = parseRagSource("[3] Source:   Padded Label   \n   body text   \n\nQuestion: q?");
    expect(src?.label).toBe("Padded Label");
    expect(src?.text).toBe("body text");
  });

  it("returns null when there is no source header (no results — never a literal marker)", () => {
    expect(parseRagSource("just a plain question with no context")).toBeNull();
    expect(parseRagSource("[n] Source: not-a-number\nx")).toBeNull();
  });

  it("does not mis-parse a bracketed phrase that is not a `Source:` header", () => {
    // A `[1]` inside prose (no `Source:` header) is not a source marker.
    expect(parseRagSource("As noted in [1], the plan is on track.\n\nQuestion: q?")).toBeNull();
    // Nested brackets are not a header either.
    expect(parseRagSource("see [[chunk:abc]] for details\n\nQuestion: q?")).toBeNull();
  });

  it("a source header must be followed by its text on the next line", () => {
    // `[2] Source: X` immediately before `Question:` with no body → empty text.
    const src = parseRagSource("[2] Source: X\n\nQuestion: q?");
    expect(src).toEqual({ n: 2, label: "X", text: "" });
  });

  it("keeps MULTI-LINE chunk text (a whole-page body is not truncated at line 1)", () => {
    // The RAG service feeds a whole doc's body (title line + content lines) as
    // the first source when a page doc out-ranks its chunks. The old `/m`
    // regex made `$` match every line break and cut the text at the first
    // newline — the TASK-0125 integration's seeded `Launch Runbook\n…
    // Zanzibar-7.` parent body proved it.
    const src = parseRagSource(
      "[1] Source: Launch Runbook\nLaunch Runbook\nThe launch code word is Zanzibar-7.\n\nQuestion: What is the code word?",
    );
    expect(src).toEqual({
      n: 1,
      label: "Launch Runbook",
      text: "Launch Runbook\nThe launch code word is Zanzibar-7.",
    });
  });
});

describe("MockProvider rag mode (the cited answer)", () => {
  it("streams a deterministic cited answer: `According to [n] (label): <200 chars>`", async () => {
    const text = await answerText(ragReq("[1] Source: Launch Plan\nThe launch code word is Zanzibar-7.", "What is the launch code word?"));
    expect(text).toBe("According to [1] (Launch Plan): The launch code word is Zanzibar-7.");
  });

  it("truncates the cited chunk text to 200 chars (no leak of the rest)", async () => {
    const longChunk = "x".repeat(350);
    const text = await answerText(ragReq("[2] Source: Big Doc\n" + longChunk, "q?"));
    // 200 chars of the chunk, then the trailing space the per-word streaming adds.
    expect(text).toBe(`According to [2] (Big Doc): ${"x".repeat(200)}`);
    expect(text).not.toContain("x".repeat(201));
  });

  it("no source context → the deterministic no-results answer (no literal marker leaked)", async () => {
    const text = await answerText(ragReq("no context here at all", "What is the code?"));
    expect(text).toBe("I could not find any workspace content that answers this question. Try different wording.");
    expect(text).not.toContain("[");
    expect(text).not.toContain("Zanzibar");
  });

  it("usage is the ceil(len/4) of the user prompt / answer (deterministic)", async () => {
    const p = new MockProvider("openai", 8);
    let usage: { in: number; out: number } | undefined;
    for await (const chunk of p.chat(ragReq("[1] Source: A\nB", "q?") as never)) {
      const c = chunk as { usage?: { in: number; out: number } };
      if (c.usage) usage = { in: c.usage.in, out: c.usage.out };
    }
    expect(usage?.in).toBeGreaterThan(0);
    expect(usage?.out).toBeGreaterThan(0);
  });
});