// 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 } 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);

    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");

});