// The process wrapper against the real oxy binary on a scratch repository.

// Runs with `npm test`; needs oxy on PATH, at ~/.local/bin/oxy, or in OXY_BIN.

import { test } from "node:test";

import assert from "node:assert/strict";

import { mkdtempSync, writeFileSync, mkdirSync, readFileSync, readdirSync, rmSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

import { Oxy, findBinary, isRemoteBookmark, mergeChoices, parseKeptBoth } from "../out/oxy.mjs";

const binary = process.env.OXY_BIN ?? findBinary(undefined);

const oxy = new Oxy(binary);

/** Whether the oxy under test is at least `min` (a feature newer than the oldest oxy the tests run with). */

const oxyVersion = (await oxy.version()).version;

function atLeast(min) {

  const [a, b] = [oxyVersion, min].map((v) => v.split(/[.-]/).slice(0, 3).map(Number));

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

    if (a[i] !== b[i]) {

      return a[i] > b[i];

    }

  }

  return true;

}

test("root, status, cat, log and commit round trip", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  const version = await oxy.version();

  assert.equal(version.protocol, 1);

  assert.equal(await oxy.root(dir), null, "outside a repository");

  const info = await oxy.root(root);

  assert.equal(info?.bookmark, "main");

  assert.ok(info?.root.endsWith("repo"));

  writeFileSync(join(root, "a.txt"), "one\n");

  let status = await oxy.status(root);

  assert.deepEqual(status.paths, [{ path: "a.txt", status: "Added" }]);

  assert.equal(status.clean, false);

  await oxy.commit(root, "first");

  status = await oxy.status(root);

  assert.equal(status.clean, true);

  writeFileSync(join(root, "a.txt"), "one\ntwo\n");

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "one\n", "the base version");

  const log = await oxy.log(root, 10);

  assert.equal(log.changes.filter((c) => !c.working_copy).length, 1);

  assert.equal(log.changes.find((c) => !c.working_copy)?.signature?.status, "unsigned");

  assert.ok((await oxy.prompt(root)).includes("main"));

  const bookmarks = await oxy.bookmarks(root);

  assert.deepEqual(bookmarks.map((b) => [b.name, b.current]), [["main", true]]);

  await assert.rejects(oxy.cat(root, "missing.txt"), /not in that state/);

  // Amend folds the edit into the single head.

  await oxy.amend(root, "first, amended");

  assert.equal((await oxy.status(root)).clean, true);

  assert.ok((await oxy.log(root, 10)).changes.some((c) => c.message === "first, amended"));

  // Hunks: commit only b.txt's, leave a.txt's edit, then discard it.

  writeFileSync(join(root, "a.txt"), "one\ntwo\nthree\n");

  writeFileSync(join(root, "b.txt"), "b\n");

  const hunks = await oxy.hunks(root);

  assert.ok(hunks.length >= 2, JSON.stringify(hunks));

  const bHunk = hunks.find((h) => h.path === "b.txt");

  await oxy.commitHunks(root, "b only", [bHunk.index]);

  status = await oxy.status(root);

  assert.deepEqual(status.paths.map((p) => p.path), ["a.txt"], "a.txt stays uncommitted");

  assert.equal((await oxy.cat(root, "b.txt")).toString(), "b\n", "committed with its content");

  await oxy.discard(root, ["a.txt"]);

  assert.equal((await oxy.status(root)).clean, true);

  // The operation log, and undo of the last operation (the commit).

  const ops = await oxy.opLog(root);

  assert.ok(ops[0].current && ops.length > 3);

  assert.match(await oxy.undo(root), /Undone/);

  status = await oxy.status(root);

  assert.ok(status.paths.some((p) => p.path === "b.txt"), "the commit is undone; b.txt is uncommitted work again");

});

