import { execFileSync } from "node:child_process";
import { createRequire } from "node:module";
import path from "node:path";
import { fileURLToPath } from "node:url";
import { describe, expect, it } from "vitest";

const __dirname = path.dirname(fileURLToPath(import.meta.url));
const SCRIPT_PATH = path.resolve(__dirname, "changelog-guard.cjs");
const REPO_ROOT = path.resolve(__dirname, "..");
const { evaluate, MAX_LISTED_FILES } = createRequire(import.meta.url)(
  SCRIPT_PATH,
);

function runGuard(args = [], { stdin, env } = {}) {
  try {
    const output = execFileSync(process.execPath, [SCRIPT_PATH, ...args], {
      cwd: REPO_ROOT,
      encoding: "utf8",
      stdio: "pipe",
      input: stdin ?? "",
      env: { ...process.env, ...env },
    });
    return { exitCode: 0, stdout: output, stderr: "" };
  } catch (error) {
    if (error.signal) throw new Error(`Killed by ${error.signal}`);
    return {
      exitCode: error.status ?? 1,
      stdout: error.stdout ?? "",
      stderr: error.stderr ?? "",
    };
  }
}

// A shell pipeline, so the writer owns its end of the pipe. execFileSync's
// `input` hands the script a file descriptor instead, which never reproduces
// a writer that is slow or that marks the pipe non-blocking.
function runPipeline(writerCommand) {
  try {
    const output = execFileSync(
      "bash",
      ["-c", `${writerCommand} | "$0" "$1"`, process.execPath, SCRIPT_PATH],
      { cwd: REPO_ROOT, encoding: "utf8", stdio: "pipe" },
    );
    return { exitCode: 0, stdout: output };
  } catch (error) {
    if (error.signal) throw new Error(`Killed by ${error.signal}`);
    return { exitCode: error.status ?? 1, stdout: error.stdout ?? "" };
  }
}

describe("changelog-guard decision", () => {
  it("fails a user-facing change that carries no changelog entry", () => {
    const { ok, reason } = evaluate({
      changedFiles: ["client/modules/search.ts"],
    });
    expect(ok).toBe(false);
    expect(reason).toContain("client/modules/search.ts");
    expect(reason).toContain("changelog.md");
  });

  it("passes the same change once changelog.md is part of it", () => {
    const { ok } = evaluate({
      changedFiles: ["client/modules/search.ts", "changelog.md"],
    });
    expect(ok).toBe(true);
  });

  it("passes a docs-only change", () => {
    const { ok } = evaluate({
      changedFiles: ["docs/pull-requests.md", "README.md", "agents.md"],
    });
    expect(ok).toBe(true);
  });

  it("passes a lockfile-only change", () => {
    const { ok } = evaluate({
      changedFiles: ["package-lock.json", "package.json"],
    });
    expect(ok).toBe(true);
  });

  it("passes a user-facing change carrying the skip-changelog label", () => {
    const { ok, reason } = evaluate({
      changedFiles: ["server/webSearchService.ts"],
      hasSkipLabel: true,
    });
    expect(ok).toBe(true);
    expect(reason).toContain("skip-changelog");
  });

  // "renovate[bot]" is the REST shape, which the workflow reads.
  // "app/renovate" is the GraphQL shape, which `gh pr view --json author`
  // returns. Both pass, so changing where the author comes from cannot
  // silently break the hatch.
  it.each([
    "renovate[bot]",
    "dependabot[bot]",
    "app/renovate",
    "app/dependabot",
  ])("passes a %s pull request that only bumps the Dockerfile", (login) => {
    const { ok, reason } = evaluate({
      changedFiles: ["Dockerfile"],
      authorLogin: login,
    });
    expect(ok).toBe(true);
    expect(reason).toContain(login);
  });

  it.each(["renovate", "dependabot", "renovate-bot", "app/renovate-fork"])(
    "does not treat %s as a bot login",
    (login) => {
      expect(
        evaluate({ changedFiles: ["Dockerfile"], authorLogin: login }).ok,
      ).toBe(false);
    },
  );

  it("fails a human pull request that changes the Dockerfile with no entry", () => {
    const { ok, reason } = evaluate({
      changedFiles: ["Dockerfile"],
      authorLogin: "felladrin",
    });
    expect(ok).toBe(false);
    expect(reason).toContain("Dockerfile");
  });

  it.each([
    "Dockerfile",
    "docker-compose.yml",
    "docker-compose.production.yml",
    "searxng-settings.yml",
    "client/index.tsx",
    "server/searchToken.ts",
    "shared/types.ts",
  ])("treats %s as user-facing", (filePath) => {
    expect(evaluate({ changedFiles: [filePath] }).ok).toBe(false);
  });

  it.each([
    "docs/api.md",
    "changelog.md",
    "e2e/smoke.spec.ts",
    "scripts/changelog-guard.cjs",
    ".github/workflows/ci.yml",
    "clientele/notes.txt",
  ])("treats %s as not user-facing", (filePath) => {
    expect(evaluate({ changedFiles: [filePath] }).ok).toBe(true);
  });

  it("names today's UTC date in the heading it asks for", () => {
    const { reason } = evaluate({
      changedFiles: ["client/index.tsx"],
      // 00:30 UTC on the 24th; a local-time formatter would print the 23rd.
      now: new Date("2026-09-24T00:30:00Z"),
    });
    expect(reason).toContain("## 2026-09-24");
  });

  it("caps the listed files and counts the rest", () => {
    const changedFiles = Array.from(
      { length: MAX_LISTED_FILES + 3 },
      (_, index) => `client/modules/file${index}.ts`,
    );
    const { ok, reason } = evaluate({ changedFiles });
    expect(ok).toBe(false);
    expect(reason).toContain("and 3 more");
    expect(reason).not.toContain(`file${MAX_LISTED_FILES}.ts,`);
  });

  it("ignores blank lines from an empty git diff", () => {
    expect(evaluate({ changedFiles: ["", "  ", "\n"] }).ok).toBe(true);
  });

  it("requires an entry even when a non-trigger file is also changed", () => {
    const { ok } = evaluate({
      changedFiles: ["docs/api.md", "server/rerankerService.ts"],
    });
    expect(ok).toBe(false);
  });
});

