// Ported from Draco 1.5.7: Apache License 2.0, Copyright 2016 The Draco Authors. See NOTICE.

///|
/// `DRACO_BITSTREAM_VERSION(major, minor)`.
fn bitstream(major : Int32, minor : Int32) -> Int32 {
  (major << 8) | minor
}

///|
fn ult(a : Int32, b : Int32) -> Bool {
  a.reinterpret_as_uint() < b.reinterpret_as_uint()
}

///|
/// Draco's `DecoderBuffer` over `data[start, start + size)`, with its bit reader. A read past the
/// end sets `failed` and moves nothing, as Draco's reads fail; callers check `failed` where Draco
/// checks the read. `floor` is the input's first byte, which no read goes below.
priv struct Buffer {
  data : FixedArray[Byte]
  floor : Int32
  mut start : Int32
  mut size : Int32
  mut pos : Int32
  mut version : Int32
  mut bit_mode : Bool
  mut bit_start : Int32
  mut bit_end : Int32
  mut bit_offset : Int32
  mut failed : Bool
}

///|
fn Buffer::new(data : FixedArray[Byte], start : Int32, size : Int32) -> Buffer {
  {
    data,
    floor: start,
    start,
    size,
    pos: 0,
    version: 0,
    bit_mode: false,
    bit_start: 0,
    bit_end: 0,
    bit_offset: 0,
    failed: false,
  }
}

///|
fn Buffer::copy(self : Buffer) -> Buffer {
  { ..self, }
}

///|
/// `*self = other`.
fn Buffer::assign(self : Buffer, other : Buffer) -> Unit {
  self.start = other.start
  self.size = other.size
  self.pos = other.pos
  self.version = other.version
  self.bit_mode = other.bit_mode
  self.bit_start = other.bit_start
  self.bit_end = other.bit_end
  self.bit_offset = other.bit_offset
  self.failed = other.failed
}

///|
/// `Init(data_head, size, version)`: `start` is absolute in `data`.
fn Buffer::init(
  self : Buffer,
  start : Int32,
  size : Int32,
  version : Int32,
) -> Unit {
  self.start = start
  self.size = size
  self.pos = 0
  self.version = version
}

///|
fn Buffer::head(self : Buffer) -> Int32 {
  self.start + self.pos
}

///|
fn Buffer::remaining(self : Buffer) -> Int32 {
  self.size - self.pos
}

///|
fn Buffer::has(self : Buffer, n : Int32) -> Bool {
  if n < 0 || self.pos + n > self.size || self.size < 0 {
    self.failed = true
    false
  } else {
    true
  }
}

///|
fn Buffer::byte_at(self : Buffer, i : Int32) -> Int32 {
  self.data[self.start + i].to_int()
}

///|
fn Buffer::u8(self : Buffer) -> Int32 {
  guard self.has(1) else { 0 }
  let v = self.byte_at(self.pos)
  self.pos += 1
  v
}

///|
fn Buffer::i8(self : Buffer) -> Int32 {
  self.u8() << 24 >> 24
}

///|
fn Buffer::u16(self : Buffer) -> Int32 {
  guard self.has(2) else { 0 }
  let p = self.pos
  self.pos += 2
  self.byte_at(p) | (self.byte_at(p + 1) << 8)
}

///|
/// A little-endian 32-bit word (signed or unsigned bits).
fn Buffer::u32(self : Buffer) -> Int32 {
  guard self.has(4) else { 0 }
  let p = self.pos
  self.pos += 4
  self.byte_at(p) |
  (self.byte_at(p + 1) << 8) |
  (self.byte_at(p + 2) << 16) |
  (self.byte_at(p + 3) << 24)
}

///|
fn Buffer::u64(self : Buffer) -> UInt64 {
  guard self.has(8) else { 0 }
  let lo = self.u32().reinterpret_as_uint().to_uint64()
  let hi = self.u32().reinterpret_as_uint().to_uint64()
  lo | (hi << 32)
}

///|
fn Buffer::f32(self : Buffer) -> Float {
  Float::reinterpret_from_int(self.u32())
}

///|
/// `DecodeVarint`: at most five bytes, the value taken mod 2^32; bytes read before a
/// failure stay consumed.
fn Buffer::varint(self : Buffer) -> Int32 {
  let mut v = 0
  for depth in 0..<5 {
    let b = self.u8()
    guard !self.failed else { return 0 }
    v = v | ((b & 0x7f) << (7 * depth))
    if b < 0x80 {
      return v
    }
  }
  self.failed = true
  0
}

///|
/// `DecodeVarint`: at most ten bytes.
fn Buffer::varint64(self : Buffer) -> UInt64 {
  let mut v : UInt64 = 0
  for depth in 0..<10 {
    let b = self.u8()
    guard !self.failed else { return 0 }
    v = v | ((b & 0x7f).to_uint64() << (7 * depth))
    if b < 0x80 {
      return v
    }
  }
  self.failed = true
  0
}

///|
/// `remaining_size()` against an unsigned count, as Draco compares them (a negative remainder is
/// below every count).
fn Buffer::fits(self : Buffer, n : UInt64) -> Bool {
  let r = self.remaining()
  r >= 0 && n <= r.to_uint64()
}

///|
fn Buffer::start_bits(self : Buffer, decode_size : Bool) -> UInt64 {
  let mut size : UInt64 = 0
  if decode_size {
    size = if self.version < bitstream(2, 2) {
      self.u64()
    } else {
      self.varint64()
    }
    guard !self.failed else { return 0 }
  }
  self.bit_mode = true
  self.bit_start = self.head()
  self.bit_end = self.head() + self.remaining()
  self.bit_offset = 0
  size
}

///|
fn Buffer::end_bits(self : Buffer) -> Unit {
  self.bit_mode = false
  self.pos += (self.bit_offset + 7) / 8
}

///|
/// `GetBits`: bits past the end read as 0 and are not counted. The caller checks `bit_mode` and
/// `nbits <= 32` where Draco does.
fn Buffer::bits(self : Buffer, nbits : Int32) -> Int32 {
  let mut value = 0
  for bit in 0..> 3)
    if at < self.bit_end {
      value = value | (((self.data[at].to_int() >> (off & 7)) & 1) << bit)
      self.bit_offset = off + 1
    }
  }
  value
}