import type { AMQPProperties, Field } from "./amqp-properties.js"

/**
 * An extended DataView, with AMQP protocol specific methods.
 * Set methods returns bytes written.
 * Get methods returns the value read and how many bytes it used.
 * @ignore
 */
export class AMQPView extends DataView<Uint8Array["buffer"]> {
  getUint64(byteOffset: number, littleEndian?: boolean): number {
    // split 64-bit number into two 32-bit (4-byte) parts
    const left = this.getUint32(byteOffset, littleEndian)
    const right = this.getUint32(byteOffset + 4, littleEndian)

    // combine the two 32-bit values
    const combined = littleEndian ? left + 2 ** 32 * right : 2 ** 32 * left + right

    if (!Number.isSafeInteger(combined)) {
      console.warn(combined, "exceeds MAX_SAFE_INTEGER. Precision may be lost")
    }

    return combined
  }

  setUint64(byteOffset: number, value: number, littleEndian?: boolean): void {
    this.setBigUint64(byteOffset, BigInt(value), littleEndian)
  }

  getInt64(byteOffset: number, littleEndian?: boolean): number {
    return Number(this.getBigInt64(byteOffset, littleEndian))
  }

  setInt64(byteOffset: number, value: number, littleEndian?: boolean): void {
    this.setBigInt64(byteOffset, BigInt(value), littleEndian)
  }

  getShortString(byteOffset: number): [string, number] {
    const len = this.getUint8(byteOffset)
    byteOffset += 1
    if (typeof Buffer !== "undefined") {
      const text = Buffer.from(this.buffer, this.byteOffset + byteOffset, len).toString()
      return [text, len + 1]
    } else {
      const view = new Uint8Array(this.buffer, this.byteOffset + byteOffset, len)
      const text = new TextDecoder().decode(view)
      return [text, len + 1]
    }
  }

  setShortString(byteOffset: number, string: string): number {
    if (typeof Buffer !== "undefined") {
      const len = Buffer.byteLength(string)
      if (len > 255) throw new Error(`Short string too long, ${len} bytes: ${string.substring(0, 255)}...`)
      this.setUint8(byteOffset, len)
      byteOffset += 1
      Buffer.from(this.buffer, this.byteOffset + byteOffset, len).write(string)
      return len + 1
    } else {
      const utf8 = new TextEncoder().encode(string)
      const len = utf8.byteLength
      if (len > 255) throw new Error(`Short string too long, ${len} bytes: ${string.substring(0, 255)}...`)
      this.setUint8(byteOffset, len)
      byteOffset += 1
      const view = new Uint8Array(this.buffer, this.byteOffset + byteOffset)
      view.set(utf8)
      return len + 1
    }
  }

  getLongString(byteOffset: number, littleEndian?: boolean): [string, number] {
    const len = this.getUint32(byteOffset, littleEndian)
    byteOffset += 4
    if (typeof Buffer !== "undefined") {
      const text = Buffer.from(this.buffer, this.byteOffset + byteOffset, len).toString()
      return [text, len + 4]
    } else {
      const view = new Uint8Array(this.buffer, this.byteOffset + byteOffset, len)
      const text = new TextDecoder().decode(view)
      return [text, len + 4]
    }
  }

  setLongString(byteOffset: number, string: string, littleEndian?: boolean): number {
    if (typeof Buffer !== "undefined") {
      const len = Buffer.byteLength(string)
      this.setUint32(byteOffset, len, littleEndian)
      byteOffset += 4
      Buffer.from(this.buffer, this.byteOffset + byteOffset, len).write(string)
      return len + 4
    } else {
      const utf8 = new TextEncoder().encode(string)
      const len = utf8.byteLength
      this.setUint32(byteOffset, len, littleEndian)
      byteOffset += 4
      const view = new Uint8Array(this.buffer, this.byteOffset + byteOffset)
      view.set(utf8)
      return len + 4
    }
  }

  getProperties(byteOffset: number, littleEndian?: boolean): [AMQPProperties, number] {
    let j = byteOffset
    const flags = this.getUint16(j, littleEndian)
    j += 2
    const props: AMQPProperties = {}
    if ((flags & 0x8000) > 0) {
      const [contentType, len] = this.getShortString(j)
      j += len
      props.contentType = contentType
    }
    if ((flags & 0x4000) > 0) {
      const [contentEncoding, len] = this.getShortString(j)
      j += len
      props.contentEncoding = contentEncoding
    }
    if ((flags & 0x2000) > 0) {
      const [headers, len] = this.getTable(j, littleEndian)
      j += len
      props.headers = headers
    }
    if ((flags & 0x1000) > 0) {
      props.deliveryMode = this.getUint8(j)
      j += 1
    }
    if ((flags & 0x0800) > 0) {
      props.priority = this.getUint8(j)
      j += 1
    }
    if ((flags & 0x0400) > 0) {
      const [correlationId, len] = this.getShortString(j)
      j += len
      props.correlationId = correlationId
    }
    if ((flags & 0x0200) > 0) {
      const [replyTo, len] = this.getShortString(j)
      j += len
      props.replyTo = replyTo
    }
    if ((flags & 0x0100) > 0) {
      const [expiration, len] = this.getShortString(j)
      j += len
      props.expiration = expiration
    }
    if ((flags & 0x0080) > 0) {
      const [messageId, len] = this.getShortString(j)
      j += len
      props.messageId = messageId
    }
    if ((flags & 0x0040) > 0) {
      props.timestamp = new Date(this.getInt64(j, littleEndian) * 1000)
      j += 8
    }
    if ((flags & 0x0020) > 0) {
      const [type, len] = this.getShortString(j)
      j += len
      props.type = type
    }
    if ((flags & 0x0010) > 0) {
      const [userId, len] = this.getShortString(j)
      j += len
      props.userId = userId
    }
    if ((flags & 0x0008) > 0) {
      const [appId, len] = this.getShortString(j)
      j += len
      props.appId = appId
    }
    const len = j - byteOffset
    return [props, len]
  }

