import { afterEach, beforeEach, describe, expect, test } from "bun:test";
import { chmodSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import { delimiter, join } from "node:path";
import { Effect, Fiber } from "effect";

import { resolveBinary, runCommandAsync, runCommandAsyncEffect } from "./command";

test("retains only bounded stdout and stderr tails", async () => {
  const result = await runCommandAsync(
    process.execPath,
    [
      "-e",
      'process.stdout.write("a".repeat(512)+"stdout-tail");process.stderr.write("b".repeat(512)+"stderr-tail")',
    ],
    { timeoutMs: 5_000, maxOutputBytes: 32 },
  );

  expect(Buffer.byteLength(result.stdout)).toBeLessThanOrEqual(32);
  expect(Buffer.byteLength(result.stderr)).toBeLessThanOrEqual(32);
  expect(result.stdout.endsWith("stdout-tail")).toBe(true);
  expect(result.stderr.endsWith("stderr-tail")).toBe(true);
});

test("abort waits for the child process to exit", async () => {
  const controller = new AbortController();
  let closed = false;
  const command = runCommandAsync(process.execPath, ["-e", "setInterval(()=>{},1000)"], {
    timeoutMs: 60_000,
    signal: controller.signal,
    onSpawn: (child): void => {
      child.once("close", () => {
        closed = true;
      });
    },
  });

  controller.abort();
  await command;
  expect(closed).toBe(true);
});

test("effect interruption kills and settles the child process", async () => {
  let closed = false;
  const fiber = Effect.runFork(
    runCommandAsyncEffect(process.execPath, ["-e", "setInterval(()=>{},1000)"], {
      timeoutMs: 60_000,
      onSpawn: (child): void => {
        child.once("close", () => {
          closed = true;
        });
      },
    }),
  );

  await Effect.runPromise(Fiber.interrupt(fiber));
  expect(closed).toBe(true);
});

const executableName = (name: string): string =>
  process.platform === "win32" ? `${name}.exe` : name;

const createExecutable = (directory: string, name: string): string => {
  const filePath = join(directory, executableName(name));
  writeFileSync(filePath, "");
  chmodSync(filePath, 0o755);
  return filePath;
};

describe("resolveBinary", () => {
  let temporaryDirectory: string;
  let savedPath: string | undefined;
  let savedRuntimeBin: string | undefined;
  let savedSnap: string | undefined;
  let savedHome: string | undefined;

  const restoreEnvironment = (key: string, value: string | undefined): void => {
    if (value === undefined) delete process.env[key];
    else process.env[key] = value;
  };

  beforeEach(() => {
    temporaryDirectory = mkdtempSync(join(tmpdir(), "resolve-binary-"));
    savedPath = process.env["PATH"];
    savedRuntimeBin = process.env["LOCAL_STUDIO_RUNTIME_BIN"];
    savedSnap = process.env["SNAP"];
    savedHome = process.env["HOME"];
    delete process.env["LOCAL_STUDIO_RUNTIME_BIN"];
    delete process.env["SNAP"];
  });

  afterEach(() => {
    restoreEnvironment("PATH", savedPath);
    restoreEnvironment("LOCAL_STUDIO_RUNTIME_BIN", savedRuntimeBin);
    restoreEnvironment("SNAP", savedSnap);
    restoreEnvironment("HOME", savedHome);
    rmSync(temporaryDirectory, { recursive: true, force: true });
  });

  test("resolves a bare name from PATH using the platform delimiter", () => {
    const expected = createExecutable(temporaryDirectory, "local-studio-test-tool");
    process.env["PATH"] = temporaryDirectory;
    expect(resolveBinary("local-studio-test-tool")).toBe(expected);
  });

  test("searches every PATH entry, not just the first", () => {
    const emptyDirectory = join(temporaryDirectory, "empty");
    const toolDirectory = join(temporaryDirectory, "tools");
    mkdirSync(emptyDirectory);
    mkdirSync(toolDirectory);
    const expected = createExecutable(toolDirectory, "local-studio-test-tool");
    process.env["PATH"] = [emptyDirectory, toolDirectory].join(delimiter);
    expect(resolveBinary("local-studio-test-tool")).toBe(expected);
  });

  test("resolves from a PATH entry wrapped in quotes", () => {
    const expected = createExecutable(temporaryDirectory, "local-studio-test-tool");
    process.env["PATH"] = `"${temporaryDirectory}"`;
    expect(resolveBinary("local-studio-test-tool")).toBe(expected);
  });

  test("returns null when the binary is not on PATH", () => {
    process.env["PATH"] = temporaryDirectory;
    expect(resolveBinary("local-studio-missing-tool")).toBeNull();
  });

  test("returns null for an empty name", () => {
    expect(resolveBinary("")).toBeNull();
  });

  test("resolves an explicit path directly", () => {
    const expected = createExecutable(temporaryDirectory, "local-studio-test-tool");
    expect(resolveBinary(expected)).toBe(expected);
  });

  test("returns null for an explicit path that does not exist", () => {
    expect(
      resolveBinary(join(temporaryDirectory, executableName("local-studio-missing-tool"))),
    ).toBeNull();
  });

  test("prefers LOCAL_STUDIO_RUNTIME_BIN over PATH", () => {
    const runtimeDirectory = join(temporaryDirectory, "runtime-bin");
    const pathDirectory = join(temporaryDirectory, "path-bin");
    mkdirSync(runtimeDirectory);
    mkdirSync(pathDirectory);
    const expected = createExecutable(runtimeDirectory, "local-studio-test-tool");
    createExecutable(pathDirectory, "local-studio-test-tool");
    process.env["LOCAL_STUDIO_RUNTIME_BIN"] = runtimeDirectory;
    process.env["PATH"] = pathDirectory;
    expect(resolveBinary("local-studio-test-tool")).toBe(expected);
  });

  test("falls back to HOME local bin after PATH", () => {
    const homeDirectory = join(temporaryDirectory, "home");
    const localBin = join(homeDirectory, ".local", "bin");
    mkdirSync(localBin, { recursive: true });
    const expected = createExecutable(localBin, "local-studio-test-tool");
    process.env["HOME"] = homeDirectory;
    process.env["PATH"] = join(temporaryDirectory, "does-not-exist");
    expect(resolveBinary("local-studio-test-tool")).toBe(expected);
  });

  test("returns null for a file without the execute bit", () => {
    if (process.platform === "win32") return;
    const filePath = join(temporaryDirectory, "local-studio-test-tool");
    writeFileSync(filePath, "");
    chmodSync(filePath, 0o644);
    process.env["PATH"] = temporaryDirectory;
    expect(resolveBinary("local-studio-test-tool")).toBeNull();
  });
});