import type { ErrorReport } from "./error";
import type { ProgressEvent } from "./progress";
import type { NonMeshCurveSplineType, NonMeshFontCharacterIR, NonMeshFontLinksIR, NonMeshFontPropertiesIR, NonMeshFontTextBoxIR, SceneSnapshotIR } from "./scene-ir";
import type { SceneDelta } from "./scene-delta";
import type { SimplifyProfile } from "./simplify";
import type { SimplifyResult } from "./simplify";
import type { LODGenerationRequest } from "./lod";
import type { LODManifest } from "./simplify";
import type { DepsgraphEvaluationIR } from "./depsgraph";
import type { SculptMeshAttributesIR, SculptStrokeIR } from "./sculpt";
import type { GeometryNodeGraphIR } from "./geometry-nodes";
import type { PhysicsSimulationManifestIR } from "./physics-simulation";
import type { ShaderGraphIR } from "./shader-graph";
import type { ShaderCompileReport } from "./shader-compiler";
import type { NlaMoveStripCommand, NlaTrackIR } from "./nla";
import type { RenderCapabilityRequest } from "./render-capabilities";
import type { CapabilityGateResult } from "./capability-gates";
import type { NonMeshGeometryChunk } from "./nonmesh-binary";
import type {
  PaintStrokeSessionBeginIR,
  PaintStrokeSessionCancelIR,
  PaintStrokeSessionChunkIR,
  PaintStrokeSessionCommitIR,
  PaintStrokeSessionReceiptIR,
} from "./paint-stroke-session";
import type { PaintPBVHCapabilityRequest } from "./paint-pbvh-capability";
import type { LibraryMainAppendReceiptIR, LibraryMainAppendRequestIR } from "./library-main-append";

export interface MeshGeometryBuffer {
  schemaVersion: 1;
  meshId: string;
  byteLength: number;
  positions: ArrayBuffer;
  indices: ArrayBuffer;
  normals?: ArrayBuffer;
  triangleCornerIndices?: ArrayBuffer;
  uvs?: ArrayBuffer;
  colors?: ArrayBuffer;
  triangleMaterialIndices?: ArrayBuffer;
  triangleFaceIndices?: ArrayBuffer;
  edgeVertexIndices?: ArrayBuffer;
  tangents?: ArrayBuffer;
  splitNormals?: ArrayBuffer;
  sculptMask?: ArrayBuffer;
  faceSets?: ArrayBuffer;
}

export type MeshGeometryBufferField =
  | "positions"
  | "indices"
  | "normals"
  | "triangleCornerIndices"
  | "uvs"
  | "colors"
  | "triangleMaterialIndices"
  | "triangleFaceIndices"
  | "edgeVertexIndices"
  | "tangents"
  | "splitNormals"
  | "sculptMask"
  | "faceSets";

export interface MeshGeometryRangePatch {
  meshId: string;
  field: MeshGeometryBufferField;
  byteOffset: number;
  data: ArrayBuffer;
}

export interface MeshGeometryDelta {
  schemaVersion: 1;
  patches: MeshGeometryRangePatch[];
  replaced: MeshGeometryBuffer[];
  removed: string[];
}

export type MeshElementMode = "VERT" | "EDGE" | "FACE";
export type MeshEditOperation = "MERGE" | "DISSOLVE" | "EXTRUDE" | "INSET" | "BEVEL" | "LOOP_CUT";
export type FCurveInterpolation = "CONSTANT" | "LINEAR" | "BEZIER";

