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

import { canvasEditingModule } from "./built-ins/canvas-editing/canvas-editing-module";
import { model3dModule } from "./built-ins/model-3d/model-3d-module";
import { spatialViewModule } from "./built-ins/spatial-view/spatial-view-module";

function expectRecursivelyFrozen(value: unknown): void {
  if (value === null || typeof value !== "object") {
    return;
  }

  expect(Object.isFrozen(value)).toBe(true);
  for (const nestedValue of Object.values(value)) {
    expectRecursivelyFrozen(nestedValue);
  }
}

function assertModelOptionsAreClosed(): void {
  // @ts-expect-error Model presentation accepts only runtime or custom.
  model3dModule({ presentation: "hybrid" });
  // @ts-expect-error Model module options do not carry pipeline metadata.
  model3dModule({ presentation: "runtime", sourceTarget: "media.source" });
}
void assertModelOptionsAreClosed;

describe("Project B scene built-in factories", () => {
  it("defines only the two cached Model 3D presentation variants", () => {
    const runtime = model3dModule();
    const custom = model3dModule({ presentation: "custom" });

    expect(model3dModule({ presentation: "runtime" })).toBe(runtime);
    expect(model3dModule({ presentation: "custom" })).toBe(custom);
    expect(custom).not.toBe(runtime);
    expect(Object.fromEntries(Object.entries(runtime))).toEqual({
      contractVersion: 2,
      contributions: [],
      defaultProviders: [
        {
          capabilityId: "media.source",
          providerId: "media.source-default",
        },
      ],
      id: "model-3d",
      portRequirements: [],
      provides: ["model.3d"],
      requires: ["media.source"],
    });
    expect(Object.fromEntries(Object.entries(custom))).toEqual({
      contractVersion: 2,
      contributions: [],
      defaultProviders: [
        {
          capabilityId: "media.source",
          providerId: "media.source-default",
        },
      ],
      id: "model-3d",
      portRequirements: [
        { applicability: "always", id: "modelPresentation" },
      ],
      provides: ["model.3d"],
      requires: ["media.source"],
    });
    expectRecursivelyFrozen(runtime);
    expectRecursivelyFrozen(custom);
  });

  it("defines one exact cached Canvas Editing module", () => {
    const definition = canvasEditingModule();

    expect(canvasEditingModule()).toBe(definition);
    expect(Object.fromEntries(Object.entries(definition))).toEqual({
      contractVersion: 2,
      contributions: [
        {
          behavior: "editing",
          id: "canvas-editing.behavior",
          kind: "canvas-behavior",
          moduleId: "canvas-editing",
          operations: ["drag", "handles", "resize", "selection"],
        },
      ],
      defaultProviders: [],
      id: "canvas-editing",
      portRequirements: [
        { applicability: "always", id: "scene.canvasContent" },
      ],
      provides: ["canvas.editing"],
      requires: [],
    });
    expectRecursivelyFrozen(definition);
  });

  it("defines one exact cached Spatial View module", () => {
    const definition = spatialViewModule();

    expect(spatialViewModule()).toBe(definition);
    expect(Object.fromEntries(Object.entries(definition))).toEqual({
      contractVersion: 2,
      contributions: [
        {
          behavior: "spatial-view",
          id: "spatial-view.behavior",
          kind: "canvas-behavior",
          moduleId: "spatial-view",
          operations: ["gizmo", "orbit", "paused-live-sync", "pose"],
        },
      ],
      defaultProviders: [],
      id: "spatial-view",
      portRequirements: [
        { applicability: "spatial-product-scene", id: "scene.canvasContent" },
      ],
      provides: ["spatial.view"],
      requires: [],
    });
    expectRecursivelyFrozen(definition);
  });
});