///|
/// Incremental parser for concatenated single-symbol RFC packets with the
/// same OTI. Symbol size fixes the frame length; no extra wire bytes are added.
struct FrameBuffer {
  size : Int32
  limit : Int32
  partial : Array[Byte]
  mut used : Int32
  mut packets : Int32
  mut finished : Bool
}

///|
fn FrameBuffer::new(
  size : Int32,
  max_packets~ : Int32 = 4096,
) -> Result[FrameBuffer, RaptorError] {
  if max_packets < 1 || max_packets > 65536 {
    return Err(ResourceLimit("framer packet budget must be 1..65536"))
  }
  Ok({
    size,
    limit: max_packets,
    partial: Array::make(size, 0),
    used: 0,
    packets: 0,
    finished: false,
  })
}

///|
fn FrameBuffer::buffered(self : FrameBuffer) -> Int32 {
  self.used
}

///|
fn FrameBuffer::parsed(self : FrameBuffer) -> Int32 {
  self.packets
}

///|
/// Chunk processing is atomic. Errors do not consume partial input or lose
/// valid packets preceding an invalid frame in the same chunk.
fn[T] FrameBuffer::push(
  self : FrameBuffer,
  chunk : Bytes,
  parse : (Bytes) -> Result[T, RaptorError],
) -> Result[Array[T], RaptorError] {
  if self.finished {
    return Err(InvalidPacket("framer is already finished"))
  }
  let size = self.size
  let capacity = (self.limit - self.packets) * size - self.used
  if chunk.length() > capacity {
    return Err(ResourceLimit("framer packet budget exhausted"))
  }
  let partial = self.partial.copy()
  let mut used = self.used
  let result : Array[T] = []
  for byte in chunk {
    partial[used] = byte
    used += 1
    if used == size {
      match parse(Bytes::from_array(partial)) {
        Err(error) => return Err(error)
        Ok(packet) => result.push(packet)
      }
      used = 0
    }
  }
  for index in 0.. Result[Int32, RaptorError] {
  if self.used != 0 {
    return Err(InvalidPacket("truncated final packet"))
  }
  self.finished = true
  Ok(self.packets)
}