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

import type { ToolcraftModelFormatAdapter } from "../model-import-types";
import {
  toolcraftGlbModelFormatAdapter,
  toolcraftGltfModelFormatAdapter,
} from "./gltf-model-format-adapter";
import {
  createToolcraftModelFormatAdapterRegistry,
  getToolcraftAdvertisedModelFormats,
} from "./model-format-adapter";
import {
  TOOLCRAFT_ADVERTISED_MODEL_FORMATS,
  TOOLCRAFT_MODEL_FILE_DROP_ACCEPT,
  TOOLCRAFT_MODEL_ROOT_EXTENSIONS,
  TOOLCRAFT_PRODUCTION_GEOMETRY_DECODER_VERSIONS,
  TOOLCRAFT_PRODUCTION_MODEL_FORMAT_ADAPTER_REGISTRY,
  TOOLCRAFT_PRODUCTION_MODEL_FORMAT_MANIFEST,
  TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS,
} from "./production-model-format-registry";
import {
  TOOLCRAFT_FBX_ADAPTER_VERSION,
  TOOLCRAFT_GLTF_ADAPTER_VERSION,
  TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
  TOOLCRAFT_OBJ_ADAPTER_VERSION,
  TOOLCRAFT_PLY_ADAPTER_VERSION,
  TOOLCRAFT_STL_ADAPTER_VERSION,
  TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
} from "./production-model-format-manifest";
import { toolcraftFbxModelFormatAdapter } from "./fbx-model-format-adapter";
import { toolcraftObjModelFormatAdapter } from "./obj-model-format-adapter";
import { toolcraftPlyModelFormatAdapter } from "./ply-model-format-adapter";
import { toolcraftStlModelFormatAdapter } from "./stl-model-format-adapter";
import {
  TOOLCRAFT_PRODUCTION_MODEL_FORMAT_ADAPTER_REGISTRY as TOOLCRAFT_WORKER_MODEL_FORMAT_ADAPTER_REGISTRY,
  TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS as TOOLCRAFT_WORKER_MODEL_FORMAT_REGISTRATIONS,
} from "./production-model-format-worker-registry";

