import { readFileSync } from "node:fs";
import { resolve } from "node:path";
import { cwd } from "node:process";

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

import {
  getToolcraftComponentContract,
  isToolcraftBuiltInControlType,
  TOOLCRAFT_BUILT_IN_CONTROL_TYPES,
} from "./component-contracts";

describe("Toolcraft template component contracts: core", () => {
  it("derives one canonical built-in control registry from component contracts", () => {
    expect(TOOLCRAFT_BUILT_IN_CONTROL_TYPES).toEqual([
      "aspectRatio",
      "slider",
      "rangeSlider",
      "text",
      "rangeInput",
      "code",
      "select",
      "segmented",
      "tabs",
      "switch",
      "checkbox",
      "actions",
      "collectionActions",
      "sourceCollection",
      "panelActions",
      "colorOpacity",
      "palette",
      "vector",
      "orientationGizmo",
      "color",
      "gradient",
      "fontPicker",
      "curves",
      "anchorGrid",
      "channelMixer",
      "fileDrop",
      "imagePicker",
      "settingsTransfer",
    ]);
    expect(new Set(TOOLCRAFT_BUILT_IN_CONTROL_TYPES).size).toBe(
      TOOLCRAFT_BUILT_IN_CONTROL_TYPES.length,
    );
    expect(isToolcraftBuiltInControlType("gradient")).toBe(true);
    expect(isToolcraftBuiltInControlType("customControl")).toBe(false);
    expect(isToolcraftBuiltInControlType("productMaskEditor")).toBe(false);
  });

  it("exposes decision catalog metadata for controls that agents choose between", () => {
    for (const id of [
      "slider",
      "rangeSlider",
      "select",
      "segmented",
      "tabs",
      "switch",
      "checkbox",
      "text",
      "code",
      "color",
      "colorOpacity",
      "gradient",
      "fontPicker",
      "curves",
      "vector",
      "orientationGizmo",
      "fileDrop",
      "imagePicker",
      "palette",
      "actions",
      "collectionActions",
      "sourceCollection",
      "panelActions",
      "customControl",
    ] as const) {
      const catalog = getToolcraftComponentContract(id).decisionCatalog;

      expect(catalog?.strictness).toMatch(
        /^(exact-owner|best-fit|custom-escape-hatch)$/,
      );
      expect(catalog?.ownsValueModel.length).toBeGreaterThan(0);
      expect(catalog?.useWhen.length).toBeGreaterThan(0);
      expect(catalog?.requiredAcceptance.length).toBeGreaterThan(0);
    }
  });

  it("documents high-confidence owner controls and their bad substitutes", () => {
    const gradient = getToolcraftComponentContract("gradient").decisionCatalog;
    const fontPicker =
      getToolcraftComponentContract("fontPicker").decisionCatalog;
    const colorOpacity =
      getToolcraftComponentContract("colorOpacity").decisionCatalog;
    const customControl =
      getToolcraftComponentContract("customControl").decisionCatalog;

    expect(gradient?.strictness).toBe("exact-owner");
    expect(gradient?.useWhen.join(" ")).toMatch(
      /adjustable gradient|gradient stops/i,
    );
    expect(gradient?.doNotReplaceWith?.join(" ")).toMatch(
      /two Color controls/i,
    );
    expect(gradient?.requiredAcceptance.join(" ")).toMatch(
      /gradientType.*angle.*stop position.*stop color.*stop opacity/i,
    );

    expect(fontPicker?.doNotReplaceWith?.join(" ")).toMatch(
      /plain Select.*separate typography controls/i,
    );
    expect(colorOpacity?.doNotReplaceWith?.join(" ")).toMatch(
      /separate Color.*opacity/i,
    );
    expect(customControl?.strictness).toBe("custom-escape-hatch");
    expect(customControl?.requiredAcceptance.join(" ")).toMatch(
      /rejected built-ins/i,
    );
  });

  it("keeps UI data variants in the exported stylesheet for standalone apps", () => {
    const uiStyles = readFileSync(
      resolve(cwd(), "../ui/src/styles.css"),
      "utf8",
    );

    for (const [variant, selector] of [
      ["data-horizontal", "[data-orientation='horizontal']"],
      ["data-vertical", "[data-orientation='vertical']"],
      ["data-active", "[data-state='active']"],
      ["data-checked", "[data-state='checked']"],
    ] as const) {
      expect(uiStyles).toContain(`@custom-variant ${variant}`);
      expect(uiStyles).toContain(selector);
    }
  });

  it("marks grouped controls as label-required grouped controls", () => {
    for (const id of [
      "slider",
      "rangeSlider",
      "select",
      "segmented",
      "switch",
      "checkbox",
      "text",
      "rangeInput",
      "actions",
    ] as const) {
      const contract = getToolcraftComponentContract(id);

      expect(contract.kind).toBe("control");
      expect(contract.defaultSectionLayout).toBe("grouped");
      expect(contract.labelPolicy).toBe("required");
    }
  });

  it("preserves literal contract types from the getter", () => {
    const contract = getToolcraftComponentContract("slider");

    expectTypeOf(contract.id).toEqualTypeOf<"slider">();
    expectTypeOf(contract.kind).toEqualTypeOf<"control">();
    expectTypeOf(contract.defaultSectionLayout).toEqualTypeOf<"grouped">();
    expectTypeOf(contract.labelPolicy).toEqualTypeOf<"required">();
  });
});