import { describe, expect, it } from "vitest";
import {
  createDesignTokenRegistry,
  DESIGN_TOKEN_CATEGORIES,
  DESIGN_TOKEN_VALUE_MAX_LENGTH,
  DesignTokenError,
  type DesignTokenInput,
} from "../src/index.js";

function tokens(...overrides: readonly Partial<DesignTokenInput>[]): readonly DesignTokenInput[] {
  return overrides.map((override) => ({
    description: "A token used by this test.",
    label: "Test token",
    name: "background.page",
    value: "#ffffff",
    ...override,
  }));
}

describe("design token validation", () => {
  it("accepts a minimal well-formed declaration and derives category and CSS variable", () => {
    const registry = createDesignTokenRegistry(tokens({ name: "spacing.2xs", value: "0.125rem" }));
    const token = registry.get("spacing.2xs");

    expect(token).toEqual({
      category: "spacing",
      cssVariable: "--ekklesia-spacing-2xs",
      description: "A token used by this test.",
      label: "Test token",
      name: "spacing.2xs",
      value: "0.125rem",
    });
    expect(Object.isFrozen(token)).toBe(true);
  });

  it("rejects a duplicate token name", () => {
    expect(() => createDesignTokenRegistry(tokens({}, {}))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_DUPLICATE" }),
    );
  });

  it.each([
    ["a single segment", "page"],
    ["an empty name", ""],
    ["an uppercase segment", "background.Page"],
    ["an underscore", "background.page_alt"],
    ["a trailing dot", "background.page."],
    ["a space", "background.page alt"],
  ])("rejects %s as a token name", (_label, name) => {
    expect(() => createDesignTokenRegistry(tokens({ name }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_NAME_INVALID" }),
    );
  });

  it("rejects a name whose first segment is not a known category", () => {
    expect(() => createDesignTokenRegistry(tokens({ name: "brand.primary" }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_CATEGORY_UNKNOWN" }),
    );
  });

  it.each([
    ["a declaration terminator", "#fff; color: red"],
    ["a rule block", "#fff } body { display: none"],
    ["a comment", "#fff /* hidden */"],
    ["an at-rule", "@import 'evil.css'"],
    ["a url reference", "url(https://example.invalid/x.png)"],
    ["an override", "#fff !important"],
    ["a markup fragment", "</style><script>"],
    ["an escape sequence", "\\0041"],
    ["an empty value", "   "],
  ])("rejects %s as a token value", (_label, value) => {
    expect(() => createDesignTokenRegistry(tokens({ value }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_VALUE_INVALID" }),
    );
  });

  it("rejects an unbounded value", () => {
    expect(() =>
      createDesignTokenRegistry(tokens({ value: "a".repeat(DESIGN_TOKEN_VALUE_MAX_LENGTH + 1) })),
    ).toThrowError(expect.objectContaining({ code: "DESIGN_TOKEN_VALUE_INVALID" }));
  });

  it("rejects a control character hidden inside a value", () => {
    expect(() => createDesignTokenRegistry(tokens({ value: "#fff\u0007" }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_VALUE_INVALID" }),
    );
    expect(() => createDesignTokenRegistry(tokens({ value: "#fff\nred" }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_VALUE_INVALID" }),
    );
  });

  it("rejects an empty or overlong label and description", () => {
    expect(() => createDesignTokenRegistry(tokens({ label: "  " }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_LABEL_INVALID" }),
    );
    expect(() => createDesignTokenRegistry(tokens({ description: "" }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_DESCRIPTION_INVALID" }),
    );
    expect(() => createDesignTokenRegistry(tokens({ description: "d".repeat(241) }))).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_DESCRIPTION_INVALID" }),
    );
  });

  it("never echoes the rejected declaration in the error", () => {
    let caught: unknown;
    try {
      createDesignTokenRegistry(tokens({ value: "#fff; content: 'leak-me'" }));
    } catch (error) {
      caught = error;
    }

    expect(caught).toBeInstanceOf(DesignTokenError);
    expect(String((caught as Error).message)).not.toContain("leak-me");
    expect(String((caught as Error).stack)).not.toContain("leak-me");
  });

  it("fails a lookup closed for an unregistered or non-string name", () => {
    const registry = createDesignTokenRegistry(tokens({}));

    expect(registry.get("nope.nope")).toBeUndefined();
    expect(registry.get(42)).toBeUndefined();
    expect(registry.has(undefined)).toBe(false);
    expect(() => registry.variable("nope.nope")).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_UNKNOWN" }),
    );
  });

  it("rejects a stylesheet scope outside the closed set", () => {
    const registry = createDesignTokenRegistry(tokens({}));

    expect(() => registry.stylesheet("body" as "root")).toThrowError(
      expect.objectContaining({ code: "DESIGN_TOKEN_SCOPE_INVALID" }),
    );
  });

  it("emits one rule per scope containing every declared token", () => {
    const registry = createDesignTokenRegistry(
      tokens({ name: "background.page", value: "#fff" }, { name: "text.primary", value: "#000" }),
    );

    expect(registry.stylesheet()).toBe(
      ":root {\n  --ekklesia-background-page: #fff;\n  --ekklesia-text-primary: #000;\n}\n",
    );
    expect(registry.stylesheet("host").startsWith(":host {")).toBe(true);
  });

  it("groups tokens by category without a second source of truth", () => {
    const registry = createDesignTokenRegistry(
      tokens({ name: "background.page" }, { name: "text.primary", value: "#000" }),
    );

    expect(registry.listByCategory("background").map((token) => token.name)).toEqual([
      "background.page",
    ]);
    expect(registry.listByCategory("shadow")).toEqual([]);
    expect(DESIGN_TOKEN_CATEGORIES).toContain("background");
  });
});