  setProperties(byteOffset: number, properties: AMQPProperties, littleEndian?: boolean): number {
    let j = byteOffset
    let flags = 0
    if (properties.contentType) flags = flags | 0x8000
    if (properties.contentEncoding) flags = flags | 0x4000
    if (properties.headers) flags = flags | 0x2000
    if (properties.deliveryMode) flags = flags | 0x1000
    if (properties.priority) flags = flags | 0x0800
    if (properties.correlationId) flags = flags | 0x0400
    if (properties.replyTo) flags = flags | 0x0200
    if (properties.expiration) flags = flags | 0x0100
    if (properties.messageId) flags = flags | 0x0080
    if (properties.timestamp) flags = flags | 0x0040
    if (properties.type) flags = flags | 0x0020
    if (properties.userId) flags = flags | 0x0010
    if (properties.appId) flags = flags | 0x0008
    this.setUint16(j, flags, littleEndian)
    j += 2
    if (properties.contentType) {
      j += this.setShortString(j, properties.contentType)
    }
    if (properties.contentEncoding) {
      j += this.setShortString(j, properties.contentEncoding)
    }
    if (properties.headers) {
      j += this.setTable(j, properties.headers)
    }
    if (properties.deliveryMode) {
      this.setUint8(j, properties.deliveryMode)
      j += 1
    }
    if (properties.priority) {
      this.setUint8(j, properties.priority)
      j += 1
    }
    if (properties.correlationId) {
      j += this.setShortString(j, properties.correlationId)
    }
    if (properties.replyTo) {
      j += this.setShortString(j, properties.replyTo)
    }
    if (properties.expiration) {
      j += this.setShortString(j, properties.expiration)
    }
    if (properties.messageId) {
      j += this.setShortString(j, properties.messageId)
    }
    if (properties.timestamp) {
      // Date
      const unixEpoch = Math.floor(Number(properties.timestamp) / 1000)
      this.setInt64(j, unixEpoch, littleEndian)
      j += 8
    }
    if (properties.type) {
      j += this.setShortString(j, properties.type)
    }
    if (properties.userId) {
      j += this.setShortString(j, properties.userId)
    }
    if (properties.appId) {
      j += this.setShortString(j, properties.appId)
    }
    const len = j - byteOffset
    return len
  }

  getTable(byteOffset: number, littleEndian?: boolean): [Record<string, Field>, number] {
    const table: Record<string, Field> = {}
    let i = byteOffset
    const len = this.getUint32(byteOffset, littleEndian)
    i += 4
    for (; i < byteOffset + 4 + len; ) {
      const [k, strLen] = this.getShortString(i)
      i += strLen
      const [v, vLen] = this.getField(i, littleEndian)
      i += vLen
      table[k] = v
    }
    return [table, len + 4]
  }

  setTable(byteOffset: number, table: Record<string, Field>, littleEndian?: boolean): number {
    // skip the first 4 bytes which are for the size
    let i = byteOffset + 4
    for (const [key, value] of Object.entries(table)) {
      if (value === undefined) continue
      i += this.setShortString(i, key)
      i += this.setField(i, value, littleEndian)
    }
    this.setUint32(byteOffset, i - byteOffset - 4, littleEndian) // update prefix length
    return i - byteOffset
  }

  getField(byteOffset: number, littleEndian?: boolean): [Field, number] {
    let i = byteOffset
    const k = this.getUint8(i)
    i += 1
    const type = String.fromCharCode(k)
    let v
    let len
    switch (type) {
      case "t":
        v = this.getUint8(i) === 1
        i += 1
        break
      case "b":
        v = this.getInt8(i)
        i += 1
        break
      case "B":
        v = this.getUint8(i)
        i += 1
        break
      case "s":
        v = this.getInt16(i, littleEndian)
        i += 2
        break
      case "u":
        v = this.getUint16(i, littleEndian)
        i += 2
        break
      case "I":
        v = this.getInt32(i, littleEndian)
        i += 4
        break
      case "i":
        v = this.getUint32(i, littleEndian)
        i += 4
        break
      case "l":
        v = this.getInt64(i, littleEndian)
        i += 8
        break
      case "f":
        v = this.getFloat32(i, littleEndian)
        i += 4
        break
      case "d":
        v = this.getFloat64(i, littleEndian)
        i += 8
        break
      case "S":
        ;[v, len] = this.getLongString(i, littleEndian)
        i += len
        break
      case "F":
        ;[v, len] = this.getTable(i, littleEndian)
        i += len
        break
      case "A":
        ;[v, len] = this.getArray(i, littleEndian)
        i += len
        break
      case "x":
        ;[v, len] = this.getByteArray(i, littleEndian)
        i += len
        break
      case "T":
        v = new Date(this.getInt64(i, littleEndian) * 1000)
        i += 8
        break
      case "V":
        v = null
        break
      case "D": {
        const scale = this.getUint8(i)
        i += 1
        const value = this.getUint32(i, littleEndian)
        i += 4
        v = value / 10 ** scale
        break
      }
      default:
        throw new Error(`Field type '${k}' not supported`)
    }
    return [v, i - byteOffset]
  }

