import fs from "node:fs";
import { execFileSync } from "node:child_process";
import os from "node:os";
import path from "node:path";
import { afterEach, beforeEach, describe, expect, it } from "vitest";
import {
  INSTALL_MANIFEST_VERSION,
  MANAGED_SHIM_MARKER,
  addManagedPathBlock,
  buildNextManifest,
  flipCurrentAtomic,
  isManagedExecutable,
  payloadPathFor,
  pruneInstallPayloads,
  readInstallManifest,
  removeManagedPathBlock,
  removeManagedShim,
  resolveInstallStorePaths,
  withInstallStoreLock,
  writeInstallManifestAtomic,
  writeManagedShim,
  type InstallManifest,
  type InstallRecord,
} from "../install-store.js";

function record(payloadPath: string, version: string): InstallRecord {
  return {
    source: "npm",
    version,
    channel: "latest",
    payloadPath,
    installedAt: `2026-07-${version.padStart(2, "0")}T00:00:00.000Z`,
  };
}

describe("managed install store", () => {
  let root: string;
  let paths: ReturnType<typeof resolveInstallStorePaths>;

  beforeEach(() => {
    root = fs.mkdtempSync(path.join(os.tmpdir(), "paperclip-install-store-"));
    paths = resolveInstallStorePaths({
      homeDir: path.join(root, "home"),
      paperclipHome: path.join(root, "home", ".paperclip"),
    });
  });

  afterEach(() => {
    fs.rmSync(root, { recursive: true, force: true });
  });

  it("resolves the documented npm and git payload layout", () => {
    expect(payloadPathFor(paths, "npm", "2026.720.0")).toBe(
      path.join(paths.cliRoot, "installs", "npm", "2026.720.0"),
    );
    expect(payloadPathFor(paths, "git", "ab12cd34ef56")).toBe(
      path.join(paths.cliRoot, "installs", "git", "ab12cd34ef56"),
    );
  });

  it("writes and reads the manifest atomically with private permissions", () => {
    const payloadPath = payloadPathFor(paths, "npm", "1.2.3");
    const manifest: InstallManifest = {
      schemaVersion: INSTALL_MANIFEST_VERSION,
      ...record(payloadPath, "1.2.3"),
      previous: [],
    };
    writeInstallManifestAtomic(manifest, paths);
    expect(readInstallManifest(paths)).toEqual(manifest);
    expect(fs.statSync(paths.manifestPath).mode & 0o777).toBe(0o600);
  });

  it("leaves the old current payload working when interrupted before rename", () => {
    const oldPayload = payloadPathFor(paths, "npm", "1.0.0");
    const newPayload = payloadPathFor(paths, "npm", "2.0.0");
    fs.mkdirSync(oldPayload, { recursive: true });
    fs.mkdirSync(newPayload, { recursive: true });
    flipCurrentAtomic(oldPayload, paths);

    expect(() =>
      flipCurrentAtomic(newPayload, paths, {
        beforeRename: () => {
          throw new Error("simulated crash");
        },
      }),
    ).toThrow("simulated crash");

    expect(fs.realpathSync(paths.currentPath)).toBe(fs.realpathSync(oldPayload));
    expect(fs.readdirSync(paths.cliRoot).filter((entry) => entry.startsWith(".current-"))).toEqual([]);
  });

  it("retains current plus two previous payloads and prunes older entries", () => {
    const payloads = ["1", "2", "3", "4"].map((version) => payloadPathFor(paths, "npm", version));
    for (const payload of payloads) fs.mkdirSync(payload, { recursive: true });
    const previousManifest: InstallManifest = {
      schemaVersion: INSTALL_MANIFEST_VERSION,
      ...record(payloads[2], "3"),
      previous: [record(payloads[1], "2"), record(payloads[0], "1")],
    };
    const next = buildNextManifest(record(payloads[3], "4"), previousManifest);

    expect(next.previous.map((entry) => entry.version)).toEqual(["3", "2"]);
    expect(pruneInstallPayloads(next, paths)).toEqual([payloads[0]]);
    expect(fs.existsSync(payloads[0])).toBe(false);
    expect(payloads.slice(1).every((payload) => fs.existsSync(payload))).toBe(true);
  });

  it("writes a stable shim with the validated runtime and custom store path", () => {
    writeManagedShim(paths);
    const shim = fs.readFileSync(paths.shimPath, "utf8");
    expect(shim).toContain(process.execPath);
    expect(shim).toContain(paths.currentPath);
    expect(shim).not.toContain("PAPERCLIP_HOME");
    expect(fs.statSync(paths.shimPath).mode & 0o777).toBe(0o755);

    const rcPath = path.join(root, "home", ".bashrc");
    expect(addManagedPathBlock(rcPath)).toBe(true);
    expect(addManagedPathBlock(rcPath)).toBe(false);
    fs.chmodSync(rcPath, 0o640);
    expect(removeManagedPathBlock(rcPath)).toBe(true);
    expect(fs.readFileSync(rcPath, "utf8")).not.toContain("paperclipai managed PATH");
    expect(fs.statSync(rcPath).mode & 0o777).toBe(0o640);
  });

  it("uses the pinned Node for child tools even with an older node first on the service PATH", () => {
    const entrypoint = path.join(paths.currentPath, "node_modules", "paperclipai", "dist", "index.js");
    fs.mkdirSync(path.dirname(entrypoint), { recursive: true });
    fs.writeFileSync(entrypoint, `console.log(require("node:child_process").execFileSync("node", ["-p", "process.execPath"], {encoding: "utf8"}).trim())`);
    const oldBin = path.join(root, "old-bin");
    fs.mkdirSync(oldBin);
    fs.writeFileSync(path.join(oldBin, "node"), "#!/bin/sh\nexit 42\n", { mode: 0o755 });
    writeManagedShim(paths);
    const output = execFileSync(paths.shimPath, [], { env: { ...process.env, PATH: oldBin }, encoding: "utf8" });
    expect(fs.realpathSync(output.trim())).toBe(fs.realpathSync(process.execPath));
    expect(removeManagedShim(paths)).toBe(true);
  });

  it("upgrades and removes the original managed shim format", () => {
    writeManagedShim(paths);
    const original = fs.readFileSync(paths.shimPath, "utf8").split("\n").filter((line) => !line.startsWith("export PATH=")).join("\n");
    fs.writeFileSync(paths.shimPath, original);
    writeManagedShim(paths);
    expect(fs.readFileSync(paths.shimPath, "utf8")).toContain("export PATH=");
    fs.writeFileSync(paths.shimPath, original);
    expect(removeManagedShim(paths)).toBe(true);
  });

  it("rejects marker substrings that are not the exact managed shim format", () => {
    fs.mkdirSync(path.dirname(paths.shimPath), { recursive: true });
    fs.writeFileSync(paths.shimPath, `#!/bin/sh\necho '${MANAGED_SHIM_MARKER}'\n`);

    expect(removeManagedShim(paths)).toBe(false);
    expect(fs.existsSync(paths.shimPath)).toBe(true);
    expect(() => writeManagedShim(paths)).toThrow("non-managed command");
  });

  it("serializes install-store mutations with an exclusive lock", async () => {
    await expect(
      withInstallStoreLock(
        () => withInstallStoreLock(async () => undefined, paths),
        paths,
      ),
    ).rejects.toThrow("already running");
    expect(fs.existsSync(paths.lockPath)).toBe(false);
  });

  it("recovers a lock owned by a process that no longer exists", async () => {
    const staleToken = "2147483647:stale";
    await withInstallStoreLock(async () => undefined, paths);
    fs.writeFileSync(paths.lockPath, `${staleToken}\n`, { mode: 0o600 });

    await expect(withInstallStoreLock(async () => undefined, paths)).resolves.toBeUndefined();
    expect(fs.existsSync(paths.lockPath)).toBe(false);
  });

  it("reports managed provenance only for the payload selected by current", () => {
    const manifestPayload = payloadPathFor(paths, "npm", "1.0.0");
    const currentPayload = payloadPathFor(paths, "npm", "2.0.0");
    const executable = path.join(manifestPayload, "node_modules", "paperclipai", "dist", "index.js");
    fs.mkdirSync(path.dirname(executable), { recursive: true });
    fs.writeFileSync(executable, "");
    fs.mkdirSync(currentPayload, { recursive: true });
    flipCurrentAtomic(currentPayload, paths);
    const manifest: InstallManifest = {
      schemaVersion: INSTALL_MANIFEST_VERSION,
      ...record(manifestPayload, "1.0.0"),
      previous: [],
    };

    expect(isManagedExecutable(executable, manifest, paths)).toBe(false);
  });

  it("refuses symlinked payload roots and pre-existing non-managed shims", () => {
    const outside = path.join(root, "outside");
    fs.mkdirSync(outside, { recursive: true });
    fs.mkdirSync(paths.installsRoot, { recursive: true });
    fs.symlinkSync(outside, path.join(paths.installsRoot, "npm"), "dir");
    const escapedPayload = path.join(paths.installsRoot, "npm", "1.2.3");
    fs.mkdirSync(path.join(outside, "1.2.3"));
    expect(() => flipCurrentAtomic(escapedPayload, paths)).toThrow("resolves outside");

    fs.mkdirSync(path.dirname(paths.shimPath), { recursive: true });
    fs.writeFileSync(paths.shimPath, "#!/bin/sh\necho other-command\n");
    expect(() => writeManagedShim(paths)).toThrow("non-managed command");
  });

  it("refuses symlinked rc files, unsafe shim parents, and multiply linked shims", () => {
    const outsideRc = path.join(root, "outside-rc");
    fs.writeFileSync(outsideRc, "keep\n");
    const rcPath = path.join(root, "home", ".bashrc");
    fs.mkdirSync(path.dirname(rcPath), { recursive: true });
    fs.symlinkSync(outsideRc, rcPath);
    expect(() => addManagedPathBlock(rcPath)).toThrow("non-regular shell rc file");
    expect(() => removeManagedPathBlock(rcPath)).toThrow("non-regular shell rc file");
    expect(fs.readFileSync(outsideRc, "utf8")).toBe("keep\n");

    fs.rmSync(rcPath);
    const localDir = path.join(root, "home", ".local");
    const outsideBin = path.join(root, "outside-bin");
    fs.mkdirSync(outsideBin);
    fs.symlinkSync(outsideBin, localDir, "dir");
    expect(() => writeManagedShim(paths)).toThrow("unsafe shim directory");

    fs.rmSync(localDir);
    fs.mkdirSync(path.dirname(paths.shimPath), { recursive: true });
    fs.writeFileSync(paths.shimPath, `# ${MANAGED_SHIM_MARKER}\n`);
    fs.linkSync(paths.shimPath, path.join(root, "linked-shim"));
    expect(() => writeManagedShim(paths)).toThrow("multiply linked shim");
  });
});