import * as Native from './NativeTypes'
import { Pointer, ElementBuffer } from './NativeTypes'
import { UmbraFunctions } from './NativeFunctions'
import { TextureFormat, AssetLoadResult } from './NativeEnums'
import { Vector3 } from './Math'
import { Assets } from './PublicAPI'
import { MeshAttributes } from './Mesh'
import { LibraryConfig } from '.'

// Type definitions for Emscripten from https://github.com/DefinitelyTyped/DefinitelyTyped

type EnvironmentType = 'WEB' | 'NODE' | 'SHELL' | 'WORKER'
type ValueType = 'number' | 'string' | 'array' | 'boolean'
type TypeCompatibleWithC = number | string | any[] | boolean

type WebAssemblyImports = Array<{
  name: string
  kind: string
}>

type WebAssemblyExports = Array<{
  module: string
  name: string
  kind: string
}>

interface CCallOpts {
  async?: boolean
}

// A generic Emscripten module definition

interface EmscriptenModule {
  print(str: string): void
  printErr(str: string): void
  arguments: string[]
  environment: EnvironmentType
  preInit: Array<{ (): void }>
  preRun: Array<{ (): void }>
  postRun: Array<{ (): void }>
  onAbort: { (what: any): void }
  onRuntimeInitialized: { (): void }
  preinitializedWebGLContext: WebGLRenderingContext
  noInitialRun: boolean
  noExitRuntime: boolean
  logReadFiles: boolean
  filePackagePrefixURL: string
  wasmBinary: ArrayBuffer

  destroy(object: object): void
  getPreloadedPackage(remotePackageName: string, remotePackageSize: number): ArrayBuffer
  instantiateWasm(
    imports: WebAssemblyImports,
    successCallback: (module: WebAssembly.Module) => void,
  ): WebAssemblyExports
  locateFile(url: string): string
  onCustomMessage(event: MessageEvent): void

  Runtime: any

  ccall(
    ident: string,
    returnType: ValueType | null,
    argTypes: ValueType[],
    args: TypeCompatibleWithC[],
    opts?: CCallOpts,
  ): any
  cwrap(
    ident: string,
    returnType: ValueType | null,
    argTypes: ValueType[],
    opts?: CCallOpts,
  ): (...args: any[]) => any

  setValue(ptr: number, value: any, type: string, noSafe?: boolean): void
  getValue(ptr: number, type: string, noSafe?: boolean): number

  ALLOC_NORMAL: number
  ALLOC_STACK: number
  ALLOC_STATIC: number
  ALLOC_DYNAMIC: number
  ALLOC_NONE: number

  allocate(slab: any, types: string | string[], allocator: number, ptr: number): number

  // USE_TYPED_ARRAYS == 1
  HEAP: Int32Array
  IHEAP: Int32Array
  FHEAP: Float64Array

  // USE_TYPED_ARRAYS == 2
  HEAP8: Int8Array
  HEAP16: Int16Array
  HEAP32: Int32Array
  HEAPU8: Uint8Array
  HEAPU16: Uint16Array
  HEAPU32: Uint32Array
  HEAPF32: Float32Array
  HEAPF64: Float64Array

  TOTAL_STACK: number
  TOTAL_MEMORY: number
  FAST_MEMORY: number

  addOnPreRun(cb: () => any): void
  addOnInit(cb: () => any): void
  addOnPreMain(cb: () => any): void
  addOnExit(cb: () => any): void
  addOnPostRun(cb: () => any): void

  // Tools
  intArrayFromString(stringy: string, dontAddNull?: boolean, length?: number): number[]
  intArrayToString(array: number[]): string
  writeStringToMemory(str: string, buffer: number, dontAddNull: boolean): void
  writeArrayToMemory(array: number[], buffer: number): void
  writeAsciiToMemory(str: string, buffer: number, dontAddNull: boolean): void

  addRunDependency(id: any): void
  removeRunDependency(id: any): void

  preloadedImages: any
  preloadedAudios: any

  umbraAlloc(size: number): number
  umbraFree(ptr: number): void
}

// Our own definitions begin here

export interface NativeModule extends EmscriptenModule, UmbraFunctions {
  wgetRequests: any // Actually an object with XMLHTTPRequests as values

  readonly umbraLibraryConfig: LibraryConfig // Configuration passed in to initUmbra()

  readonly maxBytesDownloaded: number
  readonly minBytesDownloaded: number