export type WebEngineEditCommand =
  | { type: "setFrame"; frame: number }
  | { type: "setObjectVisibility"; objectId: string; visible: boolean }
  | { type: "setModifierEnabled"; meshId: string; modifierUuid: string; enabled: boolean }
  | { type: "setModifierVisibility"; meshId: string; modifierUuid: string; showViewport: boolean; showRender: boolean; showEditMode: boolean; showOnCage: boolean }
  | { type: "decimateMesh"; meshId: string; profile: SimplifyProfile }
  | { type: "previewDecimateMesh"; meshId: string; profile: SimplifyProfile }
  | { type: "createPrimitive"; primitive: "CUBE" | "PLANE"; name?: string; location: [number, number, number] }
  | { type: "duplicateObject"; objectId: string; offset?: [number, number, number]; linked?: boolean }
  | { type: "deleteObject"; objectId: string }
  | { type: "setObjectTransform"; objectId: string; translation: [number, number, number]; rotationEuler: [number, number, number]; scale: [number, number, number] }
  | { type: "translateMeshVertices"; meshId: string; vertexIndices: number[]; offset: [number, number, number] }
  | { type: "meshEdit"; meshId: string; operation: MeshEditOperation; selectionMode: MeshElementMode; elementIndices: number[]; offset?: [number, number, number]; amount?: number; segments?: number }
  | { type: "createUVMap"; meshId: string; name: string }
  | { type: "setActiveUVMap"; meshId: string; name: string }
  | { type: "unwrapUV"; meshId: string; faceIndices: number[]; method: "PLANAR" | "CUBE" }
  | { type: "addMaterialSlot"; objectId: string; name?: string }
  | { type: "removeMaterialSlot"; objectId: string; slotIndex: number }
  | { type: "assignMaterialFaces"; meshId: string; faceIndices: number[]; slotIndex: number }
  | { type: "setMaterialPrincipled"; materialId: string; baseColor: [number, number, number, number]; roughness: number; metallic: number; emissionColor?: [number, number, number, number]; alpha?: number; ior?: number; specularIORLevel?: number; transmissionWeight?: number; coatWeight?: number; coatRoughness?: number; emissionStrength?: number }
  | { type: "importImage"; name: string; mimeType: "image/png" | "image/jpeg"; width: number; height: number; base64: string }
  | { type: "setMaterialImageNode"; materialId: string; imageId: string; usage: "BASE_COLOR" | "NORMAL"; uvMap?: string }
  | { type: "insertObjectKeyframe"; objectId: string; frame: number; property: "LOCATION" | "ROTATION_EULER" | "SCALE"; interpolation?: FCurveInterpolation }
  | { type: "deleteObjectKeyframe"; objectId: string; frame: number; property?: "LOCATION" | "ROTATION_EULER" | "SCALE" }
  | { type: "setFCurveInterpolation"; animationId: string; path: string; interpolation: FCurveInterpolation }
  | { type: "setActiveAction"; objectId: string; actionId: string | null }
  | { type: "setConstraint"; objectId: string; constraintName: string; enabled: boolean; influence: number }
  | { type: "setParent"; objectId: string; parentId: string | null; keepTransform?: boolean }
  | { type: "createCollection"; name: string; parentCollectionId?: string | null }
  | { type: "moveObjectToCollection"; objectId: string; collectionId: string }
  | { type: "renameId"; id: string; name: string }
  | { type: "joinObjects"; activeObjectId: string; objectIds: string[] }
  | { type: "separateMeshFaces"; objectId: string; faceIndices: number[]; name?: string }
  | { type: "applyObjectTransform"; objectId: string }
  | { type: "setObjectOrigin"; objectId: string; mode: "GEOMETRY" | "WORLD" }
  | { type: "createCurve"; curveType: "CURVE"; name?: string; controlPoints: number[]; cyclic?: boolean; resolution?: number }
  | { type: "deleteNonMeshData"; dataId: string }
  | { type: "setCurveControlPoints"; dataId: string; controlPoints: number[]; splineOffsets?: number[]; resolution?: number }
  | { type: "setCurveHandle"; dataId: string; pointIndex: number; side: "LEFT" | "RIGHT"; position: [number, number, number] }
  | { type: "setCurveTopology"; dataId: string; baseRevision?: number; splineTypes?: NonMeshCurveSplineType[]; cyclicU?: boolean[]; cyclicV?: boolean[]; handleTypes?: number[]; handlePoints?: number[] }
  | { type: "setCurveSplines"; dataId: string; splineTypes: NonMeshCurveSplineType[]; splineOffsets: number[]; ordersU: number[]; controlPoints: number[]; pointWeights: number[]; cyclicU: boolean[]; handleTypes: number[]; handlePoints: number[] }
  | { type: "setSurfaceTopology"; dataId: string; splineDimensions: Array<{ u: number; v: number; orderU: number; orderV: number }>; controlPoints: number[]; pointWeights: number[]; cyclicU: boolean[]; cyclicV: boolean[] }
  | { type: "setFontBody"; dataId: string; body: string }
  | { type: "setFontProperties"; dataId: string; properties: Partial<NonMeshFontPropertiesIR> }
  | { type: "setFontAdvanced"; dataId: string; characters: NonMeshFontCharacterIR[]; textBoxes: NonMeshFontTextBoxIR[]; activeTextBox: number }
  | { type: "importVFont"; schemaVersion: 1; projectId: string; assetId: string; assetPath: string; sourcePath: string; name: string; format: "TTF" | "OTF" | "PFB"; mimeType: string; byteLength: number; sha256: string; base64: string }
  | { type: "setFontLinks"; dataId: string; links: NonMeshFontLinksIR }
  | { type: "setTextSource"; dataId: string; source: string }
  | { type: "setSoundProperties"; dataId: string; properties: { volume?: number; attenuation?: number; pitch?: number; minGain?: number; maxGain?: number; distance?: number; offsetTime?: number } }
  | { type: "setSpeakerProperties"; dataId: string; properties: { volumeMax?: number; volumeMin?: number; distanceMax?: number; distanceReference?: number; attenuation?: number; coneAngleOuter?: number; coneAngleInner?: number; coneVolumeOuter?: number; volume?: number; pitch?: number } }
  | { type: "setParticleSettings"; dataId: string; properties: { type?: number; from?: number; distribution?: number; physicsType?: number; totalParticles?: number; start?: number; end?: number; lifetime?: number; size?: number; drawSize?: number } }
  | { type: "setTextureProperties"; dataId: string; properties: { noiseScale?: number; noiseDepth?: number; intensity?: number; contrast?: number; saturation?: number } }
  | { type: "setVolumeProperties"; dataId: string; sourcePath: string; displayDensity: number; interpolation: "NEAREST" | "LINEAR"; stepSize: number; velocityGrid?: string; velocityScale?: number }
  | { type: "createGreasePencilLayer"; dataId: string; name: string }
  | { type: "removeGreasePencilLayer"; dataId: string; layerId: string }
  | { type: "moveGreasePencilLayer"; dataId: string; layerId: string; direction: "UP" | "DOWN" | "TOP" | "BOTTOM"; baseRevision?: number }
  | { type: "moveGreasePencilFrame"; dataId: string; layerId: string; frame: number; targetFrame: number; drawingId: string; baseRevision: number }
  | { type: "insertGreasePencilFrame"; dataId: string; layerId: string; frame: number; duration?: number }
  | { type: "removeGreasePencilFrame"; dataId: string; layerId: string; frame: number }
  | { type: "setGreasePencilStrokes"; dataId: string; layerId: string; frame: number; baseRevision?: number; strokes: Array<{ cyclic?: boolean; materialIndex?: number; points: Array<{ position: [number, number, number]; radius?: number; opacity?: number; vertexColor?: [number, number, number, number] }> }> }
  | { type: "setVertexColors"; meshId: string; attributeName: string; domain: "POINT" | "CORNER"; indices: number[]; colors: number[] }
  | { type: "setVertexWeights"; objectId: string; vertexGroup: string; indices: number[]; values: number[]; normalize?: boolean; limit?: number; mirror?: boolean; mirrorAxis?: 0 | 1 | 2; mirrorTolerance?: number }
  | { type: "setLightProperties"; dataId: string; properties: { type?: "POINT" | "SUN" | "SPOT" | "AREA"; areaShape?: 0 | 1 | 4 | 5; color?: [number, number, number]; energy?: number; exposure?: number; temperature?: number; useTemperature?: boolean; castsShadow?: boolean; radius?: number; spotAngle?: number; spotBlend?: number; areaSize?: number; areaSizeY?: number; areaSpread?: number; sunAngle?: number } }
  | { type: "setCameraProperties"; dataId: string; properties: { projection?: "PERSPECTIVE" | "ORTHOGRAPHIC"; lensMm?: number; sensorWidthMm?: number; sensorHeightMm?: number; sensorFit?: 0 | 1 | 2; shift?: [number, number]; near?: number; far?: number; orthoScale?: number; depthOfField?: { enabled?: boolean; focusDistance?: number; apertureFStop?: number; apertureBlades?: number; apertureRotation?: number; apertureRatio?: number } } }
  | { type: "setWorldProperties"; dataId: string; properties: { color?: [number, number, number]; exposure?: number; mist?: { enabled?: boolean; type?: "QUADRATIC" | "LINEAR" | "INVERSE_QUADRATIC"; start?: number; depth?: number; intensity?: number; height?: number } } }
  | { type: "setSceneProperties"; dataId: string; properties: { renderEngine?: string; viewTransform?: string; look?: string; exposure?: number; gamma?: number } }
  | { type: "setSceneRenderSettings"; dataId: string; properties: { resolutionX?: number; resolutionY?: number; resolutionPercentage?: number; frameStart?: number; frameEnd?: number; outputPath?: string } }
  | { type: "setSceneAudioSettings"; dataId: string; properties: { volume?: number; speedOfSound?: number; dopplerFactor?: number; distanceModel?: number; muted?: boolean; sync?: boolean } }
  | { type: "setSceneUnitSettings"; dataId: string; properties: { system?: number; scaleLength?: number; rotationSystem?: number; lengthUnit?: number; massUnit?: number; timeUnit?: number; temperatureUnit?: number } }
  | { type: "setSceneTimelineSettings"; dataId: string; properties: { fps?: number; fpsBase?: number; frameStep?: number; usePreviewRange?: boolean; previewStart?: number; previewEnd?: number } }
  | { type: "setScenePipelineSettings"; dataId: string; properties: { useCompositor?: boolean; useSequencer?: boolean; noOverwrite?: boolean; saveOutput?: boolean; alphaPremultiplied?: boolean } }
  | { type: "setSceneBindings"; dataId: string; properties: { cameraObjectId?: string | null; worldId?: string | null } }
  | { type: "setSceneViewLayerSettings"; dataId: string; layerName: string; properties: { useRender?: boolean; useFreestyle?: boolean; samples?: number } }
  | { type: "setSceneCollectionSettings"; dataId: string; layerName: string; collectionId: string; properties: { exclude?: boolean; holdout?: boolean; indirectOnly?: boolean; hide?: boolean } }
  | { type: "setSceneBorderSettings"; dataId: string; properties: { enabled?: boolean; minX?: number; maxX?: number; minY?: number; maxY?: number } }
  | { type: "setSceneSimplifySettings"; dataId: string; properties: { subsurfViewport?: number; subsurfRender?: number; particlesViewport?: number; particlesRender?: number; volumes?: number } }
  | { type: "setSceneColorManagement"; dataId: string; properties: { displayDevice?: string; temperature?: number; tint?: number } }
  | { type: "setSceneImageFormat"; dataId: string; properties: { fileType?: "PNG" | "JPEG" | "OPEN_EXR" | "TIFF" | "WEBP"; colorMode?: number; depth?: number; quality?: number; compression?: number; exrCodec?: number } }
  | { type: "setSceneMotionBlur"; dataId: string; properties: { enabled?: boolean; shutter?: number; position?: 0 | 1 | 2 } }
  | { type: "setSceneHairSettings"; dataId: string; properties: { type?: 0 | 1 | 2; subdivisions?: number } }
  | { type: "setSceneCompositorSettings"; dataId: string; properties: { device?: 0 | 1; precision?: 0 | 1; denoiseDevice?: 0 | 1 | 2; previewQuality?: 0 | 1 | 2; finalQuality?: 0 | 1 | 2 } }
  | { type: "setScenePerformanceSettings"; dataId: string; properties: { fixedThreads?: boolean; threads?: number; persistentData?: boolean; highQualityNormals?: boolean } }
  | { type: "setSceneSamplingSettings"; dataId: string; properties: { pixelAspectX?: number; pixelAspectY?: number; filterSize?: number; dither?: number } }
  | { type: "setSceneMultiviewSettings"; dataId: string; properties: { enabled?: boolean; viewsFormat?: 0 | 1; imageViewsFormat?: 0 | 1 | 2; stereoDisplayMode?: 0 | 1 | 2 | 3 | 4; interlaceSwap?: boolean; sideBySideCrossed?: boolean; squeezedFrame?: boolean } }
  | { type: "setSceneStampSettings"; dataId: string; properties: { stampMask?: number; fontId?: number; userText?: string; foreground?: [number, number, number, number]; background?: [number, number, number, number] } }
  | { type: "setSceneLineSettings"; dataId: string; properties: { mode?: 1 | 2; thickness?: number } }
  | { type: "setSceneViewLayerPassSettings"; dataId: string; layerName: string; properties: { passMask?: number; cryptomatteMask?: number; cryptomatteLevels?: number; alphaThreshold?: number } }
  | { type: "setSceneViewLayerAOVs"; dataId: string; layerName: string; aovs: Array<{ name: string; type: 0 | 1 }> }
  | { type: "setSceneViewLayerLightgroups"; dataId: string; layerName: string; lightgroups: string[] }
  | { type: "setObjectLightgroup"; objectId: string; lightgroup: string | null }
  | { type: "setWorldLightgroup"; dataId: string; lightgroup: string | null }
  | { type: "setMetaballElements"; dataId: string; elements: Array<{ type: number; position: [number, number, number]; radius: number; scale: [number, number, number] }> }
  | { type: "sculptStroke"; stroke: SculptStrokeIR }
  | { type: "setSculptMeshAttributes"; attributes: SculptMeshAttributesIR }
  | { type: "setGeometryNodeGraph"; meshId: string; graph: GeometryNodeGraphIR }
  | { type: "setPhysicsSimulation"; manifest: PhysicsSimulationManifestIR }
  | { type: "setShaderGraph"; materialId: string; graph: ShaderGraphIR }
  | { type: "setNLAStack"; objectId: string; tracks: NlaTrackIR[]; baseRevision?: number }
  | NlaMoveStripCommand
  | { type: "undo" }
  | { type: "redo" };

