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

import { imageExportModule } from "./built-ins/image-export/image-export-module";
import { mediaSourceModule } from "./built-ins/media-source/media-source-module";
import { svgExportModule } from "./built-ins/svg-export/svg-export-module";
import { timelineModule } from "./built-ins/timeline/timeline-module";
import { videoExportModule } from "./built-ins/video-export/video-export-module";
import {
  TOOLCRAFT_BUILT_IN_MODULE_CATALOG,
  TOOLCRAFT_DEFAULT_PROVIDER_CATALOG,
} from "./built-in-catalog";
import type { ToolcraftProductModuleId } from "./contract/capability";
import type { ToolcraftProductModuleDefinition } from "./contract/module-definition";

const expectedBuiltInModuleIds = [
  "canvas-editing",
  "image-export",
  "layers",
  "media-source",
  "model-3d",
  "spatial-view",
  "svg-export",
  "timeline",
  "video-export",
] as const satisfies readonly ToolcraftProductModuleId[];
type MissingBuiltInModuleId = Exclude<
  ToolcraftProductModuleId,
  (typeof expectedBuiltInModuleIds)[number]
>;
const builtInModuleIdsAreExhaustive: MissingBuiltInModuleId extends never
  ? true
  : never = true;
void builtInModuleIdsAreExhaustive;

function expectModuleBoundaryFrozen(
  definition: ToolcraftProductModuleDefinition,
): void {
  expect(Object.isFrozen(definition)).toBe(true);
  expect(Object.isFrozen(definition.provides)).toBe(true);
  expect(Object.isFrozen(definition.requires)).toBe(true);
  expect(Object.isFrozen(definition.defaultProviders)).toBe(true);
  expect(definition.defaultProviders.every(Object.isFrozen)).toBe(true);
  expect(Object.isFrozen(definition.portRequirements)).toBe(true);
  expect(definition.portRequirements.every(Object.isFrozen)).toBe(true);
  expect(Object.isFrozen(definition.contributions)).toBe(true);
  expect(definition.contributions.every(Object.isFrozen)).toBe(true);
}

function expectPublicDefinition(
  definition: ToolcraftProductModuleDefinition,
  expected: Record<string, unknown>,
): void {
  expect(Object.fromEntries(Object.entries(definition))).toEqual(expected);
}

function expectSettingsContributionFrozen(
  definition: ToolcraftProductModuleDefinition,
): void {
  const settings = definition.contributions.find(
    (contribution) => contribution.kind === "control-section",
  );
  expect(settings).toBeDefined();
  if (settings?.kind !== "control-section") {
    return;
  }

  expect(Object.isFrozen(settings.placement)).toBe(true);
  expect(Object.isFrozen(settings.placement.after)).toBe(true);
  expect(Object.isFrozen(settings.placement.before)).toBe(true);
  expect(Object.isFrozen(settings.section)).toBe(true);
  expect(Object.isFrozen(settings.section.controls)).toBe(true);
  for (const control of Object.values(settings.section.controls)) {
    expect(Object.isFrozen(control)).toBe(true);
    expect(Object.isFrozen(control.applicability)).toBe(true);
    expect(Object.isFrozen(control.options)).toBe(true);
    expect(control.options.every(Object.isFrozen)).toBe(true);
  }
  expect(Object.isFrozen(settings.section.layoutGroups)).toBe(true);
  for (const layoutGroup of settings.section.layoutGroups) {
    expect(Object.isFrozen(layoutGroup)).toBe(true);
    expect(Object.isFrozen(layoutGroup.controls)).toBe(true);
  }
}