describe("production model format registry", () => {
  it("derives every lightweight production projection from the immutable manifest", () => {
    expect(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_MANIFEST).toEqual([
      {
        accept: ".glb",
        adapterVersion: TOOLCRAFT_GLTF_ADAPTER_VERSION,
        decoderVersion: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
        extensions: [".glb"],
        format: "glb",
      },
      {
        accept: ".gltf",
        adapterVersion: TOOLCRAFT_GLTF_ADAPTER_VERSION,
        decoderVersion: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
        extensions: [".gltf"],
        format: "gltf",
      },
      {
        accept: ".fbx",
        adapterVersion: TOOLCRAFT_FBX_ADAPTER_VERSION,
        decoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
        extensions: [".fbx"],
        format: "fbx",
      },
      {
        accept: ".obj",
        adapterVersion: TOOLCRAFT_OBJ_ADAPTER_VERSION,
        decoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
        extensions: [".obj"],
        format: "obj",
      },
      {
        accept: ".stl",
        adapterVersion: TOOLCRAFT_STL_ADAPTER_VERSION,
        decoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
        extensions: [".stl"],
        format: "stl",
      },
      {
        accept: ".ply",
        adapterVersion: TOOLCRAFT_PLY_ADAPTER_VERSION,
        decoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
        extensions: [".ply"],
        format: "ply",
      },
    ]);
    expect(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS).toEqual([
      {
        adapter: {
          adapterVersion: TOOLCRAFT_GLTF_ADAPTER_VERSION,
          format: "glb",
          rootExtensions: [".glb"],
        },
        geometryDecoderVersion: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: {
          adapterVersion: TOOLCRAFT_GLTF_ADAPTER_VERSION,
          format: "gltf",
          rootExtensions: [".gltf"],
        },
        geometryDecoderVersion: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: {
          adapterVersion: TOOLCRAFT_FBX_ADAPTER_VERSION,
          format: "fbx",
          rootExtensions: [".fbx"],
        },
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: {
          adapterVersion: TOOLCRAFT_OBJ_ADAPTER_VERSION,
          format: "obj",
          rootExtensions: [".obj"],
        },
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: {
          adapterVersion: TOOLCRAFT_STL_ADAPTER_VERSION,
          format: "stl",
          rootExtensions: [".stl"],
        },
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: {
          adapterVersion: TOOLCRAFT_PLY_ADAPTER_VERSION,
          format: "ply",
          rootExtensions: [".ply"],
        },
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
    ]);
    expect(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_ADAPTER_REGISTRY.adapters).toEqual(
      expect.arrayContaining([
        expect.objectContaining({ format: "glb", rootExtensions: [".glb"] }),
        expect.objectContaining({ format: "gltf", rootExtensions: [".gltf"] }),
        expect.objectContaining({ format: "fbx", rootExtensions: [".fbx"] }),
        expect.objectContaining({ format: "obj", rootExtensions: [".obj"] }),
        expect.objectContaining({ format: "stl", rootExtensions: [".stl"] }),
        expect.objectContaining({ format: "ply", rootExtensions: [".ply"] }),
      ]),
    );
    expect(TOOLCRAFT_PRODUCTION_GEOMETRY_DECODER_VERSIONS).toEqual({
      glb: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
      gltf: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
      fbx: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      obj: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      ply: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      stl: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
    });
    expect(TOOLCRAFT_ADVERTISED_MODEL_FORMATS).toEqual([
      "glb", "gltf", "fbx", "obj", "stl", "ply",
    ]);
    expect(TOOLCRAFT_MODEL_ROOT_EXTENSIONS).toEqual([
      ".fbx", ".glb", ".gltf", ".obj", ".ply", ".stl",
    ]);
    expect(TOOLCRAFT_MODEL_FILE_DROP_ACCEPT).toBe(
      ".glb,.gltf,.fbx,.obj,.stl,.ply,.zip",
    );
    expect(
      TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS.some(({ adapter }) =>
        "decode" in adapter
      ),
    ).toBe(false);

    expect(Object.isFrozen(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_MANIFEST)).toBe(true);
    expect(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_MANIFEST.every(Object.isFrozen)).toBe(true);
    expect(Object.isFrozen(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS)).toBe(true);
    expect(
      TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS.every(Object.isFrozen),
    ).toBe(true);
    expect(Object.isFrozen(TOOLCRAFT_PRODUCTION_MODEL_FORMAT_ADAPTER_REGISTRY)).toBe(true);
    expect(Object.isFrozen(TOOLCRAFT_PRODUCTION_GEOMETRY_DECODER_VERSIONS)).toBe(true);
    expect(Object.isFrozen(TOOLCRAFT_ADVERTISED_MODEL_FORMATS)).toBe(true);
    expect(Object.isFrozen(TOOLCRAFT_MODEL_ROOT_EXTENSIONS)).toBe(true);
  });

  it("keeps worker adapters in parity with the lightweight manifest", () => {
    expect(TOOLCRAFT_WORKER_MODEL_FORMAT_REGISTRATIONS).toEqual([
      {
        adapter: toolcraftGlbModelFormatAdapter,
        geometryDecoderVersion: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: toolcraftGltfModelFormatAdapter,
        geometryDecoderVersion: TOOLCRAFT_GLTF_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: toolcraftFbxModelFormatAdapter,
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: toolcraftObjModelFormatAdapter,
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: toolcraftStlModelFormatAdapter,
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
      {
        adapter: toolcraftPlyModelFormatAdapter,
        geometryDecoderVersion: TOOLCRAFT_THREE_STATIC_GEOMETRY_DECODER_VERSION,
      },
    ]);
    expect(TOOLCRAFT_WORKER_MODEL_FORMAT_ADAPTER_REGISTRY.adapters).toEqual([
      toolcraftFbxModelFormatAdapter,
      toolcraftGlbModelFormatAdapter,
      toolcraftGltfModelFormatAdapter,
      toolcraftObjModelFormatAdapter,
      toolcraftPlyModelFormatAdapter,
      toolcraftStlModelFormatAdapter,
    ]);
  });

  it("does not constrain generic registries used by isolated format tests", () => {
    const objAdapter: ToolcraftModelFormatAdapter = {
      adapterVersion: "obj-test@1",
      decode: vi.fn(async () => {
        throw new Error("not decoded in registry test");
      }),
      format: "obj",
      rootExtensions: [".obj"],
      workerCapable: true,
    };
    const testRegistry = createToolcraftModelFormatAdapterRegistry([objAdapter]);

    expect(getToolcraftAdvertisedModelFormats(testRegistry)).toEqual(["obj"]);
    expect(TOOLCRAFT_ADVERTISED_MODEL_FORMATS).toEqual([
      "glb", "gltf", "fbx", "obj", "stl", "ply",
    ]);
  });

  it("exports the same production authority through both model format barrels", async () => {
    const [formatBarrel, modelImportBarrel] = await Promise.all([
      import("./index"),
      import("../index"),
    ]);

    expect(formatBarrel.TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS).toBe(
      TOOLCRAFT_PRODUCTION_MODEL_FORMAT_REGISTRATIONS,
    );
    expect(modelImportBarrel.TOOLCRAFT_ADVERTISED_MODEL_FORMATS).toBe(
      TOOLCRAFT_ADVERTISED_MODEL_FORMATS,
    );
    expect(modelImportBarrel.TOOLCRAFT_MODEL_FILE_DROP_ACCEPT).toBe(
      TOOLCRAFT_MODEL_FILE_DROP_ACCEPT,
    );
    expect("toolcraftGlbModelFormatAdapter" in formatBarrel).toBe(false);
    expect("toolcraftGltfModelFormatAdapter" in modelImportBarrel).toBe(false);
  });
});