import arrayEqual from 'array-equal'
import { mat4, vec3, vec4 } from 'gl-matrix'

// TODO: TypedNumberArray also in nvmesh-types.ts
type TypedNumberArray =
  | Float64Array
  | Float32Array
  | Uint32Array
  | Uint16Array
  | Uint8Array
  | Int32Array
  | Int16Array
  | Int8Array

/**
 * Namespace for utility functions
 * @ignore
 */

/**
 * Read ZIP files using asynchronous compression streams API, supports data descriptors
 * todo: check ZIP64 support
 * https://github.com/libyal/assorted/blob/main/documentation/ZIP%20archive%20format.asciidoc
 * https://en.wikipedia.org/wiki/ZIP_(file_format)
 * https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT
 * https://dev.to/ndesmic/writing-a-simple-browser-zip-file-decompressor-with-compressionstreams-5che
 */

interface Entry {
  signature: string
  version: number
  generalPurpose: number
  compressionMethod: number
  lastModifiedTime: number
  lastModifiedDate: number
  crc: number
  compressedSize: number
  uncompressedSize: number
  fileNameLength: number
  extraLength: number
  fileName: string
  extra: string
  startsAt?: number
  extract?: () => Promise<Uint8Array>
}

interface CentralDirectoryEntry {
  versionCreated: number
  versionNeeded: number
  fileCommentLength: number
  diskNumber: number
  internalAttributes: number
  externalAttributes: number
  offset: number
  comments: string
  fileNameLength: number
  extraLength: number
}

interface EndOfCentralDirectory {
  numberOfDisks: number
  centralDirectoryStartDisk: number
  numberCentralDirectoryRecordsOnThisDisk: number
  numberCentralDirectoryRecords: number
  centralDirectorySize: number
  centralDirectoryOffset: number
  commentLength: number
  comment: string
}

export class Zip {
  #dataView: DataView
  #index: number = 0
  #localFiles: Entry[] = []
  #centralDirectories: CentralDirectoryEntry[] = []
  #endOfCentralDirectory?: EndOfCentralDirectory

  constructor(arrayBuffer: ArrayBuffer) {
    this.#dataView = new DataView(arrayBuffer)
    this.read()
  }

