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

import { imageExportModule } from "../modules/built-ins/image-export/image-export-module";
import { timelineModule } from "../modules/built-ins/timeline/timeline-module";
import type { ToolcraftProductModuleDefinition } from "../modules/contract/module-definition";
import type { ToolcraftProductBase } from "./product-base";
import { resolveToolcraftProductDefinition } from "./resolve-toolcraft-product-definition";
import {
  cloneUnsafeProductBaseFixture as cloneUnsafeBase,
  createProductBaseFixture as createBase,
} from "./resolve-toolcraft-product-definition.test-support";

describe("resolveToolcraftProductDefinition boundaries", () => {
  it("rejects persistence opt-out and forbidden authored persistence identity", () => {
    expect(() =>
      resolveToolcraftProductDefinition({
        base: { ...createBase(), persistence: { storage: "none" } },
        modules: [timelineModule({ mode: "playback" })],
      }),
    ).toThrow(/timeline/);

    for (const field of ["include", "key", "version"] as const) {
      const unsafe = cloneUnsafeBase(createBase());
      (unsafe.persistence as Record<string, unknown>)[field] =
        field === "include"
          ? ["values"]
          : field === "version"
            ? 1
            : "toolcraft:x:state:v1";
      expect(() =>
        resolveToolcraftProductDefinition({
          base: unsafe as unknown as ToolcraftProductBase,
          modules: [],
        }),
      ).toThrow(new RegExp(`persistence\\.${field}`));
    }
  });

  it("requires identity as the sole identity source", () => {
    const missingIdentity = cloneUnsafeBase(createBase());
    delete missingIdentity.identity;
    expect(() =>
      resolveToolcraftProductDefinition({
        base: missingIdentity as unknown as ToolcraftProductBase,
        modules: [],
      }),
    ).toThrow(/base\.identity/);

    const duplicateIdentity = cloneUnsafeBase(createBase());
    (duplicateIdentity.settingsTransfer as Record<string, unknown>).appId =
      "legacy";
    expect(() =>
      resolveToolcraftProductDefinition({
        base: duplicateIdentity as unknown as ToolcraftProductBase,
        modules: [],
      }),
    ).toThrow(/settingsTransfer\.appId/);
  });

  it("rejects unbranded module records without mutating caller aliases", () => {
    const base = createBase();
    const before = JSON.stringify(base);
    const malformed = {
      ...imageExportModule(),
      id: "image-export",
    } as unknown as ToolcraftProductModuleDefinition;

    expect(() =>
      resolveToolcraftProductDefinition({ base, modules: [malformed] }),
    ).toThrow(/not an opaque definition/);
    expect(JSON.stringify(base)).toBe(before);
  });
});