import { defineToolcraft } from "../schema/define-toolcraft";
import {
  registerToolcraftRendererPipeline,
  type ToolcraftRendererPipelinePassContract,
} from "../rendering/renderer-pipeline-registration";
import type { ToolcraftPerformancePath } from "./performance-path-model";
import type {
  ToolcraftEnvelopePerformanceConfig,
  ToolcraftInteractionInvalidation,
  ToolcraftPerformanceScenario,
  ToolcraftRenderPass,
} from "./performance-types";

export const groupedSchema = defineToolcraft({
  base: {
    identity: { id: "runtime-test", title: "Toolcraft App" },
    canvas: { enabled: true, sizing: { mode: "editable-output" } },
    panels: {
      controls: {
        sections: [
          {
            id: "test-section-1",
            controls: {
              opacity: {
                applicability: { mode: "always" as const },
                defaultValue: 0.5,
                label: "Opacity",
                max: 1,
                min: 0,
                performanceRole: "responsiveness",
                target: "effect.opacity",
                type: "slider",
              },
              strength: {
                applicability: { mode: "always" as const },
                defaultValue: 0.5,
                label: "Strength",
                max: 1,
                min: 0,
                performanceRole: "responsiveness",
                target: "effect.strength",
                type: "slider",
              },
            },
            title: "Effect",
          },
        ],
        title: "Controls",
      },
    },
  },
  modules: [],
});

export const workloadSchema = defineToolcraft({
  base: {
    identity: { id: "runtime-test", title: "Toolcraft App" },
    canvas: { enabled: true, sizing: { mode: "editable-output" } },
    panels: {
      controls: {
        sections: [
          {
            id: "test-section-2",
            controls: {
              density: {
                applicability: { mode: "always" as const },
                defaultValue: 4,
                label: "Density",
                max: 12,
                min: 1,
                performanceRole: "workload",
                target: "render.density",
                type: "slider",
              },
            },
            title: "Render",
          },
        ],
        title: "Controls",
      },
    },
  },
  modules: [],
});

export function createPass(
  overrides: Partial<ToolcraftRenderPass>,
): ToolcraftRenderPass {
  const pass: ToolcraftRenderPass = {
    cacheKey: ["effect.source"],
    cost: {
      dimensions: [],
      frequency: "interaction",
      relationship: "constant",
    },
    id: "uniform-composite",
    inputs: ["effect.source"],
    invalidatedBy: ["effect.opacity", "effect.strength"],
    kind: "composite",
    lifecycle: { cache: "memoized", resourceScope: "renderer" },
    output: "preview",
    quality: "full",
    runsOn: "gpu",
    ...overrides,
  };
  return pass.runsOn === "gpu" || pass.runsOn === "worker-or-gpu"
    ? {
        ...pass,
        gpu: pass.gpu ?? {
          resources: "uniforms-only",
          stage: "render",
          state: "stateless",
          surfaces: ["preview"],
        },
      }
    : pass;
}

export function createInvalidation(
  overrides: Partial<ToolcraftInteractionInvalidation>,
): ToolcraftInteractionInvalidation {
  return {
    interaction: "control-drag",
    invalidates: ["uniform-composite"],
    targets: ["effect.opacity"],
    ...overrides,
  };
}

export function createConfig(
  options: {
    dimensions?: ToolcraftEnvelopePerformanceConfig["workloadEnvelope"]["dimensions"];
    interactions?: readonly ToolcraftInteractionInvalidation[];
    passes?: readonly ToolcraftRenderPass[];
    scenarios?: ToolcraftEnvelopePerformanceConfig["scenarios"];
  } = {},
): ToolcraftEnvelopePerformanceConfig {
  const rendererPipeline = registerToolcraftRendererPipeline<
    Record<string, ToolcraftRendererPipelinePassContract<unknown>>
  >()({
    interactionInvalidation: options.interactions ?? [
      createInvalidation({ targets: ["effect.opacity"] }),
      createInvalidation({ targets: ["effect.strength"] }),
    ],
    passes: options.passes ?? [createPass({})],
    runtimeId: "grouped-effect-renderer-v1",
  });

  return {
    rendererPipeline,
    rendererStrategy: "webgl",
    rendererTechnique: {
      exportRenderer: "webgl",
      fidelityRisks: [
        "The fixture must keep preview and export output equivalent.",
      ],
      gpu: {
        export: { backend: "webgl", provider: "three" },
        preview: { backend: "webgl", provider: "three" },
      },
      performanceRisks: [
        "Interactive composite updates must remain GPU-backed.",
      ],
      previewRenderer: "webgl",
      productRepresentation: "pixel",
      rendererStrategy: "webgl",
      sourceRepresentation: "procedural-data",
      whyNotAlternativeStrategies: [
        "The fixture exercises an explicitly GPU-owned composite path.",
      ],
    },
    scenarios: options.scenarios ?? [],
    usesCustomRenderer: true,
    workloadEnvelope: { dimensions: options.dimensions ?? [] },
  };
}

export function createScenario(
  path: ToolcraftPerformancePath,
  overrides: Partial<
    Exclude<ToolcraftPerformanceScenario, { interaction: "export" }>
  > = {},
): Exclude<ToolcraftPerformanceScenario, { interaction: "export" }> {
  return {
    automated: true,
    automatedTestName: "perf: shared uniform drag stays responsive",
    browser: true,
    browserTestName: "browser perf: shared uniform drag stays responsive",
    controlLabel: "Opacity",
    coversTargets: path.targets,
    expectedObservable:
      "Dragging a uniform control keeps the preview responsive.",
    fixture: "combined uniform path fixture",
    id: "shared-uniform-drag",
    interaction: "control-drag",
    pathId: path.id,
    target: path.targets[0],
    ...overrides,
  };
}