///|
fn structural_integer(
  object : @syntax.PdfObject,
  key : Bytes,
) -> Int32 raise GuardError {
  match field(object, key) {
    Some(PdfInteger(value)) if value >= 0 => value
    _ => raise Invalid("missing or invalid structural PDF integer")
  }
}

///|
fn read_object_slice(
  view : BytesView,
) -> @syntax.PdfParsedIndirectObject raise GuardError {
  let cursor = @pdfcore.byte_cursor_of_view(view)
  let tokens = @syntax.pdf_cursor_lex_tokens(cursor) catch {
    _ => raise Invalid("cannot read indexed PDF object")
  }
  let (prefix, _, complete) = @syntax.pdf_parse_indirect_object_segment_at(
    tokens, 0,
  ) catch {
    _ => raise Invalid("malformed indexed PDF object")
  }
  if complete {
    return prefix
  }
  let start = cursor.position()
  let first = if start + 8 <= view.length() &&
    view[start:start + 8] == b"stream\r\n" {
    start + 8
  } else if start + 7 <= view.length() && view[start:start + 7] == b"stream\n" {
    start + 7
  } else {
    raise Invalid("unterminated indexed PDF object")
  }
  let length = structural_integer(prefix.object, b"Length")
  if length > view.length() - first {
    raise Invalid("indexed PDF stream exceeds its object bounds")
  }
  let tail = @pdfcore.byte_cursor_of_view(view[first + length:])
  @syntax.pdf_cursor_drop_whitespace(tail)
  let markers = tail.remaining_view()
  if markers.length() < 9 || markers[0:9] != b"endstream" {
    raise Invalid("indexed PDF stream length misses endstream")
  }
  let suffix = @pdfcore.byte_cursor_of_view(markers[9:])
  @syntax.pdf_cursor_drop_whitespace(suffix)
  let ending = suffix.remaining_view()
  if ending.length() < 6 || ending[0:6] != b"endobj" {
    raise Invalid("indexed PDF stream is missing endobj")
  }
  {
    ..prefix,
    object: @syntax.pdf_stream(
      prefix.object,
      @syntax.StreamGot(view[first:first + length].to_owned()),
    ),
  }
}

///|
fn structural_bytes(
  object : @syntax.PdfObject,
  limit : Int32,
) -> Bytes raise GuardError {
  if !(object is PdfStreamObject(_)) {
    raise Invalid("expected cross-reference or object stream")
  }
  if field(object, b"DecodeParms") is Some(params) && !(params is PdfNull) {
    raise Unsupported("structural PDF stream parameters")
  }
  let bytes = object.stream_bytes() catch {
    _ => raise Invalid("cannot read structural PDF stream")
  }
  match field(object, b"Filter") {
    None | Some(PdfNull) if bytes.length() <= limit => bytes
    None | Some(PdfNull) =>
      raise Unsupported("structural PDF stream exceeds its size limit")
    Some(PdfNameObject(name)) if pdf_name_payload(name) == b"FlateDecode" =>
      inflate_bounded(bytes, limit)
    _ => raise Unsupported("structural PDF stream filter")
  }
}

///|
fn xref_entries(
  object : @syntax.PdfObject,
) -> (Array[@pdfreader.PdfClassicXRefEntry], Int32) raise GuardError {
  let size = structural_integer(object, b"Size")
  if size > 50_000 {
    raise Unsupported("PDF exceeds the object count limit")
  }
  let (pairs, widths) = (
    @pdfreader.pdf_xref_stream_index_pairs(object),
    @pdfreader.pdf_xref_stream_widths(object),
  ) catch {
    _ => raise Invalid("malformed cross-reference stream metadata")
  }
  let mut previous_end = 0
  let mut count = 0
  for pair in pairs {
    if pair.0 < previous_end ||
      pair.0 > size ||
      pair.1 < 0 ||
      pair.1 > size - pair.0 {
      raise Invalid("invalid cross-reference stream index")
    }
    previous_end = pair.0 + pair.1
    count += pair.1
  }
  let (kind, offset, generation) = widths
  if kind < 0 ||
    kind > 1 ||
    offset < 1 ||
    offset > 4 ||
    generation < 0 ||
    generation > 2 {
    raise Unsupported("cross-reference stream field width")
  }
  let expected = count * (kind + offset + generation)
  let data = structural_bytes(object, expected)
  if data.length() != expected {
    raise Invalid("cross-reference stream length differs from its index")
  }
  if kind == 1 {
    let row_width = kind + offset + generation
    for i in 0.. 2 {
        raise Unsupported("unknown cross-reference stream entry type")
      }
    }
  }
  let entries = @pdfreader.pdf_xref_stream_entries(data[:], widths, pairs[:]) catch {
    _ => raise Invalid("cannot decode cross-reference stream entries")
  }
  (entries, expected)
}