  setField(byteOffset: number, field: Field, littleEndian?: boolean): number {
    let i = byteOffset
    switch (typeof field) {
      case "string":
        this.setUint8(i, "S".charCodeAt(0))
        i += 1
        i += this.setLongString(i, field, littleEndian)
        break
      case "boolean":
        this.setUint8(i, "t".charCodeAt(0))
        i += 1
        this.setUint8(i, field ? 1 : 0)
        i += 1
        break
      case "bigint":
        this.setUint8(i, "l".charCodeAt(0))
        i += 1
        this.setBigInt64(i, field, littleEndian)
        i += 8
        break
      case "number":
        if (Number.isInteger(field)) {
          if (-(2 ** 32) < field && field < 2 ** 32) {
            this.setUint8(i, "I".charCodeAt(0))
            i += 1
            this.setInt32(i, field, littleEndian)
            i += 4
          } else {
            this.setUint8(i, "l".charCodeAt(0))
            i += 1
            this.setInt64(i, field, littleEndian)
            i += 8
          }
        } else {
          // float
          if (-(2 ** 32) < field && field < 2 ** 32) {
            this.setUint8(i, "f".charCodeAt(0))
            i += 1
            this.setFloat32(i, field, littleEndian)
            i += 4
          } else {
            this.setUint8(i, "d".charCodeAt(0))
            i += 1
            this.setFloat64(i, field, littleEndian)
            i += 8
          }
        }
        break
      case "undefined":
        this.setUint8(i, "V".charCodeAt(0))
        i += 1
        break
      case "object":
        if (Array.isArray(field)) {
          this.setUint8(i, "A".charCodeAt(0))
          i += 1
          i += this.setArray(i, field, littleEndian)
        } else if (field instanceof Uint8Array) {
          this.setUint8(i, "x".charCodeAt(0))
          i += 1
          i += this.setByteArray(i, field)
        } else if (field instanceof ArrayBuffer) {
          this.setUint8(i, "x".charCodeAt(0))
          i += 1
          i += this.setByteArray(i, new Uint8Array(field))
        } else if (field instanceof Date) {
          this.setUint8(i, "T".charCodeAt(0))
          i += 1
          const unixEpoch = Math.floor(Number(field) / 1000)
          this.setInt64(i, unixEpoch, littleEndian)
          i += 8
        } else if (field === null) {
          this.setUint8(i, "V".charCodeAt(0))
          i += 1
        } else {
          // hopefully it's a hash like object
          this.setUint8(i, "F".charCodeAt(0))
          i += 1
          i += this.setTable(i, field as Record<string, Field>, littleEndian)
        }
        break
      default:
        throw new Error(`Unsupported field type '${field}'`)
    }
    return i - byteOffset
  }

  getArray(byteOffset: number, littleEndian?: boolean): [Field[], number] {
    const len = this.getUint32(byteOffset, littleEndian)
    byteOffset += 4
    const endOffset = byteOffset + len
    const v = []
    for (; byteOffset < endOffset; ) {
      const [field, fieldLen] = this.getField(byteOffset, littleEndian)
      byteOffset += fieldLen
      v.push(field)
    }
    return [v, len + 4]
  }

  setArray(byteOffset: number, array: Field[], littleEndian?: boolean): number {
    const start = byteOffset
    byteOffset += 4 // update the length later
    array.forEach((e) => {
      byteOffset += this.setField(byteOffset, e, littleEndian)
    })
    this.setUint32(start, byteOffset - start - 4, littleEndian) // update length
    return byteOffset - start
  }

  getByteArray(byteOffset: number, littleEndian?: boolean): [Uint8Array, number] {
    const len = this.getUint32(byteOffset, littleEndian)
    byteOffset += 4
    const v = new Uint8Array(this.buffer, this.byteOffset + byteOffset, len)
    return [v, len + 4]
  }

  setByteArray(byteOffset: number, data: Uint8Array, littleEndian?: boolean): number {
    this.setUint32(byteOffset, data.byteLength, littleEndian)
    byteOffset += 4
    const view = new Uint8Array(this.buffer, this.byteOffset + byteOffset, data.byteLength)
    view.set(data)
    return data.byteLength + 4
  }
}