test("bookmarks, remotes and sync against a local origin", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-sync-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "origin"]);

  await oxy.clone(dir, join(dir, "origin"), join(dir, "work"));

  const root = join(dir, "work");

  writeFileSync(join(root, "a.txt"), "a\n");

  await oxy.commit(root, "a");

  const remotes = await oxy.remotes(root);

  assert.equal(remotes[0].name, "origin");

  let push = await oxy.push(root);

  assert.equal(push[0].ok, true);

  let bookmarks = await oxy.bookmarks(root);

  assert.deepEqual(bookmarks.map((b) => [b.name, b.current, b.ahead, b.behind]), [["main", true, 0, 0]]);

  await oxy.bookmarkCreate(root, "feature");

  await oxy.bookmarkSwitch(root, "feature");

  writeFileSync(join(root, "a.txt"), "a\nfeature\n");

  await oxy.commit(root, "feature work");

  bookmarks = await oxy.bookmarks(root);

  assert.equal(bookmarks.find((b) => b.current)?.name, "feature");

  await oxy.bookmarkSwitch(root, "main");

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "a\n");

  writeFileSync(join(root, "b.txt"), "b\n");

  await assert.rejects(oxy.bookmarkSwitch(root, "feature"), /has changes/);

  await oxy.commit(root, "b on main");

  assert.match(await oxy.merge(root, "feature"), /Merged/);

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "a\nfeature\n");

  push = await oxy.push(root, "origin", "feature");

  assert.equal(push[0].ok, true);

  push = await oxy.push(root);

  assert.equal(push[0].ok, true);

  const fetch = await oxy.fetch(root);

  assert.equal(fetch.remote, "origin");

  const pull = await oxy.pull(root);

  assert.equal(pull.changed, false);

  await oxy.bookmarkDelete(root, "feature");

  bookmarks = await oxy.bookmarks(root);

  assert.deepEqual(bookmarks.map((b) => b.name), ["main"]);

  // Blame, show, diff text, and file history.

  const blame = await oxy.blame(root, "a.txt");

  assert.deepEqual(blame.map((l) => l.line), [1, 2]);

  assert.notEqual(blame[0].hash, blame[1].hash, "two changes introduced the two lines");

  const show = await oxy.show(root, `#${blame[1].hash.slice(0, 12)}`);

  assert.equal(show.message, "feature work");

  assert.deepEqual(show.files.map((f) => f.path), ["a.txt"]);

  assert.match(await oxy.diffText(root, `#${blame[1].hash.slice(0, 12)}`), /\+feature/);

  const history = await oxy.log(root, 50, "a.txt");

  assert.equal(history.changes.filter((c) => !c.working_copy).length, 2);

  // Tags, workspaces, trust, bisect status, subrepos.

  await oxy.tagCreate(root, "v1", [], "first");

  const tags = await oxy.tags(root);

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

  const workspaces = await oxy.workspaces(root);

  assert.equal(workspaces.length, 1);

  assert.equal(workspaces[0].current, true);

  assert.equal(await oxy.policyShow(root), null, "no policy yet");

  const verify = await oxy.verify(root);

  assert.ok(verify.every((v) => v.status === "unsigned"));

  assert.equal(await oxy.bisectStatus(root), null);

  assert.deepEqual(await oxy.submodules(root), []);

  await oxy.bisectStart(root);

  assert.equal((await oxy.bisectStatus(root))?.state, "need-marks");

  await oxy.bisectReset(root);

});

test("split, squash and rebase through the history actions, each undoable", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-hist-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(root, "a.txt"), "a\n");

  await oxy.commit(root, "one");

  writeFileSync(join(root, "b.txt"), "b\n");

  writeFileSync(join(root, "c.txt"), "c\n");

  await oxy.commit(root, "two files");

  const find = async (m) => (await oxy.log(root, 50)).changes.find((c) => !c.working_copy && c.message.startsWith(m));

  // Split: b.txt becomes its own change, c.txt stays.

  const two = await find("two files");

  const out = await oxy.split(root, `#${two.hash.slice(0, 12)}`, ["b.txt"]);

  assert.match(out, /Split into/);

  const part = await find("two files (part 1");

  assert.ok(part, "the first part exists");

  assert.deepEqual((await oxy.show(root, `#${part.hash.slice(0, 12)}`)).files.map((f) => f.path), ["b.txt"]);

  await oxy.undo(root);

  assert.equal(await find("two files (part 1"), undefined, "undo reverses the split");

  // Squash: an edit of a.txt folds into "one", which keeps its ChangeId.

  writeFileSync(join(root, "a.txt"), "a\na2\n");

  await oxy.commit(root, "edit a");

  const one = await find("one");

  const edit = await find("edit a");

  assert.deepEqual(edit.deps, [one.hash]);

  assert.match(await oxy.squash(root, `#${edit.hash.slice(0, 12)}`, `#${one.hash.slice(0, 12)}`), /Squashed into/);

  const after = await find("one");

  assert.equal(after.change_id, one.change_id);

  assert.equal(await find("edit a"), undefined);

  // Rebase onto a state that already has the change is refused, with oxy's reason.

  await assert.rejects(oxy.rebase(root, `#${after.hash.slice(0, 12)}`, ["main"]), /already part of the target state/);

});

