// Against a real hub when the binary exists: create a repository, an

// issue and a proposal through the client.

import { test } from "node:test";

import assert from "node:assert/strict";

import { spawn, execFileSync } from "node:child_process";

import { mkdtempSync, writeFileSync, existsSync, mkdirSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { HubClient, HubError, encodeDiffQuery, decodeDiffQuery, hubTarget, releaseNotes, looksPrerelease, trustMarkdown } from "../out/hub.mjs";

const HUB = join(import.meta.dirname, "../../oxygenhub/target/release/oxygenhub");

const OXY = join(import.meta.dirname, "../../oxygen/target/release/oxy");

test("hub client end to end", { skip: !existsSync(HUB) || !existsSync(OXY) }, async () => {

  const data = mkdtempSync(join(tmpdir(), "hubvs-"));

  const port = 17300 + Math.floor(Math.random() * 1000);

  const base = `http://127.0.0.1:${port}`;

  writeFileSync(join(data, "hub.toml"), `[server]\nbind = "127.0.0.1:${port}"\nbase_url = "${base}"\n[auth]\npush_tokens = ["site"]\n[registration]\nmode = "open"\n`);

  execFileSync(HUB, ["--data", data, "init"], { stdio: "ignore" });

  execFileSync(HUB, ["--data", data, "admin", "user", "create", "andy", "--admin"], { stdio: "ignore" });

  const proc = spawn(HUB, ["--data", data, "serve"], { stdio: "ignore" });

  try {

    for (let i = 0; i < 50; i++) {

      try {

        await fetch(`${base}/health`);

        break;

      } catch {

        await new Promise((r) => setTimeout(r, 100));

      }

    }

    const client = new HubClient(base, "site");

    // The client has no createRepository method by design; use fetch directly.

    const res = await fetch(`${base}/api/v1/repos`, { method: "POST", headers: { authorization: "Bearer site", "content-type": "application/json" }, body: JSON.stringify({ owner: "andy", name: "demo" }) });

    assert.equal(res.status, 201);

    // Push a bookmark with oxy so a proposal has something to add.

    const work = mkdtempSync(join(tmpdir(), "hubvs-work-"));

    const env = { ...process.env, OXY_HOME: mkdtempSync(join(tmpdir(), "hubvs-home-")) };

    const oxy = (...args) => execFileSync(OXY, ["--plain", ...args], { cwd: work, env, stdio: ["ignore", "pipe", "pipe"] }).toString();

    oxy("init");

    oxy("remote", "add", "origin", `${base}/andy/demo`);

    oxy("config", "remote.origin.token", "site");

    mkdirSync(join(work, "src"), { recursive: true });

    writeFileSync(join(work, "src/a.txt"), "a\n");

    oxy("commit", "-m", "base");

    oxy("push", "origin");

    oxy("bookmark", "create", "feat");

    oxy("bookmark", "switch", "feat");

    writeFileSync(join(work, "src/b.txt"), "b\n");

    writeFileSync(join(work, "src/a.txt"), "a\nA\n");

    oxy("commit", "-m", "feat");

    oxy("push", "origin", "--bookmark", "feat");

    const p = await client.createProposal("andy", "demo", { title: "Feat", target: "main", source: "feat", body: "", draft: false });

    assert.equal(p.number, 1);

    assert.equal(p.changes.length, 1);

    // The proposal's files and both sides, as the diff editors fetch them.

    const files = await client.proposalFiles("andy", "demo", 1);

    assert.deepEqual(

      files.map((f) => [f.path, f.kind]),

      [

        ["src/a.txt", "modified"],

        ["src/b.txt", "added"],

      ],

    );

    assert.equal(await client.proposalContent("andy", "demo", 1, "base", "src/a.txt"), "a\n");

    assert.equal(await client.proposalContent("andy", "demo", 1, "head", "src/a.txt"), "a\nA\n");

    assert.equal(await client.proposalContent("andy", "demo", 1, "base", "src/b.txt"), undefined, "absent on the target side");

    // A review comment from the diff comes back on its line.

    const c = await client.commentProposal("andy", "demo", 1, "why?", "src/a.txt", 2);

    assert.equal(c.line, 2);

    const comments = await client.proposalComments("andy", "demo", 1);

    assert.equal(comments[0].line, 2);

    const list = await client.proposals("andy", "demo");

    assert.equal(list[0].title, "Feat");

    const issue = await client.createIssue("andy", "demo", "Bug", "text");

    assert.equal(issue.number, 2);

    await client.commentIssue("andy", "demo", 2, "more");

    const closed = await client.setIssueState("andy", "demo", 2, "closed");

    assert.equal(closed.state, "closed");

    // The inbox: the site token acts as the administrator, andy.

    const inbox = await client.notifications();

    assert.equal(typeof inbox.unread, "number");

    assert.ok(Array.isArray(inbox.items));

    await client.markAllNotificationsRead();

    assert.equal((await client.notifications()).unread, 0);

    // Releases: a tag pushed with oxy, then released with notes from history.

    oxy("bookmark", "switch", "main");

    oxy("tag", "create", "v1.0", "-m", "First");

    oxy("push", "origin");

    const tags = await client.tags("andy", "demo");

    assert.deepEqual(tags.map((t) => t.name), ["v1.0"]);

    assert.deepEqual(await client.releases("andy", "demo"), []);

    const hist = await client.history("andy", "demo", "v1.0", 500);

    const rel = await client.createRelease("andy", "demo", { tag: "v1.0", title: "One", notes: releaseNotes(hist.changes, []), prerelease: false });

    assert.equal(rel.tag, "v1.0");

    assert.match(rel.notes, /- base \(/);

    const rels = await client.releases("andy", "demo");

    assert.equal(rels.length, 1);

    assert.equal(rels[0].title, "One");

    const me = await client.me();

    assert.equal(me.username, "andy");

    await assert.rejects(() => new HubClient(base, "nope").me(), (e) => e instanceof HubError && e.status === 401);

  } finally {

    proc.kill();

  }

});

test("diff document queries round trip", () => {

  const ref = { base: "https://earth.example:7343", owner: "andy", name: "demo", number: 7, side: "head", path: "src/dir with space/a.txt" };

  const back = decodeDiffQuery(encodeDiffQuery(ref), "/" + ref.path);

  assert.deepEqual(back, ref);

  assert.equal(decodeDiffQuery("hub=x&owner=a&name=b&number=0&side=head", "/p"), undefined, "number must be positive");

  assert.equal(decodeDiffQuery("hub=x&owner=a&name=b&number=3&side=left", "/p"), undefined, "side is base or head");

  assert.equal(decodeDiffQuery("owner=a&name=b&number=3&side=head", "/p"), undefined, "the hub is required");

});

test("hub page urls open in the editor when they are proposals or issues", () => {

  assert.deepEqual(hubTarget("https://earth.example:7343/andy/oxygen/proposal/12"), { kind: "proposal", base: "https://earth.example:7343", owner: "andy", name: "oxygen", number: 12 });

  assert.deepEqual(hubTarget("https://h/andy/demo/issue/3#c7"), { kind: "issue", base: "https://h", owner: "andy", name: "demo", number: 3 });

  assert.equal(hubTarget("https://h/andy/demo/releases/tag/v1").kind, "other");

  assert.equal(hubTarget("https://h/andy/demo/proposal/x").kind, "other");

});

test("release notes list the changes since the previous release, newest first", () => {

  const c = (hash, message, when_ms) => ({ hash, message, when_ms, author: {}, deps: [], head: false, signature: {} });

  const old = [c("a".repeat(64), "base", 1)];

  const now = [...old, c("b".repeat(64), "Add feature\n\nbody", 2), c("c".repeat(64), "Fix bug", 3)];

  assert.equal(releaseNotes(now, old, "v1.0"), `Changes since v1.0:\n\n- Fix bug (${"c".repeat(12)})\n- Add feature (${"b".repeat(12)})\n`);

  assert.equal(releaseNotes(old, old, "v1.0"), "No changes since the last release.\n");

  assert.match(releaseNotes(old, []), /^Changes:\n\n- base/);

});

test("pre-release tags are recognised", () => {

  for (const t of ["v1.0-rc1", "2.0.0-beta.2", "v3-alpha", "1.0.0-pre", "v2.1b3".replace("b3", "-b3")]) {

    assert.ok(looksPrerelease(t), t);

  }

  for (const t of ["v1.0", "2.0.0", "release-2026", "v1.0-final", "debate"]) {

    assert.ok(!looksPrerelease(t), t);

  }

});

test("file links: line ranges and state-address permalinks", async () => {

  const { hubUrl } = await import("../out/hub.mjs");

  const a = "a".repeat(64), b = "b".repeat(64);

  assert.equal(

    hubUrl("https://h:7343", "andy", "oxy", { kind: "file", reference: `${a}+${b}`, path: "src/main.rs", line: 10, endLine: 20 }),

    `https://h:7343/andy/oxy/file/${a}+${b}/src/main.rs#L10-L20`,

  );

  assert.equal(hubUrl("https://h", "a", "r", { kind: "file", reference: "main", path: "x.rs", line: 3, endLine: 3 }), "https://h/a/r/file/main/x.rs#L3");

  assert.equal(hubUrl("https://h", "a", "r", { kind: "file", reference: "feature/x", path: "x.rs" }), "https://h/a/r/file/feature%2Fx/x.rs");

});

/** A fetch that records each request and answers from `reply`. */

function recorder(reply = () => ({})) {

  const calls = [];

  const f = async (url, init = {}) => {

    const body = init.body ? JSON.parse(init.body) : undefined;

    calls.push({ method: init.method ?? "GET", path: url.replace("https://hub/api/v1", ""), body, auth: new Headers(init.headers).get("authorization") });

    const out = reply(init.method ?? "GET", url);

    return out === null ? new Response(null, { status: 204 }) : new Response(JSON.stringify(out), { status: 200 });

  };

  return { calls, f };

}

test("drops, Flow decisions, drafts and starters go where the hub serves them", async () => {

  const { calls, f } = recorder((m) => (m === "DELETE" ? null : {}));

  const c = new HubClient("https://hub", "tok", f);

  const id = "0123456789abcdef01234567";

  await c.drops();

  await c.userDrops("sky blue");

  await c.drop(id);

  await c.createDrop({ title: "t", secret: true, files: [{ name: "a.md", content: "x" }] });

  await c.editDrop(id, { files: [{ name: "a.md", content: null }], message: "Remove a.md" });

  await c.deleteDrop(id);

  await c.forkDrop(id);

  await c.starDrop(id, true);

  await c.starDrop(id, false);

  await c.dropComments(id);

  await c.commentDrop(id, "hi");

  await c.deleteDropComment(id, 3);

  await c.decideFlowJob("o", "n", 7, "deploy prod", true);

  await c.decideFlowJob("o", "n", 7, "deploy", false);

  await c.expediteFlowRun("o", "n", 7, "outage");

  await c.jobReports("o", "n", 7, "bench");

  await c.testReports("o", "n", "main", 1);

  await c.testReport("o", "n", 4);

  await c.setProposalDraft("o", "n", 2, false);

  await c.userProposals(true);

  await c.releaseTrust("o", "n", "v1.0");

  await c.createRepository({ owner: "o", name: "n2" });

  await c.starterAssistants("my org");

  await c.startStarter("o", "n2", { description: "a CLI" });

  assert.deepEqual(

    calls.map((x) => `${x.method} ${x.path}`),

    [

      "GET /drops",

      "GET /users/sky%20blue/drops",

      `GET /drops/${id}`,

      "POST /drops",

      `PATCH /drops/${id}`,

      `DELETE /drops/${id}`,

      `POST /drops/${id}/fork`,

      `PUT /drops/${id}/star`,

      `DELETE /drops/${id}/star`,

      `GET /drops/${id}/comments`,

      `POST /drops/${id}/comments`,

      `DELETE /drops/${id}/comments/3`,

      "POST /repos/o/n/flow/runs/7/jobs/deploy%20prod/approve",

      "POST /repos/o/n/flow/runs/7/jobs/deploy/reject",

      "POST /repos/o/n/flow/runs/7/expedite",

      "GET /repos/o/n/flow/runs/7/jobs/bench/reports",

      "GET /repos/o/n/tests?limit=1&bookmark=main",

      "GET /repos/o/n/tests/4",

      "PATCH /repos/o/n/proposals/2",

      "GET /user/proposals?landable=true",

      "GET /repos/o/n/releases/trust/v1.0",

      "POST /repos",

      "GET /user/starter?owner=my%20org",

      "POST /repos/o/n2/starter",

    ],

  );

  assert.deepEqual(calls[4].body, { files: [{ name: "a.md", content: null }], message: "Remove a.md" }, "a null content removes a file");

  assert.deepEqual(calls[10].body, { body: "hi" });

  assert.deepEqual(calls[14].body, { reason: "outage" });

  assert.deepEqual(calls[18].body, { draft: false });

  assert.ok(calls.every((x) => x.auth === "Bearer tok"));

});

test("downloads carry the token only to the hub itself", async () => {

  const seen = [];

  const f = async (url, init = {}) => (seen.push([url, new Headers(init.headers).get("authorization")]), new Response(new Uint8Array([1, 2, 3])));

  const c = new HubClient("https://hub", "tok", f);

  assert.deepEqual([...(await c.download("https://hub/o/n/releases/download/v1/a.tar.gz"))], [1, 2, 3]);

  await c.download("https://elsewhere.example/a.tar.gz");

  assert.deepEqual(seen, [

    ["https://hub/o/n/releases/download/v1/a.tar.gz", "Bearer tok"],

    ["https://elsewhere.example/a.tar.gz", null],

  ]);

});

test("a release's trust report reads as Markdown", () => {

  const md = trustMarkdown({

    repository: "andy/oxygen", tag: "v1.0", title: "One", release_url: "https://hub/andy/oxygen/releases/v1.0", heads: ["a".repeat(64)],

    tag_signer: { key: "k", name: "Andy", email: "a@x" }, tag_signature: "valid", since: "v0.9", changes: 3,

    authors: [{ who: { name: "Andy", email: "a@x", account: "andy" }, changes: 3, signed: 2, sealed: 1, unsigned: 0, revoked: 0, invalid: 0 }],

    assets: [{ name: "oxy.tar.gz", size: 9, blake3: "b".repeat(64), url: "", build: { run: 5, job: "dist", run_url: "https://hub/r/5", same_state_as_tag: true } }],

    audit: [{ verdict: "pass", title: "Tag signed", detail: "" }, { verdict: "warn", title: "One author", detail: "a bus factor of one" }],

    generated_ms: 0,

  });

  assert.match(md, /^# Trust: One$/m);

  assert.match(md, /Tag signature: \*\*valid\*\* by Andy <a@x>/);

  assert.match(md, /3 changes since v0.9/);

  assert.match(md, /^- ✔ \*\*Tag signed\*\*$/m);

  assert.match(md, /^- ! \*\*One author\*\* — a bus factor of one$/m);

  assert.match(md, /\| andy \| 3 \| 2 \| 1 \| 0 \| 0 \| 0 \|/);

  assert.match(md, /`oxy.tar.gz` · BLAKE3 `bbbbbbbbbbbbbbbb…` · built by \[run #5\]\(https:\/\/hub\/r\/5\) dist$/m);

});