/**
 * These definitions are exported in 'index.ts'.
 * See the API reference for more details:
 *
 *     https://github.com/UmbraSoftware/umbrajs/wiki/API-reference
 *
 */

import * as Native from './NativeTypes'
import * as Assets from './Assets'
import * as UmbraMath from './Math'

export {
  ConnectionStatus,
  TextureSupportFlags,
  TextureFormat,
  TextureType,
  ColorSpace,
  DepthRange,
  MatrixFormat,
} from './NativeTypes'
export type UserPointer = Native.UserPointer
export type Pointer = Native.Pointer
export type SceneInfo = Native.SceneInfo
export { UmbraMath as Math, Assets }
export * from './Heap'
export * from './Mesh'

export interface Location {
  project: string
  model: string
}

export interface Renderable {
  id: UserPointer
  mesh: any
  lod: number
  mask: number
  scenePtr: Pointer
}

export interface Texture extends Native.TextureInfo {
  mipByteSizes: number[]
  mipByteOffsets: number[]
}

export interface NativeScene {
  connectionStatus(): Native.ConnectionStatus
  isConnected(): boolean
  setTransform(matrix: UmbraMath.Matrix4x4): void
  destroy(): void
  getInfo(): SceneInfo
  readonly ptr: Native.Pointer
}

export interface View {
  setCamera(
    worldToClip: UmbraMath.Matrix4x4,
    positionVector: UmbraMath.Vector3,
    quality: number,
    lights?: UmbraMath.Vector3[],
    depthRange?: Native.DepthRange,
    matrixFormat?: Native.MatrixFormat,
  ): void
  getVisible(batchSize: number): Renderable[]
  destroy(): void
  readonly ptr: Native.Pointer
}

export interface JobHandlers {
  LoadMaterial: (data: Assets.MaterialData, assetID: UserPointer) => Assets.AssetLoadResult
  LoadTexture: (data: Assets.TextureData, assetID: UserPointer) => Assets.AssetLoadResult
  LoadMesh: (data: Assets.MeshData, assetID: UserPointer) => Assets.AssetLoadResult
  UnloadMaterial: (asset: any, assetID: UserPointer) => void
  UnloadTexture: (asset: any, assetID: UserPointer) => void
  UnloadMesh: (asset: any, assetID: UserPointer) => void
}

export interface Runtime {
  createScene(apiKey: string, locator: string): NativeScene
  createScenePublic(publicKey: string): NativeScene
  createSceneLocal(url: string): NativeScene

  setHandlers(handlers: JobHandlers): void

  update(): void
  getAssetUnloads(): IterableIterator<Assets.Unload>
  loadAssets(timeLimit: number): void

  addAsset(assetID: UserPointer, asset: any): void
  removeAsset(assetID: UserPointer): void
  readonly assets: Map<UserPointer, any>
  getStreamingState(): Native.StreamingState
  getStreamingProgress(): number
  getNumberOfWorkers(): number

  destroy(): void
}

export interface PlatformFeatures {
  textureSupportMask: number
  formats: string[]
  srgb: boolean
  halfFloat: boolean
}

export interface RuntimeConfig {
  features: PlatformFeatures
  flags?: number
}

export interface UmbraInstance {
  getPlatformFeatures(gl: WebGLRenderingContext): PlatformFeatures
  getStreamingInfo(): {
    minBytesDownloaded: number
    maxBytesDownloaded: number
  }
  getLibraryInfo(): {
    version: string
    copyright: string
    buildTime: string
    buildID: string
  }
  createRuntime(config: RuntimeConfig): Runtime
  abortDownloads(): void
}