///|
/// LSB-first bit reader over a byte buffer, ported from jxl-bitstream.
pub struct Bitstream {
  bytes : Bytes
  /// One past the last byte this reader may read.
  end : Int32
  /// Next byte to load into `buf`.
  mut pos : Int32
  mut buf : UInt64
  mut num_read_bits : Int32
  mut remaining_buf_bits : Int32
}

///|
pub fn Bitstream::new(bytes : Bytes) -> Bitstream {
  {
    bytes,
    end: bytes.length(),
    pos: 0,
    buf: 0,
    num_read_bits: 0,
    remaining_buf_bits: 0,
  }
}

///|
/// A reader over `bytes[start:start+len]`.
pub fn Bitstream::new_range(
  bytes : Bytes,
  start : Int32,
  len : Int32,
) -> Bitstream {
  {
    bytes,
    end: start + len,
    pos: start,
    buf: 0,
    num_read_bits: 0,
    remaining_buf_bits: 0,
  }
}

///|
/// An independent copy of the reader state (Rust `Clone`).
pub fn Bitstream::clone(self : Bitstream) -> Bitstream {
  {
    bytes: self.bytes,
    end: self.end,
    pos: self.pos,
    buf: self.buf,
    num_read_bits: self.num_read_bits,
    remaining_buf_bits: self.remaining_buf_bits,
  }
}

///|
pub fn Bitstream::num_read_bits(self : Bitstream) -> Int32 {
  self.num_read_bits
}

///|
/// Number of bytes not yet loaded into the bit buffer.
pub fn Bitstream::bytes_left(self : Bitstream) -> Int32 {
  self.end - self.pos
}

///|
/// Number of bits that can still be read.
pub fn Bitstream::bits_left(self : Bitstream) -> Int32 {
  self.remaining_buf_bits + (self.end - self.pos) * 8
}

///|
fn Bitstream::refill(self : Bitstream) -> Unit {
  while self.remaining_buf_bits <= 56 && self.pos < self.end {
    self.buf = self.buf |
      (self.bytes[self.pos].to_uint64() << self.remaining_buf_bits)
    self.remaining_buf_bits += 8
    self.pos += 1
  }
}

///|
/// Peeks `n` bits (n <= 32), refilling the buffer first.
pub fn Bitstream::peek_bits(self : Bitstream, n : Int32) -> UInt32 {
  self.refill()
  (self.buf & ((1UL << n) - 1)).to_uint()
}

///|
/// Peeks `n` bits without refilling; only valid after a `peek_bits`.
pub fn Bitstream::peek_bits_prefilled(self : Bitstream, n : Int32) -> UInt32 {
  (self.buf & ((1UL << n) - 1)).to_uint()
}

///|
pub fn Bitstream::consume_bits(
  self : Bitstream,
  n : Int32,
) -> Unit raise JxlError {
  if n > self.remaining_buf_bits {
    raise Eof
  }
  self.remaining_buf_bits -= n
  self.num_read_bits += n
  self.buf = if n >= 64 { 0 } else { self.buf >> n }
}

///|
/// Reads `n` bits (n <= 32) as an unsigned value.
pub fn Bitstream::read_bits(
  self : Bitstream,
  n : Int32,
) -> UInt32 raise JxlError {
  if n == 0 {
    return 0
  }
  let ret = self.peek_bits(n)
  self.consume_bits(n)
  ret
}

///|
/// `read_bits` returning a (non-negative) `Int`; n must be <= 31.
pub fn Bitstream::read_bits_int(
  self : Bitstream,
  n : Int32,
) -> Int32 raise JxlError {
  self.read_bits(n).reinterpret_as_int()
}

///|
pub fn Bitstream::skip_bits(self : Bitstream, n : Int32) -> Unit raise JxlError {
  if n <= self.remaining_buf_bits {
    self.consume_bits(n)
    return
  }
  let mut n = n - self.remaining_buf_bits
  self.num_read_bits += self.remaining_buf_bits
  self.buf = 0
  self.remaining_buf_bits = 0
  let avail = self.end - self.pos
  if n > avail * 8 {
    self.num_read_bits += avail * 8
    self.pos = self.end
    raise Eof
  }
  self.num_read_bits += n / 8 * 8
  self.pos += n / 8
  n = n % 8
  self.refill()
  self.consume_bits(n)
}

