///|
/// Iterator that reads over a buffer and emits parser events.
pub struct ParseEvents {
  priv inner : ContainerParser
  priv mut remaining_input : BytesView
  priv mut finished : Bool
}

///|
fn ParseEvents::new(parser : ContainerParser, input : BytesView) -> ParseEvents {
  parser.previous_consumed_bytes = 0
  { inner: parser, remaining_input: input, finished: false, }
}

///|
fn starts_with(buf : BytesView, prefix : BytesView) -> Bool {
  if buf.length() < prefix.length() {
    return false
  }
  for i in 0.. ParseEvent? raise @bitstream.JxlError {
  let inner = self.inner
  while true {
    let buf = self.remaining_input
    if buf.length() == 0 {
      self.finished = true
      return None
    }
    match inner.state {
      WaitingSignature =>
        if starts_with(buf, codestream_sig) {
          inner.state = InCodestream(
            kind=BareCodestream,
            bytes_left=None,
            pending_no_more_aux_box=true,
          )
          return Some(BitstreamKind(BareCodestream))
        } else if starts_with(buf, container_sig) {
          inner.state = WaitingBoxHeader
          self.remaining_input = buf[container_sig.length():]
          return Some(BitstreamKind(Container))
        } else if !starts_with(codestream_sig, buf) &&
          !starts_with(container_sig, buf) {
          inner.state = InCodestream(
            kind=Invalid,
            bytes_left=None,
            pending_no_more_aux_box=true,
          )
          return Some(BitstreamKind(Invalid))
        } else {
          return None
        }
      WaitingBoxHeader =>
        match ContainerBoxHeader::parse(buf) {
          Done(header~, header_size~) => {
            self.remaining_input = buf[header_size:]
            let tbox = header.box_type()
            if tbox == ContainerBoxType::codestream() {
              match inner.jxlp_index_state {
                Initial => inner.jxlp_index_state = SingleJxlc
                SingleJxlc => raise InvalidBox
                Jxlp(_) | JxlpFinished => raise InvalidBox
              }
              let bytes_left = header
                .box_size()
                .map(fn(x) { x.reinterpret_as_int64() })
              inner.state = InCodestream(
                kind=Container,
                bytes_left~,
                pending_no_more_aux_box=bytes_left is None,
              )
            } else if tbox == ContainerBoxType::partial_codestream() {
              if header.box_size() is Some(box_size) && box_size < 4UL {
                raise InvalidBox
              }
              match inner.jxlp_index_state {
                Initial => inner.jxlp_index_state = Jxlp(0)
                Jxlp(index) => inner.jxlp_index_state = Jxlp(index + 1)
                SingleJxlc => raise InvalidBox
                JxlpFinished => raise InvalidBox
              }
              inner.state = WaitingJxlpIndex(header)
            } else {
              let bytes_left = header
                .box_size()
                .map(fn(x) { x.reinterpret_as_int64() })
              let ty = header.box_type()
              let brotli_compressed = ty ==
                ContainerBoxType::brotli_compressed()
              if brotli_compressed {
                if bytes_left is Some(n) && n >= 0L && n <= 3L {
                  raise InvalidBox
                }
              }
              inner.state = InAuxBox(header~, brotli_box_type=None, bytes_left~)
              if !brotli_compressed {
                return Some(
                  AuxBoxStart(
                    ty~,
                    brotli_compressed=false,
                    last_box=bytes_left is None,
                  ),
                )
              }
            }
          }
          NeedMoreData => return None
        }
      WaitingJxlpIndex(header) => {
        if buf.length() < 4 {
          return None
        }
        let index = be_u32(buf, 0)
        self.remaining_input = buf[4:]
        let is_last = (index & 0x80000000U) != 0U
        let index = index & 0x7fffffffU
        match inner.jxlp_index_state {
          Jxlp(expected_index) if expected_index == index =>
            if is_last {
              inner.jxlp_index_state = JxlpFinished
            }
          Jxlp(_) => raise InvalidBox
          _ => abort("invalid jxlp index state in WaitingJxlpIndex")
        }
        let bytes_left = header
          .box_size()
          .map(fn(x) { x.reinterpret_as_int64() - 4L })
        inner.state = InCodestream(
          kind=Container,
          bytes_left~,
          pending_no_more_aux_box=bytes_left is None,
        )
      }
      // JXL codestream box is the last box; emit "no more aux box" event.
      InCodestream(kind~, bytes_left~, pending_no_more_aux_box=true) => {
        inner.state = InCodestream(
          kind~,
          bytes_left~,
          pending_no_more_aux_box=false,
        )
        return Some(NoMoreAuxBox)
      }
      InCodestream(bytes_left=None, ..) => {
        self.remaining_input = buf[buf.length():]
        return Some(Codestream(buf))
      }
      InCodestream(kind~, bytes_left=Some(bytes_left), ..) => {
        let len = buf.length().to_int64()
        if len >= bytes_left {
          let n = bytes_left.to_int()
          inner.state = WaitingBoxHeader
          self.remaining_input = buf[n:]
          return Some(Codestream(buf[:n]))
        } else {
          inner.state = InCodestream(
            kind~,
            bytes_left=Some(bytes_left - len),
            pending_no_more_aux_box=false,
          )
          self.remaining_input = buf[buf.length():]
          return Some(Codestream(buf))
        }
      }
      // Read brob payload box type.
      InAuxBox(header~, brotli_box_type=None, bytes_left~) if header.ty ==
        ContainerBoxType::brotli_compressed() => {
        if buf.length() < 4 {
          return None
        }
        let ty = buf[0:4].to_owned()
        self.remaining_input = buf[4:]
        let bytes_left = bytes_left.map(fn(x) { x - 4L })
        let is_reserved_box_type = (
            ty[0] == b'j' && ty[1] == b'x' && ty[2] == b'l'
          ) ||
          ty == b"brob" ||
          ty == b"jbrd"
        if is_reserved_box_type {
          raise ValidationFailed(
            "brob box, jxl boxes and jbrd box cannot be Brotli-compressed",
          )
        }
        let ty = ContainerBoxType(ty)
        inner.state = InAuxBox(header~, brotli_box_type=Some(ty), bytes_left~)
        return Some(
          AuxBoxStart(ty~, brotli_compressed=true, last_box=bytes_left is None),
        )
      }
      InAuxBox(header~, brotli_box_type~, bytes_left~) => {
        let ty = match brotli_box_type {
          Some(ty) => ty
          None => header.ty
        }
        let payload = match bytes_left {
          Some(0L) => {
            inner.state = WaitingBoxHeader
            return Some(AuxBoxEnd(ty))
          }
          Some(left) => {
            let num_bytes_to_read = if left < buf.length().to_int64() {
              left.to_int()
            } else {
              buf.length()
            }
            inner.state = InAuxBox(
              header~,
              brotli_box_type~,
              bytes_left=Some(left - num_bytes_to_read.to_int64()),
            )
            self.remaining_input = buf[num_bytes_to_read:]
            buf[:num_bytes_to_read]
          }
          None => {
            self.remaining_input = buf[buf.length():]
            buf
          }
        }
        return Some(AuxBoxData(ty, payload))
      }
    }
  }
  None
}

///|
/// Returns the next parser event, or `None` when the parser needs more input
/// (or the input is exhausted).
pub fn ParseEvents::next(
  self : ParseEvents,
) -> ParseEvent? raise @bitstream.JxlError {
  if self.finished {
    return None
  }
  let initial_len = self.remaining_input.length()
  defer {
    self.inner.previous_consumed_bytes += initial_len -
      self.remaining_input.length()
  }
  errdefer {
    self.finished = true
  }
  let event = self.emit_single()
  event
}

///|
/// Parser event emitted by `ParseEvents`.
pub(all) enum ParseEvent {
  /// Bitstream structure is detected.
  BitstreamKind(BitstreamKind)
  /// Codestream data is read.
  ///
  /// Returned data may be partial. Complete codestream can be obtained by concatenating all data
  /// of `Codestream` events.
  Codestream(BytesView)
  /// No more auxiliary box will come after this event.
  NoMoreAuxBox
  /// New auxiliary box starts.
  AuxBoxStart(
    ty~ : ContainerBoxType,
    brotli_compressed~ : Bool,
    last_box~ : Bool
  )
  /// Auxiliary box data is read.
  ///
  /// Returned data may be partial. Complete box payload can be obtained by concatenating all
  /// data between corresponding `AuxBoxStart` and `AuxBoxEnd` events.
  AuxBoxData(ContainerBoxType, BytesView)
  /// Current auxiliary box has ended.
  AuxBoxEnd(ContainerBoxType)
}

///|
pub impl Show for ParseEvent with fn output(self, logger) {
  match self {
    BitstreamKind(kind) => logger.write_string("BitstreamKind(\{kind})")
    Codestream(buf) =>
      logger.write_string("Codestream(\{buf.length()} byte(s))")
    NoMoreAuxBox => logger.write_string("NoMoreAuxBox")
    AuxBoxStart(ty~, brotli_compressed~, last_box~) =>
      logger.write_string(
        "AuxBoxStart { ty: \{ty}, brotli_compressed: \{brotli_compressed}, last_box: \{last_box} }",
      )
    AuxBoxData(ty, buf) =>
      logger.write_string("AuxBoxData(\{ty}, \{buf.length()} byte(s))")
    AuxBoxEnd(ty) => logger.write_string("AuxBoxEnd(\{ty})")
  }
}