import type {
  ToolcraftEnvelopePerformanceConfig,
  ToolcraftKernelBenchmarkDecision,
  ToolcraftRenderPass,
  ToolcraftRendererStrategy,
} from "./performance";
import {
  registerToolcraftRendererPipeline,
  type ToolcraftRendererPipeline,
  type ToolcraftRendererPipelinePassContract,
} from "../rendering/renderer-pipeline-registration";

export const benchmarkCandidates = ["canvas-2d", "webgl"] as const;

export const benchmarkWorkload = {
  "output-units": 12,
  samples: 4,
} as const;

export function createPass(
  overrides: Partial<ToolcraftRenderPass> = {},
): ToolcraftRenderPass {
  return {
    cacheKey: ["source.input", "effect.samples"],
    cost: {
      dimensions: ["output-units", "samples"],
      frequency: "frame",
      relationship: "product",
    },
    id: "effect",
    inputs: ["source.input"],
    invalidatedBy: ["source.input", "effect.samples"],
    kind: "pixel-transform",
    lifecycle: {
      cache: "memoized",
      resourceScope: "renderer",
    },
    output: "preview",
    quality: "full",
    runsOn: "main",
    ...overrides,
  };
}

export function createBenchmarkDecision(
  overrides: Partial<ToolcraftKernelBenchmarkDecision> = {},
): ToolcraftKernelBenchmarkDecision {
  return {
    candidates: benchmarkCandidates,
    decision:
      "Canvas 2D is selected after comparing the complete kernel at normal output quality.",
    id: "effect",
    selected: "canvas-2d",
    ...overrides,
  };
}

export function createEnvelopeConfig(options: {
  kernelBenchmarkDecisions?: readonly ToolcraftKernelBenchmarkDecision[];
  omitRuntimeId?: boolean;
  pass?: ToolcraftRenderPass;
  passes?: readonly ToolcraftRenderPass[];
  rendererStrategy?: ToolcraftRendererStrategy;
  runtimeId?: string;
} = {}): ToolcraftEnvelopePerformanceConfig {
  const pass = options.pass ?? createPass();
  const rendererPipeline: ToolcraftRendererPipeline = {
    interactionInvalidation: [
      {
        interaction: "control-drag",
        invalidates: [pass.id],
        targets: ["effect.samples"],
      },
    ],
    passes: options.passes ?? [pass],
    ...(options.omitRuntimeId
      ? {}
      : { runtimeId: options.runtimeId ?? "effect-renderer-v1" }),
  };
  let executablePipeline: ToolcraftEnvelopePerformanceConfig["rendererPipeline"] =
    rendererPipeline;
  try {
    executablePipeline = registerToolcraftRendererPipeline<
      Record<string, ToolcraftRendererPipelinePassContract<unknown>>
    >()(rendererPipeline);
  } catch {
    // Malformed assessment fixtures remain raw so validators can report every defect.
  }

  return {
    ...(options.kernelBenchmarkDecisions
      ? { kernelBenchmarkDecisions: options.kernelBenchmarkDecisions }
      : {}),
    rendererPipeline: executablePipeline,
    rendererStrategy: options.rendererStrategy ?? "canvas-2d",
    scenarios: [],
    usesCustomRenderer: true,
    workloadEnvelope: {
      dimensions: [
        {
          defaultValue: 4,
          id: "output-units",
          interactiveMax: 12,
          mapping: "direct",
          source: {
            kind: "schema-target",
            target: "render.density",
            workloadBoundary: "maximum",
          },
          unit: "units",
        },
        {
          defaultValue: 1,
          id: "samples",
          interactiveMax: 4,
          mapping: "direct",
          source: { id: "effect-samples", kind: "external-input" },
          unit: "samples",
        },
      ],
    },
  };
}