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

import {
  getToolcraftWorkloadEnvelopeErrors,
  isToolcraftEnvelopePerformanceConfig,
  type ToolcraftEnvelopePerformanceConfig,
  type ToolcraftWorkloadDimension,
  validateToolcraftPerformanceCoverage,
} from "./performance";
import { testSchema } from "./performance-test-fixtures";
import {
  createDimension,
  createEnvelopeConfig,
  createMalformedEnvelopeConfig,
  createSchema,
  errorsFor,
} from "./performance-workload-envelope-test-fixtures";

describe("Toolcraft workload envelope validation", () => {
  it("detects envelope configs by a safe own-property check", () => {
    const inheritedEnvelope = Object.assign(
      Object.create({ workloadEnvelope: { dimensions: [] } }),
      {
        rendererStrategy: "none",
        scenarios: [],
        usesCustomRenderer: false,
      },
    ) as ToolcraftEnvelopePerformanceConfig;
    const validEnvelope = createEnvelopeConfig([]);
    const malformedEnvelopes = [
      createMalformedEnvelopeConfig(undefined),
      createMalformedEnvelopeConfig(null),
      createMalformedEnvelopeConfig(0),
      createMalformedEnvelopeConfig({}),
      createMalformedEnvelopeConfig({ dimensions: null }),
    ];

    for (const value of [null, 0, "config", true]) {
      expect(
        isToolcraftEnvelopePerformanceConfig(
          value as unknown as ToolcraftEnvelopePerformanceConfig,
        ),
      ).toBe(false);
    }
    expect(isToolcraftEnvelopePerformanceConfig(inheritedEnvelope)).toBe(false);
    for (const malformedEnvelope of malformedEnvelopes) {
      expect(isToolcraftEnvelopePerformanceConfig(malformedEnvelope)).toBe(false);
    }
    expect(isToolcraftEnvelopePerformanceConfig(validEnvelope)).toBe(true);
  });

  it("rejects malformed workload envelopes without throwing through either API", () => {
    const cases: readonly [unknown, string][] = [
      [null, "workloadEnvelope must be a non-null object."],
      [0, "workloadEnvelope must be a non-null object."],
      ["envelope", "workloadEnvelope must be a non-null object."],
      [[], "workloadEnvelope must be a non-null object."],
      [{}, "workloadEnvelope.dimensions must be an array."],
      [{ dimensions: null }, "workloadEnvelope.dimensions must be an array."],
      [{ dimensions: {} }, "workloadEnvelope.dimensions must be an array."],
    ];

    expect(
      getToolcraftWorkloadEnvelopeErrors(
        createSchema({}),
        createMalformedEnvelopeConfig(undefined),
      ),
    ).toEqual(["workloadEnvelope must be a non-null object."]);

    for (const [workloadEnvelope, expectedError] of cases) {
      const config = createMalformedEnvelopeConfig(workloadEnvelope);

      expect(getToolcraftWorkloadEnvelopeErrors(createSchema({}), config)).toEqual([
        expectedError,
      ]);
      expect(validateToolcraftPerformanceCoverage(createSchema({}), config)).toEqual([
        expectedError,
      ]);
    }
  });

  it("rejects malformed mappings, dimensions, and sources deterministically", () => {
    const dimensions = [
      {
        ...createDimension({
          id: "unsupported-mapping",
          source: { kind: "external-input", id: "mapping" },
        }),
        mapping: "cubic",
      },
      { ...createDimension({ id: "missing-source" }), source: undefined },
      { ...createDimension({ id: "null-source" }), source: null },
      { ...createDimension({ id: "primitive-source" }), source: "source" },
      {
        ...createDimension({ id: "unknown-kind" }),
        source: { kind: "unknown" },
      },
      {
        ...createDimension({ id: "runtime-path" }),
        source: { kind: "runtime-state", path: 42 },
      },
      {
        ...createDimension({ id: "external-id" }),
        source: { kind: "external-input", id: null },
      },
      {
        ...createDimension({ id: "schema-target" }),
        source: { kind: "schema-target", target: {} },
      },
      {
        ...createDimension({ id: "derived-inputs" }),
        source: { kind: "derived", inputs: null },
      },
      {
        ...createDimension({ id: "derived-input" }),
        source: { kind: "derived", inputs: [null] },
      },
      null,
    ] as unknown as readonly ToolcraftWorkloadDimension[];
    const config = createEnvelopeConfig(dimensions);
    const expected = [
      'Workload dimension "unsupported-mapping" mapping "cubic" is not supported.',
      'Workload dimension "missing-source" source must be a non-null object.',
      'Workload dimension "null-source" source must be a non-null object.',
      'Workload dimension "primitive-source" source must be a non-null object.',
      'Workload dimension "unknown-kind" source kind "unknown" is not supported.',
      'Workload dimension "runtime-path" runtime-state path must be trimmed and non-empty.',
      'Workload dimension "external-id" external-input id must be trimmed and non-empty.',
      'Workload dimension "schema-target" schema-target target must be trimmed and non-empty.',
      'Workload dimension "derived-inputs" derived inputs must be an array.',
      'Workload dimension "derived-input" derived input at index 0 must be trimmed and non-empty.',
      "workloadEnvelope.dimensions[10] must be a non-null object.",
    ];

    expect(getToolcraftWorkloadEnvelopeErrors(createSchema({}), config)).toEqual(
      expected,
    );
    expect(validateToolcraftPerformanceCoverage(createSchema({}), config)).toEqual(
      expected,
    );
  });

  it("requires every explicit workload control to map to one dimension", () => {
    const config = createEnvelopeConfig([]);
    const expected = [
      "Workload control render.count must map to exactly one workloadEnvelope dimension.",
    ];

    expect(getToolcraftWorkloadEnvelopeErrors(createSchema(), config)).toEqual(expected);
    expect(validateToolcraftPerformanceCoverage(createSchema(), config)).toEqual(expected);
  });

  it("accepts a complete schema-backed envelope without legacy scenario validation", () => {
    expect(
      validateToolcraftPerformanceCoverage(
        createSchema(),
        createEnvelopeConfig([createDimension()]),
      ),
    ).toEqual([]);
  });

  it("requires trimmed non-empty dimension and source strings", () => {
    expect(
      errorsFor(
        [
          createDimension({
            id: " runtime ",
            source: { kind: "runtime-state", path: " state.count " },
          }),
          createDimension({
            id: "external",
            source: { kind: "external-input", id: "" },
            unit: " ",
          }),
          createDimension({
            id: "schema",
            source: { kind: "schema-target", target: " render.count " },
          }),
          createDimension({
            id: "derived",
            source: { kind: "derived", inputs: [" runtime "] },
          }),
          createDimension({
            id: "",
            source: { kind: "external-input", id: "empty-dimension-id" },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      "workloadEnvelope.dimensions[0].id must be trimmed and non-empty.",
      'Workload dimension " runtime " runtime-state path must be trimmed and non-empty.',
      'Workload dimension "external" unit must be trimmed and non-empty.',
      'Workload dimension "external" external-input id must be trimmed and non-empty.',
      'Workload dimension "schema" schema-target target must be trimmed and non-empty.',
      'Workload dimension "derived" derived input at index 0 must be trimmed and non-empty.',
      "workloadEnvelope.dimensions[4].id must be trimmed and non-empty.",
    ]);
  });

  it("rejects duplicate dimension ids", () => {
    expect(
      errorsFor([
        createDimension(),
        createDimension({
          id: "count",
          source: { kind: "external-input", id: "secondary" },
        }),
      ]),
    ).toEqual(['Workload dimension id "count" must be unique.']);
  });

  it("requires at least one declared maximum", () => {
    expect(
      errorsFor(
        [
          createDimension({
            interactiveMax: undefined,
            source: { kind: "external-input", id: "count" },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      'Workload dimension "count" must declare interactiveMax or batchMax.',
    ]);
  });

  it("rejects non-finite numeric values while allowing signed boundaries", () => {
    expect(
      errorsFor(
        [
          createDimension({
            batchMax: Number.POSITIVE_INFINITY,
            defaultValue: Number.NaN,
            interactiveMax: -1,
            source: { kind: "external-input", id: "first" },
          }),
          createDimension({
            defaultValue: -1,
            id: "second",
            source: { kind: "runtime-state", path: "state.second" },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      'Workload dimension "count" defaultValue must be a finite number.',
      'Workload dimension "count" batchMax must be a finite number.',
    ]);
  });

  it("accepts maximum-workload boundaries below the default value", () => {
    expect(
      errorsFor(
        [
          createDimension({
            batchMax: 19,
            defaultValue: 20,
            interactiveMax: 10,
            source: { kind: "external-input", id: "count" },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([]);
  });

  it("requires a reason only for custom mappings", () => {
    expect(
      errorsFor(
        [
          createDimension({
            mapping: "custom",
            source: { kind: "external-input", id: "count" },
          }),
        ],
        createSchema({}),
      ),
    ).toEqual([
      'Workload dimension "count" with custom mapping must provide a non-empty customMappingReason.',
    ]);

    expect(
      errorsFor(
        [
          createDimension({ source: { kind: "external-input", id: "count" } }),
        ],
        createSchema({}),
      ),
    ).toEqual([]);
  });
});