import {
  BufferGeometry,
  Float32BufferAttribute,
  Group,
  Mesh,
  MeshStandardMaterial,
} from "three";
import { describe, expect, it } from "vitest";

import { validateToolcraftModelDocument } from "../canonical/model-document-validation";
import { TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS } from "../model-import-limits";
import { canonicalizeThreeStaticGeometry } from "./three-static-geometry-canonicalizer";

const options = () => ({
  adapterVersion: "three-test@1",
  limits: TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS,
  signal: new AbortController().signal,
  sourceByteLength: 64,
  sourceFormat: "obj" as const,
});

function triangleGeometry(indexed: boolean): BufferGeometry {
  const geometry = new BufferGeometry();
  geometry.setAttribute(
    "position",
    new Float32BufferAttribute([10, 20, 30, 12, 20, 30, 10, 23, 30], 3),
  );
  geometry.setAttribute(
    "normal",
    new Float32BufferAttribute([0, 0, 1, 0, 0, 1, 0, 0, 1], 3),
  );
  if (indexed) geometry.setIndex([0, 1, 2]);
  return geometry;
}

describe("Three static geometry canonicalizer", () => {
  it("preserves hierarchy, local transforms, instances, and separate primitives", () => {
    const root = new Group();
    root.name = "Root";
    root.position.set(100, 0, 0);
    const parent = new Group();
    parent.name = "Parent";
    parent.scale.set(2, 3, 4);
    const shared = triangleGeometry(true);
    const first = new Mesh(shared);
    first.name = "First";
    first.position.set(5, 6, 7);
    const instance = new Mesh(shared);
    instance.name = "Instance";
    const nonIndexed = new Mesh(triangleGeometry(false));
    nonIndexed.name = "NonIndexed";
    parent.add(first);
    root.add(parent, instance, nonIndexed);

    const result = canonicalizeThreeStaticGeometry(root, options());

    expect(validateToolcraftModelDocument(result.document)).toEqual({ ok: true });
    expect(result.document.rootNodeIds).toEqual(["node:0"]);
    expect(result.document.nodes).toEqual([
      {
        children: ["node:1", "node:3", "node:4"],
        id: "node:0",
        localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 100, 0, 0, 1],
        name: "Root",
        primitiveIds: [],
      },
      {
        children: ["node:2"],
        id: "node:1",
        localMatrix: [2, 0, 0, 0, 0, 3, 0, 0, 0, 0, 4, 0, 0, 0, 0, 1],
        name: "Parent",
        primitiveIds: [],
      },
      {
        children: [],
        id: "node:2",
        localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 5, 6, 7, 1],
        name: "First",
        primitiveIds: ["primitive:0"],
      },
      {
        children: [],
        id: "node:3",
        localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
        name: "Instance",
        primitiveIds: ["primitive:0"],
      },
      {
        children: [],
        id: "node:4",
        localMatrix: [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1],
        name: "NonIndexed",
        primitiveIds: ["primitive:1"],
      },
    ]);
    expect(result.document.primitives).toHaveLength(2);
    expect(result.document.primitives[0]!.indices).toEqual(
      new Uint32Array([0, 1, 2]),
    );
    expect(result.document.primitives[1]!.indices).toEqual(
      new Uint32Array([0, 1, 2]),
    );
    expect(result.document.provenance.operations).toEqual([
      "sequential-indexing",
    ]);
    expect(result.document.bounds).toEqual({
      max: [12, 23, 30],
      min: [10, 20, 30],
    });
  });

  it("keeps shared geometry distinct when nodes bind different materials", () => {
    const root = new Group();
    const geometry = triangleGeometry(true);
    const red = new MeshStandardMaterial({ name: "Red" });
    const blue = new MeshStandardMaterial({ name: "Blue" });
    root.add(new Mesh(geometry, red), new Mesh(geometry, blue));
    const result = canonicalizeThreeStaticGeometry(root, {
      ...options(),
      appearance: {
        diagnostics: [],
        resolveMaterial: (material) => material ? {
          baseColor: material.name === "Red" ? [1, 0, 0] : [0, 0, 1],
          emissive: [0, 0, 0],
          key: material.name,
          metallic: 0,
          opacity: 1,
          roughness: 0.5,
        } : undefined,
      },
    });

    expect(result.document.version).toBe(2);
    if (result.document.version !== 2) throw new Error("Expected v2 document.");
    expect(result.document.primitives.map(({ materialId }) => materialId)).toEqual([
      "material:0",
      "material:1",
    ]);
    expect(result.document.nodes.slice(1).map(({ primitiveIds }) => primitiveIds)).toEqual([
      ["primitive:0"],
      ["primitive:1"],
    ]);
    expect(result.document.materials.map(({ baseColor }) => baseColor)).toEqual([
      [1, 0, 0],
      [0, 0, 1],
    ]);
  });

  it("rejects invalid geometry, finite conversion loss, and hard limits", () => {
    const empty = new BufferGeometry();
    expect(() => canonicalizeThreeStaticGeometry(empty, options())).toThrow(
      expect.objectContaining({ category: "geometry" }),
    );

    const nonFinite = triangleGeometry(true);
    nonFinite.setAttribute(
      "position",
      new Float32BufferAttribute([0, 0, 0, 1, 0, 0, Number.NaN, 1, 0], 3),
    );
    expect(() => canonicalizeThreeStaticGeometry(nonFinite, options())).toThrow(
      expect.objectContaining({ category: "geometry", code: "non-finite-position" }),
    );

    expect(() =>
      canonicalizeThreeStaticGeometry(triangleGeometry(true), {
        ...options(),
        limits: { ...TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS, maxVertices: 2 },
      }),
    ).toThrow(
      expect.objectContaining({ category: "resource-limit", code: "max-vertices-exceeded" }),
    );

    const twoTriangles = new BufferGeometry();
    twoTriangles.setAttribute(
      "position",
      new Float32BufferAttribute([0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0], 3),
    );
    twoTriangles.setIndex([0, 1, 2, 0, 2, 3]);
    expect(() =>
      canonicalizeThreeStaticGeometry(twoTriangles, {
        ...options(),
        limits: { ...TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS, maxTriangles: 1 },
      }),
    ).toThrow(
      expect.objectContaining({ category: "resource-limit", code: "max-triangles-exceeded" }),
    );
    expect(() =>
      canonicalizeThreeStaticGeometry(triangleGeometry(true), {
        ...options(),
        limits: { ...TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS, maxDecodedBytes: 40 },
      }),
    ).toThrow(
      expect.objectContaining({ category: "resource-limit", code: "decoded-byte-limit-exceeded" }),
    );
    expect(() =>
      canonicalizeThreeStaticGeometry(triangleGeometry(true), {
        ...options(),
        limits: {
          ...TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS,
          maxEstimatedWorkerBytes: 900,
        },
      }),
    ).toThrow(
      expect.objectContaining({
        category: "resource-limit",
        code: "estimated-worker-memory-limit-exceeded",
      }),
    );

    const hierarchy = new Group();
    hierarchy.add(new Mesh(triangleGeometry(true)));
    expect(() =>
      canonicalizeThreeStaticGeometry(hierarchy, {
        ...options(),
        limits: { ...TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS, maxNodes: 1 },
      }),
    ).toThrow(
      expect.objectContaining({ category: "resource-limit", code: "max-nodes-exceeded" }),
    );
  });

  it("observes cooperative cancellation during canonical copies", () => {
    const geometry = new BufferGeometry();
    const positions = new Float32Array(3_072 * 3);
    for (let index = 0; index < positions.length; index += 9) {
      positions.set([0, 0, 0, 1, 0, 0, 0, 1, 0], index);
    }
    geometry.setAttribute("position", new Float32BufferAttribute(positions, 3));
    let reads = 0;
    const signal = {
      get aborted() {
        reads += 1;
        return reads > 8;
      },
      get reason() {
        return new DOMException("cancelled in copy", "AbortError");
      },
    } as AbortSignal;

    expect(() =>
      canonicalizeThreeStaticGeometry(geometry, { ...options(), signal }),
    ).toThrow(expect.objectContaining({ name: "AbortError" }));
    expect(reads).toBeGreaterThan(8);
  });
});