///|
fn read_stream_document(
  data : Bytes,
  xref : Int32,
) -> (@pdf.PdfDocument, Int32) raise GuardError {
  let section = read_object_slice(data[xref:])
  if !@pdfreader.pdf_reader_object_is_xref_stream(section.object) {
    raise Invalid("startxref does not name a cross-reference stream")
  }
  check_trailer(section.object)
  let root = match field(section.object, b"Root") {
    Some(PdfIndirect(number)) if number > 0 => number
    _ => raise Invalid("cross-reference stream is missing an indirect catalog")
  }
  let (entries, xref_bytes) = xref_entries(section.object)
  let plain : Array[@pdfreader.PdfClassicXRefEntry] = []
  for entry in entries {
    if entry.in_use && entry.object_number == 0 {
      raise Invalid("cross-reference stream marks the free object as in use")
    }
    if entry.in_use && entry.object_stream is None {
      if entry.offset == xref &&
        entry.object_number == section.number &&
        entry.generation == section.generation {
        continue
      }
      if entry.offset <= 0 || entry.offset >= xref {
        raise Invalid("cross-reference stream points outside the object area")
      }
      plain.push(entry)
    }
  }
  plain.sort_by(fn(left, right) { left.offset.compare(right.offset) })
  let objects : Array[@syntax.PdfParsedIndirectObject] = []
  let streams : Map[Int32, @syntax.PdfObject] = Map([])
  for i, entry in plain {
    let end = if i + 1 < plain.length() { plain[i + 1].offset } else { xref }
    if end <= entry.offset {
      raise Invalid("cross-reference stream repeats an object offset")
    }
    let parsed = read_object_slice(data[entry.offset:end])
    if parsed.number != entry.object_number ||
      parsed.generation != entry.generation {
      raise Invalid("cross-reference stream object identity mismatch")
    }
    if parsed.object is PdfStreamObject(_) {
      streams.set(parsed.number, parsed.object)
    }
    objects.push(parsed)
  }
  let mut decoded = xref_bytes
  for pair in @pdfreader.pdf_reader_object_stream_groups(entries[:]) {
    let (number, members) = pair
    let stream = match streams.get(number) {
      Some(value) => value
      None => raise Invalid("missing object stream")
    }
    if !(field(stream, b"Type") is Some(PdfNameObject(name)) &&
      pdf_name_payload(name) == b"ObjStm") {
      raise Invalid("compressed reference does not name an object stream")
    }
    let count = structural_integer(stream, b"N")
    let first = structural_integer(stream, b"First")
    if count != members.length() {
      raise Unsupported(
        "object stream members differ from the cross-reference stream",
      )
    }
    let bytes = structural_bytes(
      stream,
      (64 * 1024 * 1024 - decoded).min(8 * 1024 * 1024),
    )
    decoded += bytes.length()
    let indexes = @pdfreader.pdf_object_stream_number_offsets(
      bytes[:],
      first,
      count,
    ) catch {
      _ => raise Invalid("malformed object stream header")
    }
    let mut previous_offset = -1
    for index in indexes {
      if index.1 <= previous_offset {
        raise Invalid("object stream member offsets must strictly increase")
      }
      previous_offset = index.1
    }
    let ends = @pdfreader.pdf_object_stream_end_offsets(
      indexes[:],
      bytes.length(),
      first,
    )
    for (entry, pointer) in members {
      let index = pointer.index
      if index < 0 || index >= count || indexes[index].0 != entry.object_number {
        raise Invalid("object stream member identity mismatch")
      }
      let start = indexes[index].1
      let end = ends[index]
      if start >= end || end > bytes.length() - first {
        raise Invalid("object stream member outside its bounds")
      }
      let object = @syntax.pdf_parse_object_from_view(
        bytes[first + start:first + end],
      ) catch {
        _ => raise Invalid("malformed object stream member")
      }
      objects.push({ number: entry.object_number, generation: 0, object, })
    }
  }
  if !objects.any(item => item.number == root) {
    raise Invalid("cross-reference stream catalog is missing")
  }
  let version = @pdfreader.pdf_read_header_from_bytes(data) catch {
    _ => raise Invalid("invalid PDF header")
  }
  let document = @pdf.pdf_document_of_parsed_indirect_objects(
    objects[:],
    version~,
  )
  document.set_root(root)
  if section.object is PdfStreamObject(stream) {
    document.set_trailer_dict(stream.dictionary)
  }
  (document, decoded)
}