  readonly meshInfoSize: number
  readonly textureInfoSize: number
  readonly materialInfoSize: number
  readonly renderableSize: number
  readonly elementBufferSize: number
  readonly byteBufferSize: number
  readonly sceneInfoSize: number
  readonly streamingStateSize: number
  readonly meshLoadDispatchHeaderSize: number
  readonly meshLoadResultHeaderSize: number
  readonly textureLoadDispatchHeaderSize: number
  readonly textureLoadResultHeaderSize: number

  readonly INVALID_USERPOINTER: Native.UserPointer
  readonly CONFIG_SIZE: number

  _exit(code: number): void

  convertGeodeticToEcef(geodeticCoord: Vector3): Vector3
  convertEcefToGeodetic(ecefCoord: Vector3): Vector3

  // Serialization

  serializeElementBuffer(buffer: Native.ElementBuffer, outPtr: Pointer): Pointer
  deserializeElementBuffer(ptr: Pointer): Native.ElementBuffer

  serializeByteBuffer(buffer: Native.ByteBuffer, outPtr: Pointer): Pointer

  deserializeMeshInfo(meshInfoPtr: Pointer): Native.MeshInfo
  deserializeMaterialInfo(meshInfoPtr: Pointer): Native.MaterialInfo
  deserializeTextureInfo(meshInfoPtr: Pointer): Native.TextureInfo
  serializeEnvironmentInfo(
    info: {
      textureSupportFlags: number
      localCacheDirectory: string
      localCacheMaximumByteSize: number
    },
    outPtr: Pointer,
  ): Pointer
  deserializeSceneInfo(sceneInfoPtr: Pointer): any // Actually of type API.SceneInfo
  deserializeStreamingState(statePtr: Pointer): Native.StreamingState
  textureLoadSerialize(assetLoad: Pointer, bufferPtr: Pointer): boolean
  meshLoadSerialize(assetLoad: Pointer, bufferPtr: Pointer): boolean

  // TODO give the return value type a name
  meshLoadResultBuildUmbraBuffers(
    meshLoadPtr: Pointer,
    basePtr: Pointer,
  ): {
    position: ElementBuffer
    index: ElementBuffer
    uv?: ElementBuffer
    normal?: ElementBuffer
    tangent?: ElementBuffer
  }

  meshLoadFinishExternalWithLoadResultHeader(
    meshLoad: Pointer,
    meshLoadResultPtr: Pointer,
    basePtr: number,
  ): void

  umbraAlloc(numBytes: number): Pointer
  umbraFree(ptr: Pointer)

  deserializeMeshLoadResult(
    result: Pointer,
  ): {
    result: AssetLoadResult
    assetLoad: Pointer
    runtimeMesh: Pointer
    pipelineMem: number
  }

  deserializeTextureLoadResult(
    result: Pointer,
  ): {
    result: AssetLoadResult
    assetLoad: Pointer
    textureInfo: Native.TextureInfo
    pipelineMem: number
  }

  convertAssetLoadToMeshDispatch(
    assetLoad: Pointer,
    userPointer: Native.UserPointer,
    outBufPtr: Pointer,
    outBufSize: number,
  ): any

  convertAssetLoadToTextureDispatch(
    assetLoadPtr: Pointer,
    userPointer: Native.UserPointer,
    textureSupportFlags: number,
    supportsSRGB: boolean,
    outBufPtr: Pointer,
    outBufSize: number,
  ): {} | undefined

  // Returns member offsets of the UmbraRenderable struct
  getRenderableMemberOffsets(): {
    mesh: number
    lodLevel: number
    visibilityMask: number
    transform: number
    scene: number
  }

  // Texture transcoding

  downsampleAndTranscodeTexture(
    inputFormat: TextureFormat,
    outputFormat: TextureFormat,
    width: number,
    height: number,
    data: Pointer,
    byteSize: number,
    outBuffer: Pointer,
    outBufferSize: number,
  ): Native.TranscodeResult

  getTextureByteSize(width: number, height: number, format: TextureFormat): number

  getUncompressedFromBCFormat(format: TextureFormat): TextureFormat
}

export type EmscriptenHeapName =
  | 'HEAP8'
  | 'HEAP16'
  | 'HEAP32'
  | 'HEAPU8'
  | 'HEAPU16'
  | 'HEAPU32'
  | 'HEAPF32'
  | 'HEAPF64'