export type WebEngineRequest =
  | { requestId: string; command: { type: "init" } }
  | { requestId: string; command: { type: "crashForTest" } }
  | { requestId: string; command: { type: "openBlend"; buffer: ArrayBuffer }; }
  | { requestId: string; command: { type: "cancelOpen"; targetRequestId: string } }
  | { requestId: string; command: { type: "openResourceStatus" } }
  | { requestId: string; command: { type: "snapshot" } }
  | { requestId: string; command: { type: "applyCommand"; payload: WebEngineEditCommand } }
  | { requestId: string; command: { type: "appendLibraryObject"; request: LibraryMainAppendRequestIR; source: ArrayBuffer } }
  | { requestId: string; command: { type: "beginPaintStroke"; session: PaintStrokeSessionBeginIR } }
  | { requestId: string; command: { type: "appendPaintStrokeChunk"; chunk: PaintStrokeSessionChunkIR } }
  | { requestId: string; command: { type: "commitPaintStroke"; session: PaintStrokeSessionCommitIR } }
  | { requestId: string; command: { type: "cancelPaintStroke"; session: PaintStrokeSessionCancelIR } }
  | { requestId: string; command: { type: "queryPaintPBVHCapability"; request: PaintPBVHCapabilityRequest } }
  | { requestId: string; command: { type: "generateLOD"; payload: LODGenerationRequest } }
  | { requestId: string; command: { type: "delta" } }
  | { requestId: string; command: { type: "requestAsset"; assetId: string } }
  | { requestId: string; command: { type: "queryRenderCapability"; request: RenderCapabilityRequest } }
  | { requestId: string; command: { type: "queryNonMeshCapability"; dataId: string } }
  | { requestId: string; command: { type: "evaluateDepsgraph" } }
  | { requestId: string; command: { type: "saveBlend" } }
  | { requestId: string; command: { type: "shutdown" } };