test("identity reports how commits are signed", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-id-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  assert.equal(await oxy.identity(root), null, "none yet");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  const id = await oxy.identity(root);

  assert.equal(id?.who, "Test <[email protected]>");

  assert.equal(id?.secret, true);

  assert.ok(id?.mode === "change" || id?.mode === "seal");

});

// ---------------------------------------------------------------- oxy 0.5 to 0.9 (oxygen-vscode#11)

test("oxy resolve --both's report is read", () => {

  const text = [

    "kept both  CHANGELOG.md: conflict 1, 3",

    "markers    CHANGELOG.md: conflict 2: both sides changed these lines; edit the markers",

    "resolved   CHANGELOG.md",

    "markers    src/a.rs",

    "All conflicts are resolved; `oxy commit` will record the resolution.",

  ].join("\n");

  assert.deepEqual(parseKeptBoth(text), {

    kept: [{ path: "CHANGELOG.md", conflicts: [1, 3] }],

    left: [{ path: "CHANGELOG.md", conflict: 2, why: "both sides changed these lines; edit the markers" }],

  });

  assert.deepEqual(parseKeptBoth(""), { kept: [], left: [] });

});

test("Merge Bookmark offers the other local bookmarks, then remotes' bookmarks", () => {

  const list = [

    { name: "main", heads: ["a"], current: true, ahead: 0, behind: 0, remote: "origin" },

    { name: "feature/x", heads: ["b"], current: false, ahead: null, behind: null, remote: null },

    { name: "origin/develop", heads: ["c", "d"], current: false, ahead: null, behind: null, remote: "origin" },

  ];

  assert.deepEqual(list.map(isRemoteBookmark), [false, false, true]);

  assert.deepEqual(mergeChoices(list), [

    { name: "feature/x", remote: null, heads: 1 },

    { name: "origin/develop", remote: "origin", heads: 2 },

  ]);

});

test("tags are withdrawn, signed and never reused", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-tag-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(root, "a.txt"), "a\n");

  await oxy.commit(root, "one");

  await oxy.tagCreate(root, "v1", [], "first");

  assert.match(await oxy.tagWithdraw(root, "v1", "built from the wrong state"), /Withdrew v1/);

  assert.deepEqual(await oxy.tags(root), [], "a withdrawn tag is not listed");

  await assert.rejects(oxy.tagCreate(root, "v1", [], "again"), /withdrawn/);

  // No remote, so no hub whose transparency log to check: oxy says so.

  await assert.rejects(oxy.tlogVerify(root), /hub/);

});

test("shallow clone, remote bookmarks merged, amend and commit by paths", async () => {

  const dir = mkdtempSync(join(tmpdir(), "oxy-vscode-paths-"));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "origin"]);

  const origin = join(dir, "origin");

  await oxy.check(origin, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(origin, "a.txt"), "a\n");

  await oxy.commit(origin, "one");

  await oxy.clone(dir, origin, join(dir, "work"), 0);

  const root = join(dir, "work");

  assert.equal(readFileSync(join(root, "a.txt"), "utf8"), "a\n", "the shallow clone has the latest state");

  // Amend only one path: the other stays uncommitted work.

  writeFileSync(join(root, "a.txt"), "a\nmore\n");

  await oxy.commit(root, "more");

  writeFileSync(join(root, "a.txt"), "a\nmore\nagain\n");

  writeFileSync(join(root, "c.txt"), "c\n");

  await oxy.amend(root, undefined, ["a.txt"]);

  const status = await oxy.status(root);

  assert.deepEqual(status.paths.map((p) => p.path), ["c.txt"], "c.txt was not folded in");

  assert.equal((await oxy.cat(root, "a.txt")).toString(), "a\nmore\nagain\n");

  rmSync(join(root, "c.txt"));

  // A bookmark made on the origin is merged here as origin/feat, without a local bookmark.

  await oxy.bookmarkCreate(origin, "feat");

  await oxy.bookmarkSwitch(origin, "feat");

  writeFileSync(join(origin, "f.txt"), "f\n");

  await oxy.commit(origin, "feat work");

  await oxy.fetch(root);

  const all = await oxy.bookmarks(root, true);

  assert.deepEqual(mergeChoices(all).map((c) => [c.name, c.remote]), [["origin/feat", "origin"]]);

  assert.deepEqual((await oxy.bookmarks(root)).map((b) => b.name), ["main"], "without --all, local bookmarks only");

  assert.match(await oxy.merge(root, "origin/feat"), /Merged/);

  assert.equal(readFileSync(join(root, "f.txt"), "utf8"), "f\n");

});