describe("Toolcraft built-in capability modules", () => {
  it("defines the cached image-export module with canonical settings and action", () => {
    const definition = imageExportModule();

    expect(imageExportModule()).toBe(definition);
    expectPublicDefinition(definition, {
      contractVersion: 2,
      contributions: [
        {
          id: "image-export.settings",
          kind: "control-section",
          moduleId: "image-export",
          placement: {
            after: [],
            before: ["video-export.settings"],
            slot: "artifact-settings",
          },
          runtimeSectionId: "runtime.image-export",
          section: {
            controls: {
              imageFormat: {
                applicability: { mode: "always" as const },
                defaultValue: "png",
                label: "Format",
                options: [
                  { label: "PNG", value: "png" },
                  { label: "JPG", value: "jpg" },
                ],
                performanceRole: "responsiveness",
                target: "export.image.format",
                type: "select",
              },
              imageResolution: {
                applicability: { mode: "always" as const },
                defaultValue: "4k",
                label: "Resolution",
                options: [
                  { label: "2K", value: "2k" },
                  { label: "4K", value: "4k" },
                  { label: "8K", value: "8k" },
                ],
                performanceRole: "workload",
                target: "export.image.resolution",
                type: "select",
              },
            },
            layoutGroups: [
              {
                columns: 2,
                controls: ["imageFormat", "imageResolution"],
                layout: "inline",
              },
            ],
            title: "Image Export",
          },
        },
        {
          id: "image-export.action",
          kind: "panel-action",
          moduleId: "image-export",
          role: "export-image",
        },
      ],
      defaultProviders: [],
      id: "image-export",
      portRequirements: [
        {
          applicability: "product-scene",
          id: "scene.rasterFrameRenderer",
        },
      ],
      provides: ["artifact.image-export"],
      requires: [],
    });
    expectModuleBoundaryFrozen(definition);
    expectSettingsContributionFrozen(definition);
  });

  it("defines the cached SVG-export module with only its canonical action", () => {
    const definition = svgExportModule();

    expect(svgExportModule()).toBe(definition);
    expectPublicDefinition(definition, {
      contractVersion: 2,
      contributions: [
        {
          id: "svg-export.action",
          kind: "panel-action",
          moduleId: "svg-export",
          role: "export-svg",
        },
      ],
      defaultProviders: [],
      id: "svg-export",
      portRequirements: [
        {
          applicability: "always",
          id: "scene.vectorFrameRenderer",
        },
      ],
      provides: ["artifact.svg-export"],
      requires: [],
    });
    expectModuleBoundaryFrozen(definition);
  });

  it("defines the cached video-export module with canonical settings and timeline dependency", () => {
    const definition = videoExportModule();

    expect(videoExportModule()).toBe(definition);
    expectPublicDefinition(definition, {
      contractVersion: 2,
      contributions: [
        {
          id: "video-export.settings",
          kind: "control-section",
          moduleId: "video-export",
          placement: {
            after: [],
            before: [],
            slot: "artifact-settings",
          },
          runtimeSectionId: "runtime.video-export",
          section: {
            controls: {
              videoFormat: {
                applicability: { mode: "always" as const },
                defaultValue: "mp4",
                label: "Format",
                options: [
                  { label: "MP4", value: "mp4" },
                  { label: "WebM", value: "webm" },
                ],
                performanceRole: "responsiveness",
                target: "export.video.format",
                type: "select",
              },
              videoResolution: {
                applicability: { mode: "always" as const },
                defaultValue: "current",
                label: "Resolution",
                options: [
                  { label: "Current", value: "current" },
                  { label: "4K", value: "4k" },
                ],
                performanceRole: "responsiveness",
                target: "export.video.resolution",
                type: "select",
              },
            },
            layoutGroups: [
              {
                columns: 2,
                controls: ["videoFormat", "videoResolution"],
                layout: "inline",
              },
            ],
            title: "Video Export",
          },
        },
        {
          id: "video-export.action",
          kind: "panel-action",
          moduleId: "video-export",
          role: "export-video",
        },
      ],
      defaultProviders: [
        {
          capabilityId: "timeline.playback",
          providerId: "timeline.playback-default",
        },
      ],
      id: "video-export",
      portRequirements: [
        {
          applicability: "product-scene",
          id: "scene.rasterFrameRenderer",
        },
      ],
      provides: ["artifact.video-export"],
      requires: ["timeline.playback"],
    });
    expectModuleBoundaryFrozen(definition);
    expectSettingsContributionFrozen(definition);
  });

  it("keeps raster and vector renderer requirements scoped to their products", () => {
    expect(imageExportModule().portRequirements).toEqual(
      videoExportModule().portRequirements,
    );
    expect(imageExportModule().portRequirements).toEqual([
      {
        applicability: "product-scene",
        id: "scene.rasterFrameRenderer",
      },
    ]);
    expect(svgExportModule().portRequirements).toEqual([
      {
        applicability: "always",
        id: "scene.vectorFrameRenderer",
      },
    ]);
    expect(timelineModule({ mode: "playback" }).portRequirements).toEqual([]);
    expect(timelineModule({ mode: "keyframes" }).portRequirements).toEqual([]);
  });

  it("owns image-before-video placement only from image settings", () => {
    const imageSettings = imageExportModule().contributions[0];
    const videoSettings = videoExportModule().contributions[0];

    expect(imageSettings?.kind).toBe("control-section");
    expect(videoSettings?.kind).toBe("control-section");
    if (
      imageSettings?.kind !== "control-section" ||
      videoSettings?.kind !== "control-section"
    ) {
      return;
    }

    expect(imageSettings.placement).toEqual({
      after: [],
      before: ["video-export.settings"],
      slot: "artifact-settings",
    });
    expect(videoSettings.placement).toEqual({
      after: [],
      before: [],
      slot: "artifact-settings",
    });
  });
});