///|
pub fn Bitstream::zero_pad_to_byte(self : Bitstream) -> Unit raise JxlError {
  let byte_boundary = (self.num_read_bits + 7) / 8 * 8
  let n = byte_boundary - self.num_read_bits
  if self.read_bits(n) != 0 {
    raise NonZeroPadding
  }
}

///|
/// A `U32` distribution entry: constant, or `offset + u(bits)`.
pub(all) enum U32Spec {
  Constant(UInt32)
  BitsOffset(UInt32, Int32)
}

///|
/// `u(n)`
pub fn u(n : Int32) -> U32Spec {
  BitsOffset(0, n)
}

///|
/// `c + u(n)`
pub fn cu(c : UInt32, n : Int32) -> U32Spec {
  BitsOffset(c, n)
}

///|
/// `c`
pub fn c(v : UInt32) -> U32Spec {
  Constant(v)
}

///|
pub fn Bitstream::read_u32(
  self : Bitstream,
  d0 : U32Spec,
  d1 : U32Spec,
  d2 : U32Spec,
  d3 : U32Spec,
) -> UInt32 raise JxlError {
  let d = match self.read_bits(2) {
    0 => d0
    1 => d1
    2 => d2
    _ => d3
  }
  match d {
    Constant(x) => x
    BitsOffset(offset, n) => self.read_bits(n) + offset
  }
}

///|
pub fn Bitstream::read_u64(self : Bitstream) -> UInt64 raise JxlError {
  match self.read_bits(2) {
    0 => 0
    1 => self.read_bits(4).to_uint64() + 1
    2 => self.read_bits(8).to_uint64() + 17
    _ => {
      let mut value = self.read_bits(12).to_uint64()
      let mut shift = 12
      while self.read_bits(1) == 1 {
        if shift == 60 {
          value = value | (self.read_bits(4).to_uint64() << shift)
          break
        }
        value = value | (self.read_bits(8).to_uint64() << shift)
        shift += 8
      }
      value
    }
  }
}

///|
pub fn Bitstream::read_bool(self : Bitstream) -> Bool raise JxlError {
  self.read_bits(1) != 0
}

///|
pub fn Bitstream::read_f16_as_f32(self : Bitstream) -> Float raise JxlError {
  let v = self.read_bits(16)
  let neg_bit = (v & 0x8000) << 16
  if (v & 0x7fff) == 0 {
    return Float::reinterpret_from_uint(neg_bit)
  }
  let mantissa = v & 0x3ff
  let exponent = (v >> 10) & 0x1f
  if exponent == 0x1f {
    raise InvalidFloat
  } else if exponent == 0 {
    let val : Float = (1.0 : Float) /
      16384.0 *
      (Float::from_int(mantissa.reinterpret_as_int()) / 1024.0)
    if neg_bit != 0 {
      -val
    } else {
      val
    }
  } else {
    let mantissa = mantissa << 13
    let exponent = exponent + 112
    Float::reinterpret_from_uint(mantissa | (exponent << 23) | neg_bit)
  }
}

///|
/// Reads the raw value of an `Enum(T)` field; callers map it to their enum
/// and raise `InvalidEnum(name, value)` when it is out of range.
pub fn Bitstream::read_enum_raw(self : Bitstream) -> UInt32 raise JxlError {
  self.read_u32(c(0), c(1), cu(2, 4), cu(18, 6))
}

///|
/// Reads `n` bytes (after the reader is byte aligned) into a new buffer.
pub fn Bitstream::read_bytes_aligned(
  self : Bitstream,
  n : Int32,
) -> Bytes raise JxlError {
  if self.num_read_bits % 8 != 0 {
    raise NotAligned
  }
  if n > self.bits_left() / 8 {
    raise Eof
  }
  let out = FixedArray::make(n, b'\x00')
  for i in 0.. Int32 {
  let bit = x & 1
  let base = x >> 1
  let flip = 0U - bit
  (base ^ flip).reinterpret_as_int()
}

///|
pub fn unpack_signed_u64(x : UInt64) -> Int64 {
  let bit = x & 1
  let base = x >> 1
  let flip = 0UL - bit
  (base ^ flip).reinterpret_as_int64()
}

///|
/// The `Name` bundle: a UTF-8 string with a U32 length prefix.
pub fn read_name(bs : Bitstream) -> String raise JxlError {
  let len = bs.read_u32(c(0), u(4), cu(16, 5), cu(48, 10)).reinterpret_as_int()
  let data = FixedArray::make(len, b'\x00')
  for i in 0.. raise ValidationFailed("non-UTF-8 name")
  }
}