export interface WebEngineStatus {
  ready: boolean;
  liveHandles: number;
  allocatedBytes: number;
}

export interface WebEngineOpenResourceStatus {
  activeRequests: number;
  liveInputBytes: number;
  liveNativeHandles: number;
  liveStagingFiles: number;
}

export interface AssetRequestResult {
  assetId: string;
  status: "external" | "packed" | "packed-unavailable" | "missing" | "blocked";
  sourcePath?: string;
  safeSourcePath?: string;
  pathStatus?: "safe" | "blocked";
  errorCode?: "ASSET_PATH_OUTSIDE_PROJECT";
  mimeType?: string;
  width?: number;
  height?: number;
  data?: ArrayBuffer;
}

export interface WebEngineLODLevelResult {
  level: number;
  meshId: string;
  triangleBudget: number;
  outputTriangleCount: number;
  outputVertexCount: number;
  simplify?: SimplifyResult;
  geometryBuffers: MeshGeometryBuffer[];
}

export interface WebEngineLODResult {
  manifest: LODManifest;
  levels: WebEngineLODLevelResult[];
  errors?: WebEngineLODError[];
}

export interface WebEngineLODError {
  requestedLevel: number;
  triangleBudget: number;
  message: string;
}

export interface WebEngineResult {
  status: WebEngineStatus;
  snapshot?: SceneSnapshotIR;
  geometryBuffers?: MeshGeometryBuffer[];
  nonMeshGeometryBuffers?: NonMeshGeometryChunk[];
  geometryDelta?: MeshGeometryDelta;
  delta?: SceneDelta;
  simplify?: SimplifyResult;
  lod?: WebEngineLODResult;
  asset?: AssetRequestResult;
  capabilityGate?: CapabilityGateResult;
  shaderCompile?: ShaderCompileReport;
  depsgraph?: DepsgraphEvaluationIR;
  blend?: ArrayBuffer;
  openResources?: WebEngineOpenResourceStatus;
  paintStrokeSession?: PaintStrokeSessionReceiptIR;
  libraryAppend?: LibraryMainAppendReceiptIR;
}

export type WebEngineResponse =
  | { kind: "progress"; requestId: string; progress: ProgressEvent }
  | { kind: "result"; requestId: string; ok: true; result: WebEngineResult }
  | { kind: "result"; requestId: string; ok: false; error: ErrorReport };