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

import { imageExportModule } from "./built-ins/image-export/image-export-module";
import {
  TOOLCRAFT_ARTIFACT_SETTINGS_PERFORMANCE_ROLES,
  type ToolcraftControlSectionModuleContribution,
} from "./contract/contribution";
import { normalizeToolcraftProductModuleContribution } from "./testing/module-resolution-test-support";
import { unsafeCastTestOnlyToolcraftProductModuleContribution } from "./testing/create-test-module-definition";

type IsExact<Left, Right> =
  (<Value>() => Value extends Left ? 1 : 2) extends <
    Value,
  >() => Value extends Right ? 1 : 2
    ? true
    : false;
type ImageSettingsContribution = Extract<
  ToolcraftControlSectionModuleContribution,
  Readonly<{ id: "image-export.settings" }>
>;
const imageControlIdsAreExact: IsExact<
  keyof ImageSettingsContribution["section"]["controls"],
  "imageFormat" | "imageResolution"
> = true;
const imageResolutionRoleIsExact: IsExact<
  ImageSettingsContribution["section"]["controls"]["imageResolution"]["performanceRole"],
  "workload"
> = true;
void imageControlIdsAreExact;
void imageResolutionRoleIsExact;

const malformedKnownContributions = [
  {
    contribution: {
      behavior: "editing",
      id: "canvas-editing.behavior",
      kind: "media-policy",
      moduleId: "canvas-editing",
      operations: ["drag", "handles", "resize", "selection"],
    },
    id: "canvas-editing.behavior",
  },
  {
    contribution: {
      id: "image-export.action",
      kind: "panel-action",
      moduleId: "image-export",
      role: "export-video",
    },
    id: "image-export.action",
  },
  {
    contribution: {
      behavior: "editing",
      id: "canvas-editing.behavior",
      kind: "canvas-behavior",
      moduleId: "canvas-editing",
    },
    id: "canvas-editing.behavior",
  },
] as const;

describe("Toolcraft module contribution normalization", () => {
  it("owns one recursively frozen artifact performance-role authority", () => {
    expect(Object.isFrozen(TOOLCRAFT_ARTIFACT_SETTINGS_PERFORMANCE_ROLES)).toBe(
      true,
    );
    expect(
      Object.values(TOOLCRAFT_ARTIFACT_SETTINGS_PERFORMANCE_ROLES).every(
        Object.isFrozen,
      ),
    ).toBe(true);
  });
  it("rejects noncanonical artifact performance metadata", () => {
    const settings = imageExportModule().contributions.find(
      ({ id }) => id === "image-export.settings",
    );
    expect(settings?.kind).toBe("control-section");
    if (settings?.id !== "image-export.settings") return;

    const malformed = {
      ...settings,
      section: {
        id: "test-section-1",
        ...settings.section,
        controls: {
          ...settings.section.controls,
          imageResolution: {
            ...settings.section.controls.imageResolution,
            performanceRole: "responsiveness",
          },
        },
      },
    } as const;

    expect(() =>
      normalizeToolcraftProductModuleContribution(
        unsafeCastTestOnlyToolcraftProductModuleContribution(malformed),
      ),
    ).toThrowError(
      'Invalid Toolcraft module contribution "image-export.settings": payload does not match its closed contract.',
    );
  });

  it.each([
    {
      mutation: "missing image resolution",
      mutate: (controls: Record<string, unknown>) => ({
        imageFormat: controls.imageFormat,
      }),
    },
    {
      mutation: "extra workload control",
      mutate: (controls: Record<string, unknown>) => ({
        ...controls,
        extraQuality: controls.imageResolution,
      }),
    },
  ])("rejects $mutation in the closed artifact control set", ({ mutate }) => {
    const settings = imageExportModule().contributions.find(
      ({ id }) => id === "image-export.settings",
    );
    expect(settings?.kind).toBe("control-section");
    if (settings?.id !== "image-export.settings") return;
    const malformed = {
      ...settings,
      section: {
        ...settings.section,
        controls: mutate(settings.section.controls),
      },
    };

    expect(() =>
      normalizeToolcraftProductModuleContribution(
        unsafeCastTestOnlyToolcraftProductModuleContribution(malformed),
      ),
    ).toThrowError(
      'Invalid Toolcraft module contribution "image-export.settings": payload does not match its closed contract.',
    );
  });

  it.each(malformedKnownContributions)(
    "rejects malformed $id payloads with one stable diagnostic",
    ({ contribution, id }) => {
      expect(() =>
        // @ts-expect-error Explicit malformed records exercise runtime validation.
        normalizeToolcraftProductModuleContribution(contribution),
      ).toThrowError(
        `Invalid Toolcraft module contribution "${id}": payload does not match its closed contract.`,
      );
    },
  );

  it("rejects unknown contribution ids with a stable diagnostic", () => {
    const contribution = {
      id: "unknown.contribution",
      kind: "panel-action",
      moduleId: "image-export",
      role: "export-image",
    } as const;

    expect(() =>
      // @ts-expect-error Unknown ids are deliberately rejected at the runtime boundary.
      normalizeToolcraftProductModuleContribution(contribution),
    ).toThrowError(
      'Unknown Toolcraft module contribution id "unknown.contribution".',
    );
  });
});