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

import type { ToolcraftRendererStrategy } from "./performance";
import { assessToolcraftRenderPlan } from "./performance-render-plan-assessment";
import {
  createBenchmarkDecision,
  createEnvelopeConfig,
  createPass,
} from "./performance-render-plan-test-fixtures";
import { testSchema } from "./performance-test-fixtures";

describe("Toolcraft render plan benchmark decisions", () => {
  it("rejects a malformed benchmark decision collection deterministically", () => {
    const config = {
      ...createEnvelopeConfig(),
      kernelBenchmarkDecisions: { effect: createBenchmarkDecision() },
    } as unknown as ReturnType<typeof createEnvelopeConfig>;
    const firstAssessment = assessToolcraftRenderPlan(testSchema, config);

    expect(firstAssessment).toEqual(assessToolcraftRenderPlan(testSchema, config));
    expect(firstAssessment.errors).toContain(
      "kernelBenchmarkDecisions must be an array when provided.",
    );
    expect(firstAssessment.requiredBenchmarks).toHaveLength(1);
  });

  it.each([
    {
      decision: createBenchmarkDecision({ id: " effect " }),
      expected:
        "kernelBenchmarkDecisions[0].id must be a non-empty trimmed render pass id.",
    },
    {
      decision: createBenchmarkDecision({ decision: " decision " }),
      expected:
        'kernelBenchmarkDecisions "effect" decision must be non-empty and trimmed.',
    },
  ])("rejects malformed benchmark ids and explanations", ({ decision, expected }) => {
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({ kernelBenchmarkDecisions: [decision] }),
    );

    expect(assessment.errors).toContain(expected);
    expect(assessment.requiredBenchmarks).toHaveLength(1);
  });

  it.each([
    {
      decision: createBenchmarkDecision({
        candidates: ["canvas-2d", "canvas-2d"],
      }),
      expected:
        'kernelBenchmarkDecisions "effect" candidates must be unique; received duplicate "canvas-2d".',
    },
    {
      decision: createBenchmarkDecision({ candidates: ["canvas-2d"] }),
      expected:
        'kernelBenchmarkDecisions "effect" candidates must exactly match required candidates canvas-2d, webgl.',
    },
    {
      decision: createBenchmarkDecision({
        candidates: [
          "canvas-2d",
          "webgl",
          "native",
        ] as unknown as readonly ToolcraftRendererStrategy[],
      }),
      expected:
        'kernelBenchmarkDecisions "effect" candidate "native" is not a supported renderer strategy.',
    },
  ])("rejects malformed or mismatched candidate sets", ({ decision, expected }) => {
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({ kernelBenchmarkDecisions: [decision] }),
    );

    expect(assessment.errors).toContain(expected);
    expect(assessment.requiredBenchmarks).toHaveLength(1);
  });

  it("rejects authored timing measurements as execution proof", () => {
    const decision = {
      ...createBenchmarkDecision(),
      measurements: [
        {
          candidate: "canvas-2d",
          durationMs: 1,
          fullQualityOutputVerified: true,
          iterations: 20,
        },
      ],
    };
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({
        kernelBenchmarkDecisions: [decision],
      }),
    );

    expect(assessment.errors).toContain(
      'kernelBenchmarkDecisions "effect" must not contain authored measurements; run the protected kernel benchmark command for execution evidence.',
    );
    expect(assessment.requiredBenchmarks).toHaveLength(1);
  });

  it("rejects duplicate and irrelevant decisions", () => {
    const duplicate = createBenchmarkDecision();
    const irrelevant = createBenchmarkDecision({ id: "other-pass" });
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({
        kernelBenchmarkDecisions: [duplicate, duplicate, irrelevant],
      }),
    );

    expect(assessment.errors).toEqual(
      expect.arrayContaining([
        'kernelBenchmarkDecisions id "effect" must be unique.',
        'kernelBenchmarkDecisions "other-pass" does not map to a required render pass benchmark.',
      ]),
    );
    expect(assessment.requiredBenchmarks).toHaveLength(1);
  });

  it("requires the selected strategy to be declared", () => {
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({
        kernelBenchmarkDecisions: [
          createBenchmarkDecision({ selected: "svg" }),
        ],
      }),
    );

    expect(assessment.errors).toContain(
      'kernelBenchmarkDecisions "effect" selected strategy "svg" must be declared in candidates.',
    );
    expect(assessment.requiredBenchmarks).toHaveLength(1);
  });

  it("accepts a complete decision and retains render-plan invariants", () => {
    const exportPass = createPass({
      cacheKey: undefined,
      cost: {
        dimensions: ["output-units"],
        frequency: "batch",
        relationship: "linear",
      },
      id: "export-output",
      inputs: ["effect"],
      invalidatedBy: ["effect", "canvas.size"],
      kind: "export",
      lifecycle: { cache: "none", resourceScope: "call" },
      output: "export",
      quality: "export",
      runsOn: "export-only",
    });
    const config = createEnvelopeConfig({
      kernelBenchmarkDecisions: [createBenchmarkDecision()],
      passes: [createPass(), exportPass],
    });

    expect(assessToolcraftRenderPlan(testSchema, config)).toEqual({
      errors: [],
      invariants: {
        backingResolution: {
          canvasSizeSource: "runtime-state",
          canvasSize: testSchema.canvas.size,
          defaultBackingSize: {
            height: testSchema.canvas.size.height,
            width: testSchema.canvas.size.width,
          },
          effectiveDefaultScale: 1,
          renderScale: testSchema.canvas.renderScale,
          renderScaleSource: "schema",
          runtimeTargets: {
            height: "canvas.size.height",
            renderScale: null,
            width: "canvas.size.width",
          },
          sizeSource: testSchema.canvas.sizeSource,
          sizingMode: testSchema.canvas.sizing.mode,
        },
        outputQuality: [
          { output: "preview", passId: "effect", quality: "full" },
          { output: "export", passId: "export-output", quality: "export" },
        ],
      },
      requiredBenchmarks: [],
      warnings: [],
    });
  });

  it("requires benchmark selection to match the configured renderer", () => {
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({
        kernelBenchmarkDecisions: [
          createBenchmarkDecision({ selected: "webgl" }),
        ],
      }),
    );

    expect(assessment.errors).toContain(
      'kernelBenchmarkDecisions "effect" selected strategy "webgl" must match rendererStrategy "canvas-2d".',
    );
    expect(assessment.requiredBenchmarks).toHaveLength(1);
  });

  it("keeps duplicate pass requirements unresolved", () => {
    const assessment = assessToolcraftRenderPlan(
      testSchema,
      createEnvelopeConfig({
        kernelBenchmarkDecisions: [createBenchmarkDecision()],
        passes: [createPass(), createPass()],
      }),
    );

    expect(assessment.errors).toContain(
      'rendererPipeline pass id "effect" must be unique for render-plan assessment.',
    );
    expect(assessment.requiredBenchmarks).toHaveLength(2);
  });
});