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

import { getToolcraftPerformanceFixtureAdapterErrors } from "./performance-fixture-adapters";
import {
  compileToolcraftPerformanceFixturePlan,
  defineToolcraftDiscreteFixtureAdapter,
  executeToolcraftPerformanceFixtureCheckpoint,
  validateToolcraftPerformanceCoverage,
  type ToolcraftEnvelopePerformanceConfig,
} from "./performance";
import {
  createCanonicalAdapter,
  createCanonicalConfig,
  createCanonicalDimension,
  createCanonicalPass,
  getCanonicalPath,
} from "./performance-fixture-plan.test-fixtures";
import { groupedSchema } from "./performance-paths.test-fixtures";

describe("Toolcraft pure fixture registry validation", () => {
  it.each([null, [], "registry", 42])(
    "returns a stable error for malformed registry %j",
    (fixtureAdapters) => {
      const config = createCanonicalConfig({
        adapters: { count: createCanonicalAdapter("count") },
        dimensions: [createCanonicalDimension("count")],
        passes: [createCanonicalPass("composite", ["count"], "linear")],
      });
      const malformed = {
        ...config,
        fixtureAdapters,
      } as unknown as ToolcraftEnvelopePerformanceConfig;

      expect(() =>
        getToolcraftPerformanceFixtureAdapterErrors(malformed, [
          getCanonicalPath(config),
        ]),
      ).not.toThrow();
      expect(
        getToolcraftPerformanceFixtureAdapterErrors(malformed, [
          getCanonicalPath(config),
        ]),
      ).toEqual(["fixtureAdapters must be a non-null object."]);
    },
  );

  it("sorts orphan adapter errors deterministically without executing callbacks", () => {
    let callbackCount = 0;
    const config = createCanonicalConfig({
      adapters: {
        zeta: createCanonicalAdapter("zeta", {
          apply: (value) => {
            callbackCount += 1;
            return value;
          },
        }),
        count: createCanonicalAdapter("count"),
        alpha: createCanonicalAdapter("alpha"),
      },
      dimensions: [createCanonicalDimension("count")],
      passes: [createCanonicalPass("composite", ["count"], "linear")],
    });

    expect(
      getToolcraftPerformanceFixtureAdapterErrors(config, [getCanonicalPath(config)]),
    ).toEqual([
      'fixtureAdapters.dimensions["alpha"] does not match a workload dimension.',
      'fixtureAdapters.dimensions["zeta"] does not match a workload dimension.',
    ]);
    expect(callbackCount).toBe(0);
  });

  it("returns stable errors for malformed adapter and pass metadata", () => {
    const config = createCanonicalConfig({
      adapters: { count: createCanonicalAdapter("count") },
      dimensions: [createCanonicalDimension("count")],
      passes: [createCanonicalPass("composite", ["count"], "linear")],
    });
    const malformed = {
      ...config,
      fixtureAdapters: {
        dimensions: { count: null },
        inverseCheckpoints: null,
      },
      rendererPipeline: {
        ...config.rendererPipeline!,
        passes: [null],
      },
    } as unknown as ToolcraftEnvelopePerformanceConfig;

    expect(() =>
      getToolcraftPerformanceFixtureAdapterErrors(malformed, []),
    ).not.toThrow();
    expect(getToolcraftPerformanceFixtureAdapterErrors(malformed, [])).toEqual([
      'fixtureAdapters.dimensions["count"] must be a non-null object.',
      "fixtureAdapters.inverseCheckpoints must be an array.",
    ]);
  });

  it("surfaces adapter identity errors through direct coverage without callbacks", () => {
    let callbackCount = 0;
    const config = createCanonicalConfig({
      adapters: {
        count: createCanonicalAdapter("wrong-id", {
          apply: (value) => {
            callbackCount += 1;
            return value;
          },
        }),
      },
      dimensions: [createCanonicalDimension("count")],
      passes: [createCanonicalPass("composite", ["count"], "linear")],
    });

    expect(validateToolcraftPerformanceCoverage(groupedSchema, config)).toContain(
      'fixtureAdapters.dimensions["count"].dimensionId must equal its registry key "count".',
    );
    expect(callbackCount).toBe(0);
  });

  it.each([
    {
      adapterPatch: { entries: "not-an-array" },
      expected: 'fixtureAdapters.dimensions["count"].entries must be a non-empty exhaustive mapping.',
    },
    {
      adapterPatch: { domain: null },
      expected: 'fixtureAdapters.dimensions["count"].domain must declare exhaustive provenance.',
    },
    {
      adapterPatch: { kind: "unknown-adapter-kind" },
      expected: 'fixtureAdapters.dimensions["count"].kind must be "continuous" or "exhaustive-discrete".',
    },
    {
      adapterPatch: {
        domain: { kind: "runtime-state" },
      },
      expected: 'fixtureAdapters.dimensions["count"].domain.attestation must explain why the finite domain is exhaustive.',
    },
  ])(
    "keeps malformed adapters out of the parsed registry: $expected",
    ({ adapterPatch, expected }) => {
      const validAdapter = defineToolcraftDiscreteFixtureAdapter({
        dimensionId: "count",
        domain: {
          attestation: "All runtime fixture modes are enumerated.",
          kind: "runtime-state",
          path: "fixture.count",
        },
        entries: [20, 84, 100, 200].map((value) => ({
          appliedValue: `option-${value}`,
          value,
        })),
      });
      const config = createCanonicalConfig({
        adapters: { count: validAdapter },
        dimensions: [createCanonicalDimension("count")],
        passes: [createCanonicalPass("composite", ["count"], "linear")],
      });
      const malformed = {
        ...config,
        fixtureAdapters: {
          dimensions: {
            count: { ...validAdapter, ...adapterPatch },
          },
        },
      } as unknown as ToolcraftEnvelopePerformanceConfig;
      const path = getCanonicalPath(config);

      expect(() =>
        validateToolcraftPerformanceCoverage(groupedSchema, malformed),
      ).not.toThrow();
      expect(validateToolcraftPerformanceCoverage(groupedSchema, malformed)).toContain(
        expected,
      );
      expect(() =>
        compileToolcraftPerformanceFixturePlan(malformed, path),
      ).toThrow(expected);
    },
  );

  it("rejects disconnected reachableValues metadata", () => {
    const config = createCanonicalConfig({
      adapters: { count: createCanonicalAdapter("count") },
      dimensions: [createCanonicalDimension("count")],
      passes: [createCanonicalPass("composite", ["count"], "linear")],
    });
    const malformed = {
      ...config,
      fixtureAdapters: {
        ...config.fixtureAdapters,
        dimensions: {
          count: {
            ...config.fixtureAdapters!.dimensions.count,
            reachableValues: [20, 100, 200],
          },
        },
      },
    } as unknown as ToolcraftEnvelopePerformanceConfig;

    expect(
      getToolcraftPerformanceFixtureAdapterErrors(malformed, [
        getCanonicalPath(config),
      ]),
    ).toContain(
      'fixtureAdapters.dimensions["count"].reachableValues is disconnected metadata; use an exhaustive-discrete adapter with canonical entries and domain provenance.',
    );
  });

  it.each([
    {
      expected: "must be a non-empty exhaustive mapping",
      values: [],
    },
    {
      expected: "must not contain duplicate numeric values",
      values: [20, 20, 100, 200],
    },
    {
      expected: "must include dimension defaultValue 20",
      values: [10, 100, 200],
    },
    {
      expected: "must include dimension interactiveMax 100",
      values: [20, 80, 200],
    },
    {
      expected: "must include dimension batchMax 200",
      values: [20, 80, 100],
    },
  ])("rejects invalid exhaustive entries: $expected", ({ expected, values }) => {
    const config = createCanonicalConfig({
      adapters: {
        count: defineToolcraftDiscreteFixtureAdapter({
          dimensionId: "count",
          domain: {
            attestation: "All fixture options are enumerated.",
            kind: "runtime-state",
            path: "fixture.count",
          },
          entries: values.map((value, index) => ({
            appliedValue: `option-${index}`,
            value,
          })),
        }),
      },
      dimensions: [createCanonicalDimension("count")],
      passes: [createCanonicalPass("composite", ["count"], "linear")],
    });

    expect(
      getToolcraftPerformanceFixtureAdapterErrors(config, [getCanonicalPath(config)]),
    ).toContain(`fixtureAdapters.dimensions["count"].entries ${expected}.`);
  });

  it("sorts orphan inverse evidence by path and pass", () => {
    const baseConfig = createCanonicalConfig({
      adapters: { count: createCanonicalAdapter("count") },
      dimensions: [createCanonicalDimension("count")],
      passes: [createCanonicalPass("composite", ["count"], "linear")],
    });
    const config = {
      ...baseConfig,
      fixtureAdapters: {
        ...baseConfig.fixtureAdapters!,
        inverseCheckpoints: [
          {
            measuredResult: "orphan zeta",
            normalizedPressure: 0.8,
            passId: "zeta",
            pathId: "unknown-zeta",
            values: { count: 80 },
          },
          {
            measuredResult: "orphan alpha",
            normalizedPressure: 0.8,
            passId: "alpha",
            pathId: "unknown-alpha",
            values: { count: 80 },
          },
        ],
      },
    };

    expect(
      getToolcraftPerformanceFixtureAdapterErrors(config, [getCanonicalPath(config)]),
    ).toEqual([
      'fixtureAdapters.inverseCheckpoints for path "unknown-alpha" pass "alpha" does not match a canonical evidence-required pass.',
      'fixtureAdapters.inverseCheckpoints for path "unknown-zeta" pass "zeta" does not match a canonical evidence-required pass.',
    ]);
  });

  it.each(["constructor", "toString"])(
    "treats inherited prototype key %s as a missing adapter",
    (dimensionId) => {
      const config = createCanonicalConfig({
        adapters: {},
        dimensions: [createCanonicalDimension(dimensionId)],
        passes: [createCanonicalPass("composite", [dimensionId], "linear")],
      });
      const path = getCanonicalPath(config);
      const expected =
        `fixtureAdapters.dimensions[${JSON.stringify(dimensionId)}] must apply and observe workload dimension "${dimensionId}".`;

      expect(getToolcraftPerformanceFixtureAdapterErrors(config, [path])).toContain(
        expected,
      );
      expect(() =>
        compileToolcraftPerformanceFixturePlan(config, path),
      ).toThrow(expected);
    },
  );

  it.each(["constructor", "toString"])(
    "accepts and executes an explicit own adapter for prototype key %s",
    (dimensionId) => {
      const config = createCanonicalConfig({
        adapters: { [dimensionId]: createCanonicalAdapter(dimensionId) },
        dimensions: [createCanonicalDimension(dimensionId)],
        passes: [createCanonicalPass("composite", [dimensionId], "linear")],
      });
      const path = getCanonicalPath(config);

      expect(getToolcraftPerformanceFixtureAdapterErrors(config, [path])).toEqual([]);
      const result = executeToolcraftPerformanceFixtureCheckpoint(
        config,
        compileToolcraftPerformanceFixturePlan(config, path),
        "maximum",
      );

      expect(Object.hasOwn(result.observed, dimensionId)).toBe(true);
      expect(result.observed[dimensionId]).toBe(100);
      expect(Object.getPrototypeOf(result.observed)).toBe(null);
    },
  );

  it.each([
    {
      expected:
        "workloadEnvelope.dimensions[0] must be a non-null object.",
      rawDimension: null,
    },
    {
      expected:
        "workloadEnvelope.dimensions[0] must be a non-null object.",
      rawDimension: 42,
    },
    {
      expected:
        "workloadEnvelope.dimensions[0].id must be trimmed and non-empty.",
      rawDimension: {},
    },
  ])(
    "returns stable public errors for malformed dimension $rawDimension",
    ({ expected, rawDimension }) => {
      const validConfig = createCanonicalConfig({
        adapters: { count: createCanonicalAdapter("count") },
        dimensions: [createCanonicalDimension("count")],
        passes: [createCanonicalPass("composite", ["count"], "linear")],
      });
      const malformedConfig = {
        ...validConfig,
        workloadEnvelope: { dimensions: [rawDimension] },
      } as unknown as ToolcraftEnvelopePerformanceConfig;
      const path = getCanonicalPath(validConfig);

      expect(() =>
        validateToolcraftPerformanceCoverage(groupedSchema, malformedConfig),
      ).not.toThrow();
      expect(
        validateToolcraftPerformanceCoverage(groupedSchema, malformedConfig),
      ).toContain(expected);
      expect(() =>
        compileToolcraftPerformanceFixturePlan(malformedConfig, path),
      ).toThrow(expected);
    },
  );
});