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

import { deriveToolcraftPerformancePaths } from "./performance-paths";
import {
  createConfig,
  createInvalidation,
  createPass,
  groupedSchema,
  workloadSchema,
} from "./performance-paths.test-fixtures";

describe("Toolcraft derived performance paths", () => {
  it("groups equivalent controls by interaction and invalidated render path", () => {
    const paths = deriveToolcraftPerformancePaths(groupedSchema, createConfig());

    expect(paths).toEqual([
      expect.objectContaining({
        interaction: "control-drag",
        invalidates: ["uniform-composite"],
        profile: "interactive-continuous",
        runsOn: ["gpu"],
        targets: ["effect.opacity", "effect.strength"],
        workloadDimensions: [],
      }),
    ]);
  });

  it("keeps different invalidation, execution, and interaction paths separate", () => {
    const passes = [
      createPass({ id: "uniform-composite", runsOn: "gpu" }),
      createPass({
        cacheKey: ["source.asset"],
        id: "source-raster",
        inputs: ["source.asset"],
        invalidatedBy: ["source.asset"],
        kind: "rasterize",
        runsOn: "worker",
      }),
    ];
    const interactions = [
      createInvalidation({ targets: ["effect.opacity"] }),
      createInvalidation({
        interaction: "control-change",
        invalidates: ["source-raster"],
        targets: ["source.asset"],
      }),
      createInvalidation({
        interaction: "viewport-zoom",
        invalidates: [],
        targets: ["canvas.viewport.zoom"],
      }),
      createInvalidation({
        interaction: "timeline-playback",
        invalidates: ["uniform-composite"],
        targets: ["timeline.currentTime"],
      }),
      createInvalidation({
        interaction: "media-import",
        invalidates: ["source-raster"],
        targets: ["media.source"],
      }),
      createInvalidation({
        interaction: "export",
        invalidates: ["uniform-composite"],
        targets: ["actions.export"],
      }),
    ];

    const paths = deriveToolcraftPerformancePaths(
      groupedSchema,
      createConfig({ interactions, passes }),
    );

    expect(paths).toHaveLength(6);
    expect(paths.map((path) => path.interaction)).toEqual(
      expect.arrayContaining([
        "control-change",
        "control-drag",
        "export",
        "media-import",
        "timeline-playback",
        "viewport-zoom",
      ]),
    );
    expect(paths.find((path) => path.interaction === "control-change")).toMatchObject({
      invalidates: ["source-raster"],
      profile: "interactive-discrete",
      runsOn: ["worker"],
    });
    expect(paths.find((path) => path.interaction === "export")).toMatchObject({
      profile: "batch-responsive",
    });
  });

  it("produces stable paths independent of declaration order", () => {
    const secondPass = createPass({
      id: "overlay-composite",
      invalidatedBy: ["effect.opacity", "effect.strength"],
      output: "overlay",
    });
    const interactions = [
      createInvalidation({
        invalidates: ["uniform-composite", "overlay-composite"],
        targets: ["effect.opacity"],
      }),
      createInvalidation({
        invalidates: ["overlay-composite", "uniform-composite"],
        targets: ["effect.strength"],
      }),
    ];
    const forward = createConfig({
      interactions,
      passes: [createPass({}), secondPass],
    });
    const reversed = createConfig({
      interactions: [...forward.rendererPipeline!.interactionInvalidation].reverse(),
      passes: [...forward.rendererPipeline!.passes].reverse(),
    });

    expect(deriveToolcraftPerformancePaths(groupedSchema, reversed)).toEqual(
      deriveToolcraftPerformancePaths(groupedSchema, forward),
    );
  });

  it("keeps a path id stable when equivalent target membership grows", () => {
    const oneTarget = deriveToolcraftPerformancePaths(
      groupedSchema,
      createConfig({
        interactions: [createInvalidation({ targets: ["effect.opacity"] })],
      }),
    )[0]!;
    const twoTargets = deriveToolcraftPerformancePaths(
      groupedSchema,
      createConfig(),
    )[0]!;

    expect(twoTargets.id).toBe(oneTarget.id);
    expect(twoTargets.targets).toEqual(["effect.opacity", "effect.strength"]);
  });

  it("uses collision-safe canonical path ids", () => {
    const getPathId = (dimensions: readonly string[]) =>
      deriveToolcraftPerformancePaths(
        groupedSchema,
        createConfig({
          passes: [
            createPass({
              cost: {
                dimensions,
                frequency: "interaction",
                relationship: dimensions.length > 0 ? "linear" : "constant",
              },
            }),
          ],
        }),
      )[0]!.id;

    expect(getPathId([])).not.toBe(getPathId(["none"]));
    expect(getPathId(["a", "b"])).not.toBe(getPathId(["a+b"]));
    expect(getPathId(["passes=x", "a/b"])).not.toBe(
      getPathId(["passes=x+a/b"]),
    );
  });

  it("includes workload dimensions referenced by invalidated pass costs", () => {
    const config = createConfig({
      dimensions: [
        {
          defaultValue: 4,
          id: "output-units",
          interactiveMax: 12,
          mapping: "direct",
          source: {
            kind: "schema-target",
            target: "render.density",
            workloadBoundary: "maximum",
          },
          unit: "units",
        },
      ],
      interactions: [
        createInvalidation({
          invalidates: ["source-raster"],
          targets: ["render.density"],
        }),
      ],
      passes: [
        createPass({
          cost: {
            dimensions: ["output-units"],
            frequency: "interaction",
            relationship: "linear",
          },
          id: "source-raster",
          invalidatedBy: ["render.density"],
          kind: "rasterize",
        }),
      ],
    });

    expect(deriveToolcraftPerformancePaths(workloadSchema, config)).toEqual([
      expect.objectContaining({
        targets: ["render.density"],
        workloadDimensions: ["output-units"],
      }),
    ]);
  });
});