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

import {
  compileGlobalGovernanceFacts,
  componentId as makeComponentId,
  FactIndex,
  makeGovernanceRuleConfigFact,
  makeUsageComponentFact,
  makeUsageNodeFact,
  makeUsagePropResolvedFact,
} from "../facts/index.js";
import type { GovernanceConfig } from "../governance.js";

import { ruleCompositionCardinality, ruleCompositionCoOccurrence } from "./composition-pattern.js";
import {
  type CompositionAuthoringEntry,
  type CompositionPattern,
  lowerCompositionContract,
} from "./composition-pattern-schema.js";

const BUTTON_GROUP = makeComponentId("@fragments-sdk/ui", "ButtonGroup");
const BUTTON = makeComponentId("@fragments-sdk/ui", "Button");
const FILE = "src/App.tsx";

// The shared example policies from ACCEPTANCE.md.
const POLICY_CARDINALITY: CompositionPattern = {
  region: { component: "ButtonGroup" },
  select: { component: "Button", prop: "variant", value: "primary" },
  constraint: { kind: "cardinality", max: 1 },
};
const POLICY_COOCCURRENCE: CompositionPattern = {
  region: { component: "ButtonGroup" },
  select: { component: "Button", prop: "variant", value: "primary" },
  constraint: { kind: "co-occurrence", requires: { prop: "variant", value: "secondary" } },
};

interface NodeSpec {
  path: string;
  element: string;
  /** Canonical component the node resolves to (omit for an untracked element). */
  component?: ReturnType<typeof makeComponentId>;
  /** A `variant` prop and how it resolves (omit for none). */
  variant?: { value?: string; resolution?: "static" | "dynamic" };
}

function add(ix: FactIndex, spec: NodeSpec): void {
  const node = makeUsageNodeFact({
    file: FILE,
    nodePath: spec.path,
    element: spec.element,
    location: { file: FILE, line: 1, column: 1 },
  });
  ix.add(node);
  if (spec.component) {
    ix.add(makeUsageComponentFact({ nodeId: node.id, componentId: spec.component }));
  }
  if (spec.variant) {
    ix.add(
      makeUsagePropResolvedFact({
        nodeId: node.id,
        prop: "variant",
        resolution: spec.variant.resolution ?? "static",
        value: spec.variant.value,
      })
    );
  }
}

function withPolicy(ix: FactIndex, ruleId: string, patterns: CompositionPattern[]): FactIndex {
  ix.add(makeGovernanceRuleConfigFact({ ruleId, enabled: true, options: { patterns } }));
  return ix;
}

const buttonGroup = (path: string): NodeSpec => ({
  path,
  element: "ButtonGroup",
  component: BUTTON_GROUP,
});
const button = (path: string, variant?: NodeSpec["variant"]): NodeSpec => ({
  path,
  element: "Button",
  component: BUTTON,
  variant,
});

describe("composition/cardinality", () => {
  // ACCEPTANCE §3
  it("flags a second primary Button in one ButtonGroup", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    add(ix, button("0:0/1", { value: "primary" }));
    withPolicy(ix, "composition/cardinality", [POLICY_CARDINALITY]);

    const findings = ruleCompositionCardinality(ix);
    expect(findings).toHaveLength(1);
    expect(findings[0]).toMatchObject({
      ruleId: "composition/cardinality",
      level: "warn",
      code: "FUI5003",
      message: "At most one primary Button is allowed per ButtonGroup (found 2).",
    });
  });

  // ACCEPTANCE §4
  it("does not flag a primary + secondary Button", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    add(ix, button("0:0/1", { value: "secondary" }));
    withPolicy(ix, "composition/cardinality", [POLICY_CARDINALITY]);

    expect(ruleCompositionCardinality(ix)).toHaveLength(0);
  });

  // ACCEPTANCE §5 — per region, not per file.
  it("counts cardinality per region, not across the file", () => {
    const ix = new FactIndex();
    // <> <ButtonGroup><Button primary/></ButtonGroup> <ButtonGroup><Button primary/></ButtonGroup> </>
    add(ix, { path: "0:0", element: "Fragment" }); // untracked container
    add(ix, buttonGroup("0:0/0"));
    add(ix, button("0:0/0/0", { value: "primary" }));
    add(ix, buttonGroup("0:0/1"));
    add(ix, button("0:0/1/0", { value: "primary" }));
    withPolicy(ix, "composition/cardinality", [POLICY_CARDINALITY]);

    expect(ruleCompositionCardinality(ix)).toHaveLength(0);
  });

  // ACCEPTANCE §6 — static-resolution ceiling.
  it("does not flag dynamic variants (unknown, not primary)", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { resolution: "dynamic" }));
    add(ix, button("0:0/1", { resolution: "dynamic" }));
    withPolicy(ix, "composition/cardinality", [POLICY_CARDINALITY]);

    expect(ruleCompositionCardinality(ix)).toHaveLength(0);
  });

  // Foundation guard (not an ACCEPTANCE case): `min` is symmetric to `max`.
  it("flags fewer than the required minimum", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    withPolicy(ix, "composition/cardinality", [
      {
        region: { component: "ButtonGroup" },
        select: { component: "Button", prop: "variant", value: "primary" },
        constraint: { kind: "cardinality", min: 2 },
      },
    ]);

    const findings = ruleCompositionCardinality(ix);
    expect(findings).toHaveLength(1);
    expect(findings[0].message).toBe(
      "At least 2 primary Buttons are required per ButtonGroup (found 1)."
    );
  });

  it("emits nothing when no policy is configured", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    add(ix, button("0:0/1", { value: "primary" }));

    expect(ruleCompositionCardinality(ix)).toHaveLength(0);
  });

  // Hardening: a malformed pattern is skipped; valid ones in the same array still fire.
  it("skips malformed patterns without breaking the scan", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    add(ix, button("0:0/1", { value: "primary" }));
    ix.add(
      makeGovernanceRuleConfigFact({
        ruleId: "composition/cardinality",
        enabled: true,
        options: { patterns: [{ nonsense: true }, POLICY_CARDINALITY] },
      })
    );

    const findings = ruleCompositionCardinality(ix);
    expect(findings).toHaveLength(1);
    expect(findings[0].message).toBe(
      "At most one primary Button is allowed per ButtonGroup (found 2)."
    );
  });
});

