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

import {
  areToolcraftPredicateSetsProvablyExclusive,
  areToolcraftPredicatesProvablyExclusive,
  doesToolcraftApplicabilityMatch,
  doesToolcraftPredicateMatchValue,
  getToolcraftApplicabilityTargets,
  resolveToolcraftControlApplicability,
} from "./control-applicability";

describe("Toolcraft control applicability", () => {
  it("normalizes explicit, legacy, and implicit inputs into one model", () => {
    expect(
      resolveToolcraftControlApplicability({
        applicability: { mode: "always" },
      }),
    ).toEqual({ mode: "always", origin: "explicit" });

    expect(
      resolveToolcraftControlApplicability({
        applicability: {
          all: [
            { equals: "create", target: "source.mode" },
            { oneOf: ["polygon", "star"], target: "shape.kind" },
          ],
          mode: "conditional",
        },
      }),
    ).toEqual({
      all: [
        { equals: "create", target: "source.mode" },
        { oneOf: ["polygon", "star"], target: "shape.kind" },
      ],
      mode: "conditional",
      origin: "explicit",
    });

    expect(
      resolveToolcraftControlApplicability({
        visibleWhen: { equals: "create", target: "source.mode" },
      }),
    ).toEqual({
      all: [{ equals: "create", target: "source.mode" }],
      mode: "conditional",
      origin: "legacy",
    });

    expect(resolveToolcraftControlApplicability({})).toEqual({
      mode: "always",
      origin: "implicit",
    });

    expect(
      resolveToolcraftControlApplicability({
        applicability: { mode: "always", origin: "implicit" },
      }),
    ).toEqual({ mode: "always", origin: "implicit" });
  });

  it("rejects ambiguous and structurally invalid input", () => {
    expect(() =>
      resolveToolcraftControlApplicability({
        applicability: { mode: "always" },
        visibleWhen: { equals: true, target: "feature.enabled" },
      }),
    ).toThrow("cannot declare both applicability and visibleWhen");

    expect(() =>
      resolveToolcraftControlApplicability({
        applicability: { all: [], mode: "conditional" },
      }),
    ).toThrow("conditional applicability requires at least one predicate");

    expect(() =>
      resolveToolcraftControlApplicability({
        applicability: { mode: "always", origin: "legacy" },
      }),
    ).toThrow("invalid resolved applicability origin");
  });

  it("evaluates predicates once and combines targets with AND", () => {
    const applicability = {
      all: [
        { equals: "create", target: "source.mode" },
        { oneOf: ["polygon", "star"], target: "shape.kind" },
      ],
      mode: "conditional",
      origin: "explicit",
    } as const;
    const values = new Map<string, unknown>([
      ["source.mode", "create"],
      ["shape.kind", "star"],
    ]);

    expect(getToolcraftApplicabilityTargets(applicability)).toEqual([
      "source.mode",
      "shape.kind",
    ]);
    expect(
      doesToolcraftApplicabilityMatch(applicability, (target) =>
        values.get(target),
      ),
    ).toBe(true);
    expect(
      doesToolcraftPredicateMatchValue(
        { equals: "heart", target: "shape.kind" },
        "star",
      ),
    ).toBe(false);
  });

  it("proves finite and numeric predicate exclusivity", () => {
    expect(
      areToolcraftPredicatesProvablyExclusive(
        { equals: "circle", target: "shape.kind" },
        { oneOf: ["polygon", "star"], target: "shape.kind" },
      ),
    ).toBe(true);
    expect(
      areToolcraftPredicateSetsProvablyExclusive(
        [{ greaterThan: 5, target: "shape.count" }],
        [{ lessThanOrEqual: 5, target: "shape.count" }],
      ),
    ).toBe(true);
  });
});