describe("changelog-guard command line", () => {
  it("exits 1 and prints the remedy for a failing change", () => {
    const { exitCode, stdout } = runGuard(["client/modules/search.ts"]);
    expect(exitCode).toBe(1);
    expect(stdout).toContain("client/modules/search.ts");
    expect(stdout).toContain("skip-changelog");
  });

  it("exits 0 for a change that includes the changelog", () => {
    const { exitCode } = runGuard(["client/modules/search.ts", "changelog.md"]);
    expect(exitCode).toBe(0);
  });

  it("reads the changed files from stdin, one per line", () => {
    const { exitCode, stdout } = runGuard([], {
      stdin: "server/searchToken.ts\ndocs/api.md\n",
    });
    expect(exitCode).toBe(1);
    expect(stdout).toContain("server/searchToken.ts");
  });

  it("honours --skip-label", () => {
    expect(runGuard(["Dockerfile", "--skip-label"]).exitCode).toBe(0);
  });

  it("honours --author for a bot", () => {
    expect(runGuard(["Dockerfile", "--author", "renovate[bot]"]).exitCode).toBe(
      0,
    );
    expect(runGuard(["Dockerfile", "--author", "app/renovate"]).exitCode).toBe(
      0,
    );
  });

  it("reads the same facts from the environment", () => {
    expect(
      runGuard(["Dockerfile"], {
        env: { CHANGELOG_GUARD_SKIP_LABEL: "true" },
      }).exitCode,
    ).toBe(0);
    expect(
      runGuard(["Dockerfile"], {
        env: { CHANGELOG_GUARD_AUTHOR: "renovate[bot]" },
      }).exitCode,
    ).toBe(0);
    expect(
      runGuard(["Dockerfile"], {
        env: { CHANGELOG_GUARD_SKIP_LABEL: "false" },
      }).exitCode,
    ).toBe(1);
  });

  it("exits 1 on an unknown option", () => {
    const { exitCode, stderr } = runGuard(["--nope"]);
    expect(exitCode).toBe(1);
    expect(stderr).toContain("Unknown option");
  });

  it("exits 0 when nothing changed", () => {
    expect(runGuard([], { stdin: "" }).exitCode).toBe(0);
  });

  it("waits for a writer that has not produced anything yet", () => {
    const { exitCode, stdout } = runPipeline(
      `sleep 0.3; printf 'server/searchToken.ts\\n'`,
    );
    expect(exitCode).toBe(1);
    expect(stdout).toContain("server/searchToken.ts");
  });

  it("reads a list larger than one read buffer", () => {
    const paths = Array.from(
      { length: 4000 },
      (_, index) => `docs/file${index}.md`,
    );
    paths.push("client/index.tsx");
    const input = `${paths.join("\n")}\n`;
    expect(input.length).toBeGreaterThan(64 * 1024);

    const { exitCode, stdout } = runGuard([], { stdin: input });
    expect(exitCode).toBe(1);
    expect(stdout).toContain("client/index.tsx");
  });
});