describe("Toolcraft built-in module catalogs", () => {
  it("contains every built-in module id exactly once in deterministic order", () => {
    expect(TOOLCRAFT_BUILT_IN_MODULE_CATALOG).toEqual([
      { contractVersion: 2, id: "canvas-editing" },
      { contractVersion: 2, id: "image-export" },
      { contractVersion: 2, id: "layers" },
      { contractVersion: 2, id: "media-source" },
      { contractVersion: 2, id: "model-3d" },
      { contractVersion: 2, id: "spatial-view" },
      { contractVersion: 2, id: "svg-export" },
      { contractVersion: 2, id: "timeline" },
      { contractVersion: 2, id: "video-export" },
    ]);
    expect(
      new Set(TOOLCRAFT_BUILT_IN_MODULE_CATALOG.map(({ id }) => id)).size,
    ).toBe(TOOLCRAFT_BUILT_IN_MODULE_CATALOG.length);
    expect(TOOLCRAFT_BUILT_IN_MODULE_CATALOG.map(({ id }) => id)).toEqual(
      expectedBuiltInModuleIds,
    );
    expect(Object.isFrozen(TOOLCRAFT_BUILT_IN_MODULE_CATALOG)).toBe(true);
    expect(TOOLCRAFT_BUILT_IN_MODULE_CATALOG.every(Object.isFrozen)).toBe(true);
    expect(
      TOOLCRAFT_BUILT_IN_MODULE_CATALOG.every(
        (entry) => Object.keys(entry).sort().join(",") === "contractVersion,id",
      ),
    ).toBe(true);
  });

  it("contains exactly the canonical media and playback default providers", () => {
    expect(TOOLCRAFT_DEFAULT_PROVIDER_CATALOG).toEqual([
      {
        capabilityId: "media.source",
        definition: mediaSourceModule(),
        id: "media.source-default",
      },
      {
        capabilityId: "timeline.playback",
        definition: timelineModule({ mode: "playback" }),
        id: "timeline.playback-default",
      },
    ]);
    expect(Object.isFrozen(TOOLCRAFT_DEFAULT_PROVIDER_CATALOG)).toBe(true);
    expect(TOOLCRAFT_DEFAULT_PROVIDER_CATALOG.every(Object.isFrozen)).toBe(
      true,
    );
    expect(
      TOOLCRAFT_DEFAULT_PROVIDER_CATALOG.every(
        (entry) =>
          Object.keys(entry).sort().join(",") === "capabilityId,definition,id",
      ),
    ).toBe(true);
    expect(TOOLCRAFT_DEFAULT_PROVIDER_CATALOG[0]?.definition).toBe(
      mediaSourceModule(),
    );
    expect(TOOLCRAFT_DEFAULT_PROVIDER_CATALOG[1]?.definition).toBe(
      timelineModule({ mode: "playback" }),
    );
  });
});