import { vi } from "vitest";

import { defineToolcraft } from "../schema/define-toolcraft";
import { createToolcraftState } from "../state/create-template-state";
import { toolcraftReducer } from "../state/reducer";
import type { ToolcraftModelAsset, ToolcraftState } from "../state/types";
import { TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS } from "./model-import-limit-values";
import type { ToolcraftModelWorkerAnalysisSummary } from "./model-import-types";
import type { ToolcraftModelWorkerClient } from "./worker/model-import-worker-client";

export function createHydrationAnalysis(): ToolcraftModelAsset["analysis"] {
  return {
    boundaryEdges: 0,
    diagnostics: [],
    disconnectedComponents: 1,
    nonManifoldEdges: 0,
    outcome: "clean",
    triangles: 1,
    vertices: 3,
  };
}

export function createHydrationModelAsset(
  activeDocumentRef: string,
  overrides: Partial<ToolcraftModelAsset> = {},
): ToolcraftModelAsset {
  return {
    activeDocumentRef,
    analysis: createHydrationAnalysis(),
    assetKind: "model",
    fileName: "cube.glb",
    id: "model-1",
    layerId: "layer-1",
    lifecycle: "restoring",
    mimeType: "model/gltf-binary",
    originalAnalysis: createHydrationAnalysis(),
    originalDocumentRef: activeDocumentRef,
    position: { x: 0, y: 0 },
    size: { height: 512, unit: "px", width: 512 },
    sourceBundleDigest: `sha256:${"2".repeat(64)}`,
    sourceBundleRef: `toolcraft:model-source-bundle:sha256:${"2".repeat(64)}`,
    topologyProfile: "realtime-mesh",
    ...overrides,
  };
}

export function createHydrationWorkerAnalysis(): ToolcraftModelWorkerAnalysisSummary {
  return {
    analyzerVersion: "toolcraft-topology-v1",
    diagnostics: [],
    limits: TOOLCRAFT_DEFAULT_MODEL_IMPORT_LIMITS,
    outcome: "clean",
    profile: "realtime-mesh",
    statistics: {
      boundaryEdgeCount: 0,
      componentCount: 1,
      decodedBytes: 64,
      edgeCount: 3,
      estimatedPeakWorkerBytes: 128,
      estimatedRepairBytes: 64,
      nodeCount: 1,
      nonManifoldEdgeCount: 0,
      nonManifoldVertexCount: 0,
      primitiveCount: 1,
      triangleCount: 1,
      unusedVertexCount: 0,
      vertexCount: 3,
    },
  };
}

export function createHydrationWorkerClient(
  importModel: ToolcraftModelWorkerClient["importModel"] = vi.fn(),
  extractModelPackage: ToolcraftModelWorkerClient["extractModelPackage"] = vi.fn(),
): ToolcraftModelWorkerClient {
  return {
    cancel: vi.fn(),
    dispose: vi.fn(),
    extractModelPackage,
    importModel,
    repair: vi.fn(),
    reset: vi.fn(),
  };
}

export function createHydrationStateHarness(asset: ToolcraftModelAsset) {
  const schema = defineToolcraft({ canvas: { enabled: true }, panels: {} });
  let state: ToolcraftState = createToolcraftState(schema, {
    mediaAssets: [asset],
  });
  return {
    dispatch: (command: Parameters<typeof toolcraftReducer>[1]) => {
      state = toolcraftReducer(state, command);
    },
    getState: () => state,
  };
}