/** A repository whose main and other bookmarks changed `t.txt` (inserting after the same line) and `bin.dat` two ways, merged. */

async function conflicted(prefix, text) {

  const dir = mkdtempSync(join(tmpdir(), prefix));

  const home = join(dir, "home");

  mkdirSync(home);

  process.env.OXY_HOME = home;

  await oxy.check(dir, ["init", "repo"]);

  const root = join(dir, "repo");

  await oxy.check(root, ["identity", "create", "--name", "Test", "--email", "[email protected]"]);

  writeFileSync(join(root, "t.txt"), "a\nb\n");

  writeFileSync(join(root, "u.txt"), "a\nb\n");

  writeFileSync(join(root, "bin.dat"), Buffer.from([0, 1, 2, 3]));

  await oxy.commit(root, "base");

  await oxy.bookmarkCreate(root, "other");

  writeFileSync(join(root, "t.txt"), text("X"));

  writeFileSync(join(root, "u.txt"), "a\nX\n");

  writeFileSync(join(root, "bin.dat"), Buffer.from([0, 1, 2, 4]));

  await oxy.commit(root, "main side");

  await oxy.bookmarkSwitch(root, "other");

  writeFileSync(join(root, "t.txt"), text("Y"));

  writeFileSync(join(root, "u.txt"), "a\nY\n");

  writeFileSync(join(root, "bin.dat"), Buffer.from([0, 1, 2, 5]));

  await oxy.commit(root, "other side");

  await oxy.bookmarkSwitch(root, "main");

  await oxy.merge(root, "other");

  return root;

}

test("a binary file's conflict is settled by keeping one side, then its resolution committed by path", async () => {

  const root = await conflicted("oxy-vscode-keep-", (s) => `a\n${s}\n`);

  let status = await oxy.status(root);

  const bin = status.conflicts.find((c) => c.path === "bin.dat");

  assert.equal(bin.kind, "replace");

  assert.equal(bin.changes.length, 2);

  // Keep side 2 as Keep a Side does: its version in place, candidates gone, oxy resolve PATH.

  const side = await oxy.cat(root, "bin.dat", bin.changes[1]);

  writeFileSync(join(root, "bin.dat"), side);

  for (const c of readdirSync(root).filter((e) => e.startsWith("bin.dat.oxy-conflict-"))) {

    rmSync(join(root, c));

  }

  status = await oxy.resolvePaths(root, ["bin.dat"]);

  assert.equal(status.conflicts.find((c) => c.path === "bin.dat").resolved, true);

  assert.ok(status.conflicts.some((c) => c.path !== "bin.dat" && c.resolved !== true), "the text conflicts remain");

  await assert.rejects(oxy.resolvePaths(root, ["u.txt"]), /no replace conflict/);

  // Commit Resolution of Selected Paths: only bin.dat; the text conflicts stay for later.

  await oxy.commit(root, "keep the other logo", ["bin.dat"]);

  status = await oxy.status(root);

  assert.equal(status.conflicts.some((c) => c.path === "bin.dat"), false);

  assert.deepEqual(status.conflicts.map((c) => c.path).sort(), ["t.txt", "u.txt"]);

  assert.deepEqual([...(await oxy.cat(root, "bin.dat"))], [...side]);

});

test("two changes adding lines at the same place are settled with one command", { skip: !atLeast("0.8.0") && `oxy ${oxyVersion} has no resolve --both` }, async () => {

  const root = await conflicted("oxy-vscode-both-", (s) => `a\n${s}\nb\n`);

  const result = await oxy.resolveBoth(root, ["t.txt", "u.txt"]);

  assert.deepEqual(result.kept, [{ path: "t.txt", conflicts: [1] }]);

  assert.deepEqual(result.left.map((l) => [l.path, l.conflict]), [["u.txt", 1]], "u.txt's sides changed the same line");

  assert.match(result.left[0].why, /same lines|edit the markers/);

  assert.equal(readFileSync(join(root, "t.txt"), "utf8"), "a\nX\nY\nb\n", "earliest change first");

  const status = await oxy.status(root);

  assert.equal(status.conflicts.find((c) => c.path === "t.txt").resolved, true);

});