export interface Camera {
  dir: vec4;
  U: vec4;
  V: vec4;
  eye: vec4;
  l: number;
  fov: number;
}

export interface SortTypeValue {
  value: number;
}

export interface TextureFormatValue {
  value: number;
}

export interface SharkRenderInfo {
  triangles: number;
}

export interface SharkInfo {
  renderCalls: number;
  render: SharkRenderInfo;
  reset(): void;
}

export interface RendererWGPU {
  getProgramCount(): number;
  getTextureCount(): number;
  getEstimatedTextureSize(): number;
  getTotalBufferSize(): number;
  info: SharkInfo;
}

export interface RenderState {
  initRenderState(
    renderer: RendererWGPU,
    width: number,
    height: number,
    vertices: number,
    splats: number,
    cubes: number,
    sortThreads: number,
    sortGroupSize: number,
    sortKeySize: number,
  ): void;
  initGraphicsState(
    width: number,
    height: number,
    renderTextureFormat: TextureFormatValue,
    depthTextureFormat: TextureFormatValue,
  ): void;
  updateRenderDetails(
    width: number,
    height: number,
    splatTriangles: number,
  ): void;
}

export interface vec4 {
  x: number;
  y: number;
  z: number;
  w: number;
  delete(): void;
}

export interface SplatSet {
  splatCount: number;
  // Number of splats actually drawn: ordering[0, activeSplats) holds the unmasked splat indices.
  // Set alongside orderingView() to restrict the draw to unmasked octant ranges.
  activeSplats: number;
  // Selects which ellipsoid layout to allocate and what ellipsoidsView() exposes:
  // packed (16 bytes/splat) or uncompressed (48). Must be set before the first resize.
  usePackedEllipsoids: boolean;
  // direct-write upload: resize -> write into the views -> finalize.
  // views are valid only until the next resize.
  resize(splatCount: number): void;
  ellipsoidsView(): Uint32Array;
  colorsView(): Uint32Array;
  sh1View(): Uint32Array;
  sh2View(): Uint32Array;
  sh3aView(): Uint32Array;
  sh3bView(): Uint32Array;
  // Per-chunk fade (opacity multiplier), one float per chunk, defaults to 1.0.
  // Also sizes the chunk slot to model root slot map below, since both are indexed by chunk slot
  resizeChunkFades(chunkCount: number): void;
  chunkFadesView(): Float32Array;
  // Per-splat chunk index, defaults to slot 0. Write before finalize()
  chunkIndicesView(): Int32Array;
  // Model transforms, resolved per splat as
  //   modelRootTransforms[chunkModelRoots[chunkIndices[splat]]]
  // Slot 0 of both tables is reserved as identity, so real slots start at 1 and a set that
  // never writes them renders untransformed.
  resizeModelRootSlots(modelRootCount: number): void;
  // 16 floats per model root, COLUMN-major - i.e. write THREE's Matrix4.toArray() straight in
  modelRootTransformsView(): Float32Array;
  // The inverses, same slots and layout. The true-perspective projection (Project.glsl) transforms
  // a quadratic form and needs them; writing a transform without its inverse leaves that path
  // projecting the splat as if untransformed. Use Matrix4.invert() on a copy
  modelRootInverseTransformsView(): Float32Array;
  // Sized by resizeChunkFades. Defaults to slot 0 (identity) for every chunk
  chunkModelRootsView(): Int32Array;
  // int32 render-order buffer (sized 2*splatCount after finalize). Valid only until the next resize.
  orderingView(): Int32Array;
  finalize(): void;
  // like finalize() but keeps splats in their delivered (octant-sorted) order — no kd-tree reorder —
  // so sparse-octant range masking can index child-octant ranges directly. RADIX_SORT only.
  finalizeBounds(): void;
}

export interface WebGPUInterface {
  importJsAdapter(adapter: GPUAdapter, parentPtr?: number): number;
  importJsDevice(device: GPUDevice, parentPtr?: number): number;
  importJsTexture(obj: GPUTexture, parentPtr?: number): number;
}

export interface MainModule {
  Camera: new () => Camera;
  RenderState: new () => RenderState;
  SplatSet: new () => SplatSet;
  vec4: new (x: number, y: number, z: number, w: number) => vec4;

  SortType: {
    RADIX_SORT: SortTypeValue;
    OCTREE_SORT: SortTypeValue;
    KDTREE_SORT: SortTypeValue;
    STD_SORT: SortTypeValue;
  };

  TextureFormat: {
    RGBA32_Float: TextureFormatValue;
    RGBA16_Float: TextureFormatValue;
    RG16_Float: TextureFormatValue;
    RGBA32_UInt: TextureFormatValue;
    RGBA32_SInt: TextureFormatValue;
    RGBA16_UInt: TextureFormatValue;
    RGBA16_SInt: TextureFormatValue;
    RGBA8_UInt: TextureFormatValue;
    RGBA8_SInt: TextureFormatValue;
    RGBA8_UNorm: TextureFormatValue;
    RGBA8_SNorm: TextureFormatValue;
    RGBA16_UNorm: TextureFormatValue;
    RGBA16_SNorm: TextureFormatValue;
    BGRA8_UNorm: TextureFormatValue;
    BC6HRGB_UFloat: TextureFormatValue;
    BC6HRGB_Float: TextureFormatValue;
    BC7RGBA_UNorm: TextureFormatValue;
    BC7RGBA_UNormSrgb: TextureFormatValue;
    BC3RGBA_UNorm: TextureFormatValue;
    BC3RGBA_UNormSrgb: TextureFormatValue;
    Depth16Unorm: TextureFormatValue;
    Depth24Plus: TextureFormatValue;
    Depth32Float: TextureFormatValue;
  };

  WebGPU: WebGPUInterface;

  uploadSplatSetData(
    set: SplatSet,
    renderState: RenderState,
    start: number,
  ): void;
  uploadChunkFades(set: SplatSet, renderState: RenderState): void;
  // One mat4 per model root, so cheap enough to call every frame while an asset is moving
  uploadModelRootTransforms(set: SplatSet, renderState: RenderState): void;
  processSplatSet(
    camera: Camera,
    set: SplatSet,
    renderState: RenderState,
    width: number,
    height: number,
    triangles: number,
    projectOnGPU: boolean,
    cullEllipsoid: boolean,
    useAffineApprox: boolean,
    depthSortOnGPU: boolean,
    useInvZ: boolean,
    rasterizeWithCompute: boolean,
    useSOGS: boolean,
    sortType: SortTypeValue,
    skipSort: boolean,
  ): number;
  createRendererWGPUWithoutSurface(
    colorTargetFormat: TextureFormatValue,
  ): RendererWGPU;
  renderSplatSetToSceneTextures(
    splatSet: SplatSet,
    renderState: RenderState,
    colorTarget: number,
    depthTarget: number,
    renderGES: boolean,
  ): void;
}

declare function WebShark(
  moduleArg?: Record<string, unknown>,
): Promise<MainModule>;

export default WebShark;