describe("composition/co-occurrence", () => {
  // ACCEPTANCE §7
  it("flags a primary Button without the required secondary", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    withPolicy(ix, "composition/co-occurrence", [POLICY_COOCCURRENCE]);

    const findings = ruleCompositionCoOccurrence(ix);
    expect(findings).toHaveLength(1);
    expect(findings[0]).toMatchObject({
      ruleId: "composition/co-occurrence",
      level: "warn",
      code: "FUI5004",
      message: "A ButtonGroup with a primary Button should also contain a secondary Button.",
    });
  });

  // ACCEPTANCE §8
  it("does not flag when the required secondary is present", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    add(ix, button("0:0/1", { value: "secondary" }));
    withPolicy(ix, "composition/co-occurrence", [POLICY_COOCCURRENCE]);

    expect(ruleCompositionCoOccurrence(ix)).toHaveLength(0);
  });
});

// ACCEPTANCE §9 — a cloud-managed config round-trips into the rule input.
describe("composition policy round-trip (§9)", () => {
  it("compiles a delivered governance config into the §3 finding", () => {
    const ix = new FactIndex();
    add(ix, buttonGroup("0:0"));
    add(ix, button("0:0/0", { value: "primary" }));
    add(ix, button("0:0/1", { value: "primary" }));

    // The exact shape Cloud delivers via GET /api/govern/policy (governConfig):
    // a `composition/cardinality` rule config carrying `options.patterns`. This
    // exercises the GovernanceConfig → governance_rule_config fact path the CLI
    // runs, not a hand-built fact — proving the cloud→CLI contract end to end.
    const govern: GovernanceConfig = {
      rules: {
        "composition/cardinality": {
          enabled: true,
          severity: "warn",
          options: { patterns: [POLICY_CARDINALITY] },
        },
      },
    };
    for (const fact of compileGlobalGovernanceFacts(govern)) ix.add(fact);

    const findings = ruleCompositionCardinality(ix);
    expect(findings).toHaveLength(1);
    expect(findings[0]).toMatchObject({
      ruleId: "composition/cardinality",
      level: "warn",
      code: "FUI5003",
      message: "At most one primary Button is allowed per ButtonGroup (found 2).",
    });
  });
});

// ACCEPTANCE §10 — fragment authoring sugar lowers to the same pattern the rule
// reads, so authoring and cloud policy converge on one config.
describe("lowerCompositionContract (§10)", () => {
  it("lowers a cardinality block to POLICY_CARDINALITY", () => {
    const block: CompositionAuthoringEntry[] = [
      {
        inRegion: "ButtonGroup",
        rule: { atMost: 1, of: { component: "Button", prop: "variant", value: "primary" } },
      },
    ];
    expect(lowerCompositionContract(block)).toEqual([POLICY_CARDINALITY]);
  });

  it("lowers a co-occurrence block to POLICY_COOCCURRENCE", () => {
    const block: CompositionAuthoringEntry[] = [
      {
        inRegion: "ButtonGroup",
        rule: {
          when: { component: "Button", prop: "variant", value: "primary" },
          require: { prop: "variant", value: "secondary" },
        },
      },
    ];
    expect(lowerCompositionContract(block)).toEqual([POLICY_COOCCURRENCE]);
  });

  it("returns no patterns for an absent block", () => {
    expect(lowerCompositionContract(undefined)).toEqual([]);
  });
});