  async extract(entry: Entry): Promise<Uint8Array> {
    const buffer = new Uint8Array(this.#dataView.buffer.slice(entry.startsAt!, entry.startsAt! + entry.compressedSize))
    if (entry.compressionMethod === 0x00) {
      return buffer
    } else if (entry.compressionMethod === 0x08) {
      const stream = new DecompressionStream('deflate-raw')
      const writer = stream.writable.getWriter()
      writer.write(buffer).catch(console.error)
      const closePromise = writer.close().catch(console.error)
      const response = new Response(stream.readable)
      const result = new Uint8Array(await response.arrayBuffer())
      await closePromise
      return result
    }
    throw new Error(`Unsupported compression method: ${entry.compressionMethod}`)
  }

  private read(): void {
    while (!this.#endOfCentralDirectory && this.#index < this.#dataView.byteLength) {
      const signature = this.#dataView.getUint32(this.#index, true)
      if (signature === 0x04034b50) {
        const entry = this.readLocalFile(this.#index)
        entry.extract = this.extract.bind(this, entry)
        this.#localFiles.push(entry)
        const hasDataDescriptor = (entry.generalPurpose & 0x0008) !== 0
        entry.startsAt = this.#index + 30 + entry.fileNameLength + entry.extraLength
        if (entry.compressedSize === 0 && hasDataDescriptor) {
          let scanIndex = entry.startsAt
          while (scanIndex! + 20 <= this.#dataView.byteLength) {
            const possibleSignature = this.#dataView.getUint32(scanIndex!, true)
            if (possibleSignature === 0x08074b50) {
              const nextPK = this.#dataView.getUint16(scanIndex! + 16, true) === 0x4b50
              if (nextPK) {
                scanIndex! += 4
                break
              }
            }
            scanIndex!++
          }
          entry.crc = this.#dataView.getUint32(scanIndex!, true)
          entry.compressedSize = this.#dataView.getUint32(scanIndex! + 4, true)
          entry.uncompressedSize = this.#dataView.getUint32(scanIndex! + 8, true)
          this.#index = scanIndex! + 12
        } else {
          this.#index = entry.startsAt + entry.compressedSize
        }
      } else if (signature === 0x02014b50) {
        const entry = this.readCentralDirectory(this.#index)
        this.#centralDirectories.push(entry)
        this.#index += 46 + entry.fileNameLength + entry.extraLength + entry.fileCommentLength
      } else if (signature === 0x06054b50) {
        this.#endOfCentralDirectory = this.readEndCentralDirectory(this.#index)
        break
      } else if (signature === 0x06064b50) {
        this.#endOfCentralDirectory = this.readEndCentralDirectory64(this.#index)
        break
      } else {
        console.error(`Unexpected ZIP signature 0x${signature.toString(16).padStart(8, '0')} at index ${this.#index}`)
        break
      }
    }
  }

  private readLocalFile(offset: number): Entry {
    let compressedSize = this.#dataView.getUint32(offset + 18, true)
    let uncompressedSize = this.#dataView.getUint32(offset + 22, true)
    const fileNameLength = this.#dataView.getUint16(offset + 26, true)
    const extraLength = this.#dataView.getUint16(offset + 28, true)
    const extraOffset = offset + 30 + fileNameLength
    const extra = this.readString(extraOffset, extraLength)
    if (compressedSize === 0xffffffff && uncompressedSize === 0xffffffff) {
      let zip64Offset = extraOffset
      let foundZip64 = false
      while (zip64Offset < extraOffset + extraLength - 4) {
        const fieldSignature = this.#dataView.getUint16(zip64Offset, true)
        const fieldLength = this.#dataView.getUint16(zip64Offset + 2, true)
        zip64Offset += 4 // Move past signature and length
        if (fieldSignature === 0x0001) {
          // ZIP64 Extended Information Extra Field
          if (fieldLength >= 16) {
            // Ensure we have enough bytes
            uncompressedSize = Number(this.#dataView.getBigUint64(zip64Offset, true))
            zip64Offset += 8
            compressedSize = Number(this.#dataView.getBigUint64(zip64Offset, true))
            foundZip64 = true
            break
          } else {
            throw new Error(
              `ZIP64 extra field found but is too small (expected at least 16 bytes, got ${fieldLength}).`
            )
          }
        }
        zip64Offset += fieldLength // Move to the next extra field
      }
      if (!foundZip64) {
        throw new Error('ZIP64 format missing extra field with signature 0x0001.')
      }
    }
    return {
      signature: this.readString(offset, 4),
      version: this.#dataView.getUint16(offset + 4, true),
      generalPurpose: this.#dataView.getUint16(offset + 6, true),
      compressionMethod: this.#dataView.getUint16(offset + 8, true),
      lastModifiedTime: this.#dataView.getUint16(offset + 10, true),
      lastModifiedDate: this.#dataView.getUint16(offset + 12, true),
      crc: this.#dataView.getUint32(offset + 14, true),
      compressedSize,
      uncompressedSize,
      fileNameLength,
      extraLength,
      fileName: this.readString(offset + 30, fileNameLength),
      extra: this.readString(offset + 30 + fileNameLength, extraLength)
    }
  }

  private readCentralDirectory(offset: number): CentralDirectoryEntry {
    return {
      versionCreated: this.#dataView.getUint16(offset + 4, true),
      versionNeeded: this.#dataView.getUint16(offset + 6, true),
      fileNameLength: this.#dataView.getUint16(offset + 28, true),
      extraLength: this.#dataView.getUint16(offset + 30, true),
      fileCommentLength: this.#dataView.getUint16(offset + 32, true),
      diskNumber: this.#dataView.getUint16(offset + 34, true),
      internalAttributes: this.#dataView.getUint16(offset + 36, true),
      externalAttributes: this.#dataView.getUint32(offset + 38, true),
      offset: this.#dataView.getUint32(offset + 42, true),
      comments: this.readString(offset + 46, this.#dataView.getUint16(offset + 32, true))
    }
  }

  private readEndCentralDirectory(offset: number): EndOfCentralDirectory {
    const commentLength = this.#dataView.getUint16(offset + 20, true)
    return {
      numberOfDisks: this.#dataView.getUint16(offset + 4, true),
      centralDirectoryStartDisk: this.#dataView.getUint16(offset + 6, true),
      numberCentralDirectoryRecordsOnThisDisk: this.#dataView.getUint16(offset + 8, true),
      numberCentralDirectoryRecords: this.#dataView.getUint16(offset + 10, true),
      centralDirectorySize: this.#dataView.getUint32(offset + 12, true),
      centralDirectoryOffset: this.#dataView.getUint32(offset + 16, true),
      commentLength,
      comment: this.readString(offset + 22, commentLength)
    }
  }

  private readEndCentralDirectory64(offset: number): EndOfCentralDirectory {
    const commentLength = Number(this.#dataView.getBigUint64(offset + 0, true))
    return {
      numberOfDisks: this.#dataView.getUint32(offset + 16, true),
      centralDirectoryStartDisk: this.#dataView.getUint32(offset + 20, true),
      numberCentralDirectoryRecordsOnThisDisk: Number(this.#dataView.getBigUint64(offset + 24, true)),
      numberCentralDirectoryRecords: Number(this.#dataView.getBigUint64(offset + 32, true)),
      centralDirectorySize: Number(this.#dataView.getBigUint64(offset + 40, true)),
      centralDirectoryOffset: Number(this.#dataView.getBigUint64(offset + 48, true)),
      commentLength,
      comment: ''
    }
  }

  private readString(offset: number, length: number): string {
    return Array.from({ length }, (_, i) => String.fromCharCode(this.#dataView.getUint8(offset + i))).join('')
  }

  get entries(): Entry[] {
    return this.#localFiles
  }
}

export class NVUtilities {
  static arrayBufferToBase64(arrayBuffer: ArrayBuffer): string {
    const bytes = new Uint8Array(arrayBuffer)
    return NVUtilities.uint8tob64(bytes)
  }

  static async decompress(data: Uint8Array): Promise<Uint8Array> {
    const format =
      data[0] === 31 && data[1] === 139 && data[2] === 8
        ? 'gzip'
        : data[0] === 120 && (data[1] === 1 || data[1] === 94 || data[1] === 156 || data[1] === 218)
          ? 'deflate'
          : 'deflate-raw'
    const stream = new DecompressionStream(format)
    const writer = stream.writable.getWriter()
    writer.write(data).catch(console.error) // Do not await this
    // Close without awaiting directly, preventing the hang issue
    const closePromise = writer.close().catch(console.error)
    const response = new Response(stream.readable)
    const result = new Uint8Array(await response.arrayBuffer())
    await closePromise // Ensure close happens eventually
    return result
  }

  static async decompressToBuffer(data: Uint8Array): Promise<ArrayBuffer> {
    const decompressed = await NVUtilities.decompress(data)
    return decompressed.buffer.slice(decompressed.byteOffset, decompressed.byteOffset + decompressed.byteLength)
  }

  static async readMatV4(
    buffer: ArrayBuffer,
    isReplaceDots: boolean = false
  ): Promise<Record<string, TypedNumberArray>> {
    let len = buffer.byteLength
    if (len < 40) {
      throw new Error('File too small to be MAT v4: bytes = ' + buffer.byteLength)
    }
    let reader = new DataView(buffer)
    let magic = reader.getUint16(0, true)
    let _buffer = buffer
    if (magic === 35615 || magic === 8075) {
      // gzip signature 0x1F8B in little and big endian
      const raw = await this.decompress(new Uint8Array(buffer))
      reader = new DataView(raw.buffer)
      magic = reader.getUint16(0, true)
      _buffer = raw.buffer
      len = _buffer.byteLength
    }
    const textDecoder = new TextDecoder('utf-8')
    const bytes = new Uint8Array(_buffer)
    let pos = 0
    const mat: Record<string, TypedNumberArray> = {}
    function getTensDigit(v: number): number {
      return Math.floor(v / 10) % 10
    }
    function readArray(tagDataType: number, tagBytesStart: number, tagBytesEnd: number): TypedNumberArray {
      const byteArray = new Uint8Array(bytes.subarray(tagBytesStart, tagBytesEnd))
      if (tagDataType === 1) {
        return new Float32Array(byteArray.buffer)
      }
      if (tagDataType === 2) {
        return new Int32Array(byteArray.buffer)
      }
      if (tagDataType === 3) {
        return new Int16Array(byteArray.buffer)
      }
      if (tagDataType === 4) {
        return new Uint16Array(byteArray.buffer)
      }
      if (tagDataType === 5) {
        return new Uint8Array(byteArray.buffer)
      }
      return new Float64Array(byteArray.buffer)
    }
    function readTag(): void {
      const mtype = reader.getUint32(pos, true)
      const mrows = reader.getUint32(pos + 4, true)
      const ncols = reader.getUint32(pos + 8, true)
      const imagf = reader.getUint32(pos + 12, true)
      const namlen = reader.getUint32(pos + 16, true)
      pos += 20 // skip header
      if (imagf !== 0) {
        throw new Error('Matlab V4 reader does not support imaginary numbers')
      }
      const tagArrayItems = mrows * ncols
      if (tagArrayItems < 1) {
        throw new Error('mrows * ncols must be greater than one')
      }
      const byteArray = new Uint8Array(bytes.subarray(pos, pos + namlen))
      let tagName = textDecoder.decode(byteArray).trim().replaceAll('\x00', '')
      // n.b. DSI studio have array mat.dti_fa[] and mat.dti_fa.slope
      if (isReplaceDots) {
        // kludge for invalid DSIstudio FZ files
        tagName = tagName.replaceAll('.', '_')
      }
      const tagDataType = getTensDigit(mtype)
      // 0 double-precision (64-bit) floating-point numbers
      // 1 single-precision (32-bit) floating-point numbers
      // 2 32-bit signed integers
      // 3 16-bit signed integers
      // 4 16-bit unsigned integers
      // 5 8-bit unsigned integers
      let tagBytesPerItem = 8
      if (tagDataType >= 1 && tagDataType <= 2) {
        tagBytesPerItem = 4
      } else if (tagDataType >= 3 && tagDataType <= 4) {
        tagBytesPerItem = 2
      } else if (tagDataType === 5) {
        tagBytesPerItem = 1
      } else if (tagDataType !== 0) {
        throw new Error('impossible Matlab v4 datatype')
      }
      pos += namlen // skip name
      if (mtype > 50) {
        throw new Error('Does not appear to be little-endian V4 Matlab file')
      }
      const posEnd = pos + tagArrayItems * tagBytesPerItem
      mat[tagName] = readArray(tagDataType, pos, posEnd)
      pos = posEnd
    }
    while (pos + 20 < len) {
      readTag()
    }
    return mat
  } // readMatV4()

  static b64toUint8(base64: string): Uint8Array {
    const binaryString = atob(base64)
    const length = binaryString.length
    const bytes = new Uint8Array(length)
    for (let i = 0; i < length; i++) {
      bytes[i] = binaryString.charCodeAt(i)
    }
    return bytes
  }

  /*
https://gist.github.com/jonleighton/958841
MIT LICENSE
Copyright 2011 Jon Leighton
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
  static uint8tob64(bytes: Uint8Array): string {
    // TODO: use TextDecoder instead of shipping own implementation

    let base64 = ''
    const encodings = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
    const byteLength = bytes.byteLength
    const byteRemainder = byteLength % 3
    const mainLength = byteLength - byteRemainder

    let a, b, c, d
    let chunk

    // Main loop deals with bytes in chunks of 3
    for (let i = 0; i < mainLength; i = i + 3) {
      // Combine the three bytes into a single integer
      chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2]

      // Use bitmasks to extract 6-bit segments from the triplet
      a = (chunk & 16515072) >> 18 // 16515072 = (2^6 - 1) << 18
      b = (chunk & 258048) >> 12 // 258048   = (2^6 - 1) << 12
      c = (chunk & 4032) >> 6 // 4032     = (2^6 - 1) << 6
      d = chunk & 63 // 63       = 2^6 - 1

      // Convert the raw binary segments to the appropriate ASCII encoding
      base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d]
    }

    // Deal with the remaining bytes and padding
    if (byteRemainder === 1) {
      chunk = bytes[mainLength]

      a = (chunk & 252) >> 2 // 252 = (2^6 - 1) << 2

      // Set the 4 least significant bits to zero
      b = (chunk & 3) << 4 // 3   = 2^2 - 1

      base64 += encodings[a] + encodings[b] + '=='
    } else if (byteRemainder === 2) {
      chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1]

      a = (chunk & 64512) >> 10 // 64512 = (2^6 - 1) << 10
      b = (chunk & 1008) >> 4 // 1008  = (2^6 - 1) << 4

      // Set the 2 least significant bits to zero
      c = (chunk & 15) << 2 // 15    = 2^4 - 1

      base64 += encodings[a] + encodings[b] + encodings[c] + '='
    }

    return base64
  }

  // https://stackoverflow.com/questions/34156282/how-do-i-save-json-to-local-text-file
  static download(content: string | ArrayBuffer, fileName: string, contentType: string): void {
    const a = document.createElement('a')
    const contentArray = Array.isArray(content) ? content : [content]
    const file = new Blob(contentArray, { type: contentType })
    a.href = URL.createObjectURL(file)
    a.download = fileName
    a.click()
  }

  static readFileAsync(file: Blob): Promise<ArrayBuffer> {
    return new Promise((resolve, reject) => {
      const reader = new FileReader()
      reader.onload = (): void => {
        resolve(reader.result as ArrayBuffer)
      }

      reader.onerror = reject

      reader.readAsArrayBuffer(file)
    })
  }

  static blobToBase64(blob: Blob): Promise<string> {
    return new Promise((resolve) => {
      const reader = new FileReader()
      reader.onloadend = (): void => resolve(reader.result as string)
      reader.readAsDataURL(blob)
    })
  }

  static async decompressBase64String(base64: string): Promise<string> {
    const compressed = atob(base64)
    // convert to an array buffer
    const compressedBuffer = new ArrayBuffer(compressed.length)
    const compressedView = new Uint8Array(compressedBuffer)
    for (let i = 0; i < compressed.length; i++) {
      compressedView[i] = compressed.charCodeAt(i)
    }
    return NVUtilities.decompressArrayBuffer(compressedView)
  }

  static async compressToBase64String(string: string): Promise<string> {
    const buf = await NVUtilities.compressStringToArrayBuffer(string)
    return NVUtilities.uint8tob64(new Uint8Array(buf))
  }

  /**
   * Converts a string into a Uint8Array for use with compression/decompression methods (101arrowz/fflate: MIT License)
   * @param str The string to encode
   * @param latin1 Whether or not to interpret the data as Latin-1. This should
   *               not need to be true unless decoding a binary string.
   * @returns The string encoded in UTF-8/Latin-1 binary
   */

  static strToU8(str: string, latin1?: boolean): Uint8Array {
    if (latin1) {
      const ar = new Uint8Array(str.length)
      for (let i = 0; i < str.length; ++i) {
        ar[i] = str.charCodeAt(i)
      }
      return ar
    }
    const l = str.length
    // TODO: strToU8 and strFromU8 both define slc
    // typed array slice - allows garbage collector to free original reference,
    // while being more compatible than .slice
    const slc = (v: Uint8Array, s: number, e?: number): Uint8Array => {
      if (s == null || s < 0) {
        s = 0
      }
      if (e == null || e > v.length) {
        e = v.length
      }
      // can't use .constructor in case user-supplied
      return new Uint8Array(v.subarray(s, e))
    }
    let ar = new Uint8Array(str.length + (str.length >> 1))
    let ai = 0
    const w = (v: number): void => {
      ar[ai++] = v
    }
    for (let i = 0; i < l; ++i) {
      if (ai + 5 > ar.length) {
        const n = new Uint8Array(ai + 8 + ((l - i) << 1))
        n.set(ar)
        ar = n
      }
      let c = str.charCodeAt(i)
      if (c < 128 || latin1) {
        w(c)
      } else if (c < 2048) {
        w(192 | (c >> 6))
        w(128 | (c & 63))
      } else if (c > 55295 && c < 57344) {
        c = (65536 + (c & (1023 << 10))) | (str.charCodeAt(++i) & 1023)
        w(240 | (c >> 18))
        w(128 | ((c >> 12) & 63))
        w(128 | ((c >> 6) & 63))
        w(128 | (c & 63))
      } else {
        c = (65536 + (c & (1023 << 10))) | (str.charCodeAt(++i) & 1023)
        w(240 | (c >> 18))
        w(128 | ((c >> 12) & 63))
        w(128 | ((c >> 6) & 63))
        w(128 | (c & 63))
      }
    }
    return slc(ar, 0, ai)
  }

  static async compress(data: Uint8Array, format: CompressionFormat = 'gzip'): Promise<ArrayBuffer> {
    // mimics fflate, use 'deflate-raw' 'deflate' or 'gzip' if needed
    // const format = 'deflate-raw'
    const stream = new CompressionStream(format)
    const writer = stream.writable.getWriter()

    writer.write(data).catch(console.error) // Do not await this
    const closePromise = writer.close().catch(console.error)

    const response = new Response(stream.readable)
    const result = await response.arrayBuffer()

    await closePromise // Ensure close happens eventually
    return result
  }

  static async compressStringToArrayBuffer(input: string): Promise<ArrayBuffer> {
    const uint8Array = this.strToU8(input)
    return await this.compress(uint8Array)
  }

  static isArrayBufferCompressed(buffer: ArrayBuffer): boolean {
    if (buffer && buffer.byteLength) {
      const arr = new Uint8Array(buffer)
      const magicNumber = (arr[0] << 8) | arr[1]
      return magicNumber === 0x1f8b
    } else {
      return false
    }
  }

  /**
   * Converts a Uint8Array to a string (101arrowz/fflate: MIT License)
   * @param dat The data to decode to string
   * @param latin1 Whether or not to interpret the data as Latin-1. This should
   *               not need to be true unless encoding to binary string.
   * @returns The original UTF-8/Latin-1 string
   */
  static strFromU8(dat: Uint8Array, latin1?: boolean): string {
    if (latin1) {
      let r = ''
      for (let i = 0; i < dat.length; i += 16384) {
        r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384))
      }
      return r
    } else {
      // typed array slice - allows garbage collector to free original reference,
      // while being more compatible than .slice
      const slc = (v: Uint8Array, s: number, e?: number): Uint8Array => {
        if (s == null || s < 0) {
          s = 0
        }
        if (e == null || e > v.length) {
          e = v.length
        }
        // can't use .constructor in case user-supplied
        return new Uint8Array(v.subarray(s, e))
      }
      // decode UTF8
      const dutf8 = (d: Uint8Array): { s: string; r: Uint8Array } => {
        for (let r = '', i = 0; ; ) {
          let c = d[i++]
          const eb =
            ((c > 127) as unknown as number) + ((c > 223) as unknown as number) + ((c > 239) as unknown as number)
          if (i + eb > d.length) {
            return { s: r, r: slc(d, i - 1) }
          }
          if (!eb) {
            r += String.fromCharCode(c)
          } else if (eb === 3) {
            c = (((c & 15) << 18) | ((d[i++] & 63) << 12) | ((d[i++] & 63) << 6) | (d[i++] & 63)) - 65536
            r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023))
          } else if (eb & 1) {
            r += String.fromCharCode(((c & 31) << 6) | (d[i++] & 63))
          } else {
            r += String.fromCharCode(((c & 15) << 12) | ((d[i++] & 63) << 6) | (d[i++] & 63))
          }
        }
      }
      const { s, r } = dutf8(dat)
      if (r.length) {
        throw new Error('Unexpected trailing bytes in UTF-8 decoding')
      }
      return s
    }
  }

  static async decompressArrayBuffer(buffer: ArrayBuffer): Promise<string> {
    const decompressed = await this.decompress(new Uint8Array(buffer))
    return this.strFromU8(decompressed)
  }

  static arraysAreEqual(a: unknown[], b: unknown[]): boolean {
    return arrayEqual(a, b)
  }

  /**
   * Generate a pre-filled number array.
   *
   * @param start - start value
   * @param stop - stop value
   * @param step - step value
   * @returns filled number array
   */
  static range(start: number, stop: number, step: number): number[] {
    return Array.from({ length: (stop - start) / step + 1 }, (_, i) => start + i * step)
  }

  /**
   * convert spherical AZIMUTH, ELEVATION to Cartesian
   * @param azimuth - azimuth number
   * @param elevation - elevation number
   * @returns the converted [x, y, z] coordinates
   * @example
   * xyz = NVUtilities.sph2cartDeg(42, 42)
   */
  static sph2cartDeg(azimuth: number, elevation: number): number[] {
    // convert spherical AZIMUTH,ELEVATION,RANGE to Cartesian
    // see Matlab's [x,y,z] = sph2cart(THETA,PHI,R)
    // reverse with cart2sph
    const Phi = -elevation * (Math.PI / 180)
    const Theta = ((azimuth - 90) % 360) * (Math.PI / 180)
    const ret = [Math.cos(Phi) * Math.cos(Theta), Math.cos(Phi) * Math.sin(Theta), Math.sin(Phi)]
    const len = Math.sqrt(ret[0] * ret[0] + ret[1] * ret[1] + ret[2] * ret[2])
    if (len <= 0.0) {
      return ret
    }
    ret[0] /= len
    ret[1] /= len
    ret[2] /= len
    return ret
  }

  static vox2mm(XYZ: number[], mtx: mat4): vec3 {
    const sform = mat4.clone(mtx)
    mat4.transpose(sform, sform)
    const pos = vec4.fromValues(XYZ[0], XYZ[1], XYZ[2], 1)
    vec4.transformMat4(pos, pos, sform)
    const pos3 = vec3.fromValues(pos[0], pos[1], pos[2])
    return pos3
  }
}