import { describe, expect, test } from "bun:test";

import type { CheckerValidationInput } from "../../../../../src/server/checker/runner/types";
import type { RawTargetConfig } from "../../../../../src/server/checker/types";

import { normalizeAuthoringConfig } from "../../../../../src/server/checker/normalizer";
import { validateDbConfig } from "../../../../../src/server/checker/runner/db/validate";
import { validateHttpConfig } from "../../../../../src/server/checker/runner/http/validate";
import { validateLlmConfig } from "../../../../../src/server/checker/runner/llm/validate";

function input(target: Record<string, unknown>): CheckerValidationInput {
  return { targets: [target as CheckerValidationInput["targets"][number]] };
}

describe("HTTP/LLM headers reject case-insensitive duplicate keys", () => {
  test("HTTP headers 大小写不同的重复 key 报错", () => {
    const target = {
      expect: { headers: { "Content-Type": "application/json", "content-type": "text/plain" } },
      http: { url: "https://example.com" },
      id: "dup",
      type: "http",
    };

    const issues = validateHttpConfig(input(target));
    expect(issues.some((i) => i.code === "duplicate-key" && i.path.includes("headers"))).toBe(true);
  });

  test("LLM headers 大小写不同的重复 key 报错", () => {
    const target = {
      expect: { headers: { "X-Trace": "a", "x-trace": "b" } },
      id: "dup",
      llm: {
        mode: "stream",
        model: "test-model",
        prompt: "hello",
        provider: "openai",
        url: "https://example.com/v1/chat/completions",
      },
      type: "llm",
    };

    const issues = validateLlmConfig(input(target));
    expect(issues.some((i) => i.code === "duplicate-key" && i.path.includes("headers"))).toBe(true);
  });

  test("HTTP headers 不同 key 不触发 duplicate-key", () => {
    const target = {
      expect: { headers: { Accept: "application/json", "Content-Type": "application/json" } },
      http: { url: "https://example.com" },
      id: "ok",
      type: "http",
    };

    expect(validateHttpConfig(input(target)).some((i) => i.code === "duplicate-key")).toBe(false);
  });

  test("HTTP normalized headers 大小写不同的重复 key 报错", () => {
    const authoring = {
      expect: { headers: { "Content-Type": "application/json", "content-type": "text/plain" } },
      http: { url: "https://example.com" },
      id: "dup",
      type: "http",
    };

    const result = normalizeAuthoringConfig({ targets: [authoring] });
    const normalized = result.config as { targets: RawTargetConfig[] };
    const issues = validateHttpConfig({ targets: normalized.targets });
    expect(issues.some((i) => i.code === "duplicate-key" && i.path.includes("headers"))).toBe(true);
  });

  test("HTTP normalized headers unsafe regex 报错", () => {
    const authoring = {
      expect: { headers: { "x-test": { regex: "(\\d+)*x" } } },
      http: { url: "https://example.com" },
      id: "unsafe",
      type: "http",
    };

    const result = normalizeAuthoringConfig({ targets: [authoring] });
    const normalized = result.config as { targets: RawTargetConfig[] };
    const issues = validateHttpConfig({ targets: normalized.targets });
    expect(issues.some((i) => i.code === "unsafe-regex" && i.path.includes("headers"))).toBe(true);
  });

  test("DB normalized rows 通过校验", () => {
    const authoring = {
      db: { query: "SELECT 1", url: "sqlite://:memory:" },
      expect: { rows: [{ Name: "Alice" }] },
      id: "db-rows",
      type: "db",
    };

    const result = normalizeAuthoringConfig({ targets: [authoring] });
    const normalized = result.config as { targets: RawTargetConfig[] };
    const issues = validateDbConfig({ targets: normalized.targets });
    expect(issues).toHaveLength(0);
  });
});