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

import {
  createDimension,
  createSchema,
  errorsFor,
} from "./performance-workload-envelope-test-fixtures";

describe("Toolcraft derived workload validation", () => {
  it("rejects empty, unknown, and self-referencing derived inputs", () => {
    expect(
      errorsFor(
        [
          createDimension({
            id: "empty",
            source: { kind: "derived", inputs: [] },
          }),
          createDimension({
            id: "unknown",
            source: { kind: "derived", inputs: ["missing"] },
          }),
          createDimension({
            id: "self",
            source: { kind: "derived", inputs: ["self"] },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      'Workload dimension "empty" derived inputs must not be empty.',
      'Workload dimension "unknown" references unknown derived input "missing".',
      'Workload dimension "self" cannot reference itself as a derived input.',
    ]);
  });

  it("rejects derived dependency cycles", () => {
    expect(
      errorsFor(
        [
          createDimension({
            id: "first",
            source: { kind: "derived", inputs: ["second"] },
          }),
          createDimension({
            id: "second",
            source: { kind: "derived", inputs: ["first"] },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      "Derived workload dependency cycle detected: first -> second -> first.",
    ]);
  });

  it("detects a unique dependency cycle when other dimension ids are duplicated", () => {
    expect(
      errorsFor(
        [
          createDimension({
            id: "duplicate",
            source: { kind: "external-input", id: "first-duplicate" },
          }),
          createDimension({
            id: "duplicate",
            source: { kind: "external-input", id: "second-duplicate" },
          }),
          createDimension({
            id: "first",
            source: { kind: "derived", inputs: ["second"] },
          }),
          createDimension({
            id: "second",
            source: { kind: "derived", inputs: ["first"] },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      'Workload dimension id "duplicate" must be unique.',
      "Derived workload dependency cycle detected: first -> second -> first.",
    ]);
  });

  it("validates a long acyclic dependency chain without overflowing the stack", () => {
    const dimensionCount = 20_000;
    const dimensions = Array.from({ length: dimensionCount }, (_, index) =>
      createDimension({
        id: `node-${index}`,
        source:
          index === dimensionCount - 1
            ? { kind: "external-input", id: "chain-end" }
            : { kind: "derived", inputs: [`node-${index + 1}`] },
      }),
    );

    expect(errorsFor(dimensions, createSchema({}))).toEqual([]);
  });

  it("uses only declared maxima for runtime, external, and derived dimensions", () => {
    expect(
      errorsFor(
        [
          createDimension({
            defaultValue: 0,
            id: "runtime",
            interactiveMax: 20,
            source: { kind: "runtime-state", path: "state.runtime" },
          }),
          createDimension({
            batchMax: 30,
            defaultValue: 0,
            id: "external",
            interactiveMax: undefined,
            source: { kind: "external-input", id: "external" },
          }),
          createDimension({
            batchMax: 600,
            defaultValue: 0,
            id: "combined",
            interactiveMax: undefined,
            mapping: "area",
            source: { kind: "derived", inputs: ["runtime", "external"] },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([]);
  });

  it("excludes runtime-owned workload controls and targets", () => {
    const schema = createSchema({}, true);

    expect(errorsFor([], schema)).toEqual([]);
    expect(
      errorsFor(
        [
          createDimension({
            defaultValue: 1,
            id: "render-scale",
            interactiveMax: 4,
            source: { kind: "schema-target", target: "canvas.renderScale" },
          }),
        ],
        schema,
      ),
    ).toEqual([
      'Workload dimension "render-scale" schema target "canvas.renderScale" is runtime-owned.',
    ]);
  });

});