import { readFileSync } from "node:fs";
import { fileURLToPath } from "node:url";

import { describe, expect, it } from "vitest";

import {
  autoReviewConfigFileSchema,
  normalizeAutoReviewConfig,
} from "#src/auto-review/config";
import { unifiedConfigSchema } from "#src/config-schema";

/** The bundle's authoritative policy seed, as shipped. */
const SEED_PATH = fileURLToPath(
  new URL("../../config/pi-permission-policy.jsonc", import.meta.url),
);

function readSeed(): Record<string, unknown> {
  const raw = readFileSync(SEED_PATH, "utf8");
  const stripped = raw
    .replace(/^\s*\/\/.*$/gm, "")
    .replace(/\/\*[\s\S]*?\*\//g, "");
  return JSON.parse(stripped) as Record<string, unknown>;
}

describe("bundled policy seed", () => {
  it("follows the session model: enabled, with no provider/model pair", () => {
    const seed = readSeed();
    const parsed = autoReviewConfigFileSchema.safeParse(seed.autoReview);

    expect(parsed.success).toBe(true);
    if (!parsed.success) throw new Error("seed autoReview block is invalid");
    expect(parsed.data).toEqual({ enabled: true });
  });

  it("ships no overrides, so the bundle runs the code-default review knobs", () => {
    const seed = readSeed();
    const parsed = autoReviewConfigFileSchema.parse(seed.autoReview);

    // The seed writes `enabled` only; every effective value below lives in
    // normalizeAutoReviewConfig's defaults. If either the seed or the
    // defaults drift, this fails.
    const effective = normalizeAutoReviewConfig(parsed);
    expect(effective.enabled).toBe(true);
    expect(effective.provider).toBeUndefined();
    expect(effective.model).toBeUndefined();
    expect(effective.reasoning).toBe("low");
    expect(effective.timeoutMs).toBe(30_000);
    expect(effective.maxAttempts).toBe(2);
    expect(effective.maxOutputTokens).toBe(4_000);
    expect(effective.transcript).toEqual({
      messageTokens: 10_000,
      toolTokens: 10_000,
      maxUntrustedEntries: 40,
    });
  });

  it("keeps auto-review in the authorizer chain", () => {
    const seed = readSeed();

    expect(seed.authorizerChain).toEqual(["auto-review"]);
  });

  it("passes the unified schema", () => {
    const seed = readSeed();

    expect(unifiedConfigSchema.safeParse(seed).success).toBe(true);
  });
});

describe("backward compatibility with a deployed config", () => {
  it("still accepts the retired annotators key and ignores it", () => {
    // A config file saved by an older bundle revision may still carry the
    // retired `annotators` key. Rejecting it would fail that file closed
    // instead of ignoring the key.
    const result = unifiedConfigSchema.safeParse({
      annotators: ["model-explanation"],
    });

    expect(result.success).toBe(true);
  });

  it("still accepts a configured provider/model pair", () => {
    const parsed = autoReviewConfigFileSchema.safeParse({
      enabled: true,
      provider: "openai",
      model: "gpt-5-mini",
      reasoning: "off",
    });

    expect(parsed.success).toBe(true);
    const effective = normalizeAutoReviewConfig(
      parsed.success ? parsed.data : undefined,
    );
    expect(effective.provider).toBe("openai");
    expect(effective.model).toBe("gpt-5-mini");
    expect(effective.reasoning).toBe("off");
  });

  it("applies defaults when the block is absent", () => {
    const effective = normalizeAutoReviewConfig(undefined);

    expect(effective.enabled).toBe(true);
    expect(effective.reasoning).toBe("low");
    expect(effective.maxAttempts).toBe(2);
  });
});