#pdf

#Overview

#Core Types

#PdfObject

///|
pub(all) enum PdfObject {
  Null
  Boolean(Bool)
  Integer(Int)
  Real(Double)
  String(String)
  Name(PdfName)
  Array(Array[PdfObject])
  Dictionary(Array[(String, PdfObject)])
  Stream(Ref[(PdfObject, Stream)])
  Indirect(Int)
}

• Null: PDF null.
• Boolean: true or false.
• Integer/Real: Numeric values.
• String: Literal (...) or hex <...> strings. Stored as a MoonBit String, but treated as raw bytes by the parser/serializer.
• Name: PDF names like /Type, /Page, stored as PdfName (byte sequence, not Unicode text).
• Array: Ordered collection of objects.
• Dictionary: Key-value pairs, stored as Array[(String, PdfObject)] so we can represent malformed PDFs with duplicate keys and preserve insertion order; use lookup_immediate (first match) or lookup_immediate_all (all matches).
• Stream: A stream dictionary plus stream payload (possibly deferred), stored behind a Ref so getstream can materialize bytes in-place.
• Indirect: Reference to another object by number (n 0 R).

#Pdf

///|
pub(all) struct Pdf {
  major : Int // PDF major version
  minor : Int // PDF minor version
  root : Int // Object number of document catalog
  objects : PdfObjects // All objects in the document
  mut trailerdict : PdfObject
  was_linearized : Bool
  mut saved_encryption : SavedEncryption?
}

#Stream

///|
pub(all) enum Stream {
  Got(Array[Byte]) // Data in memory
  ToGet(ToGet) // Data still on disk
}

#Creating Documents

#Empty Document

///|
let pdf = @pdf.Pdf::empty()
// Creates PDF 2.0 with no objects

#Adding Objects

let pdf = @pdf.Pdf::empty()

// Add an object and get its number
let objnum = pdf.addobj(@pdf.PdfObject::Dictionary([
  ("/Type", @pdf.PdfObject::Name("/Page")),
]))

// Add with a specific object number
pdf.addobj_given_num((42, @pdf.PdfObject::Integer(100)))

#Object Lookup

#Basic Lookup

///|
test "lookup_obj returns Null for missing objects" {
  let pdf = @pdf.Pdf::empty()
  assert_true(pdf.lookup_obj(999) is Null)
}

#Following Indirect References

///|
test "direct follows indirects" {
  let pdf = @pdf.Pdf::empty()
  let objnum = pdf.addobj(Integer(42))
  let indirect = @pdf.PdfObject::Indirect(objnum)
  guard pdf.direct(indirect) is Integer(n) else { fail("expected Integer") }
  inspect(n, content="42")
}

#Dictionary Key Lookup

///|
test "lookup_direct finds keys" {
  let pdf = @pdf.Pdf::empty()
  let dict = @pdf.PdfObject::Dictionary([
    ("/Type", Name(PdfName(b"/Page"))),
    ("/Count", Integer(5)),
  ])
  guard pdf.lookup_direct("/Type", dict) is Some(Name(name)) else {
    fail("expected Name")
  }
  inspect(name.to_string_bytes(), content="/Page")
  assert_true(pdf.lookup_direct("/Missing", dict) is None)
}

#Nested Chain Lookup

///|
test "lookup_chain navigates nested dicts" {
  let pdf = @pdf.Pdf::empty()
  let inner = @pdf.PdfObject::Dictionary([("/Value", Integer(100))])
  let outer = @pdf.PdfObject::Dictionary([("/Inner", inner)])
  guard pdf.lookup_chain(outer, ["/Inner", "/Value"][:]) is Some(Integer(n)) else {
    fail("expected Integer")
  }
  inspect(n, content="100")
}

#Dictionary Manipulation

#Adding Entries

///|
test "add_dict_entry" {
  let dict = @pdf.PdfObject::Dictionary([("/Type", Name(PdfName(b"/Page")))])
  let updated = dict.add_entry("/Count", Integer(1))
  match updated {
    Dictionary(entries) => inspect(entries.length(), content="2")
    _ => fail("expected dictionary")
  }
}

#Traits

#ToPdfNumber

///|
test "ToPdfNumber converts Int/Double to PdfObject numbers" {
  guard @pdf.ToPdfNumber::to_pdf_number(42) is Integer(42) else {
    fail("expected Integer(42)")
  }
  guard @pdf.ToPdfNumber::to_pdf_number(1.5) is Real(r) && r == 1.5 else {
    fail("expected Real(1.5)")
  }
}

#Replacing Entries

///|
test "replace_dict_entry" {
  let dict = @pdf.PdfObject::Dictionary([("/Count", Integer(1))])
  let updated = dict.replace_entry("/Count", Integer(5))
  guard updated.lookup_immediate("/Count") is Some(Integer(n)) else {
    fail("expected Integer")
  }
  inspect(n, content="5")
}

#Removing Entries

///|
test "remove_dict_entry" {
  let dict = @pdf.PdfObject::Dictionary([
    ("/Type", Name(PdfName(b"/Page"))),
    ("/Count", Integer(1)),
  ])
  let updated = dict.remove_entry("/Count")
  match updated {
    Dictionary(entries) => inspect(entries.length(), content="1")
    _ => fail("expected dictionary")
  }
}

#Object Iteration

#Iterating All Objects

obj.objiter(fn(objnum) {
    println("Object \{objnum}: \{obj}")
  },
  pdf,
)

#Selecting Objects by Predicate

// Find all page objects

///|
let page_nums = obj.objselect(
  fn(obj) {
    match pdf.lookup_direct("/Type") {
      Some(Name("/Page")) => true
      _ => false
    }
  },
  pdf,
)

#Transforming All Objects

// Apply a transformation to every object
pdf,
.objselfmap(fn(obj) {
    // Return transformed object
    obj
  })

#Stream Operations

#Getting Stream Data

match obj {
  Stream(_) => {
    obj.getstream!()  // Loads data if deferred
    let bytes = obj.bigarray_of_stream!()
    // Use bytes...
  }
  _ => ()
}

#Geometry Operations

#Parsing Rectangles

///|
test "parse_rectangle" {
  let pdf = @pdf.Pdf::empty()
  let rect = @pdf.PdfObject::PdfArray([
    Real(0.0),
    Real(0.0),
    Real(612.0),
    Real(792.0),
  ])
  let (minx, miny, maxx, maxy) = pdf.parse_rectangle(rect)
  debug_inspect((minx, miny, maxx, maxy), content="(0, 0, 612, 792)")
}

#Matrices

// Parse a matrix from a dictionary

///|
let matrix = pdf.parse_matrix("/Matrix", dict)

// Create a matrix object

///|
let matrix_obj = @pdf.make_matrix(@pdftransform.TransformMatrix::identity())

#Reference Management

#Finding Referenced Objects

// Find all objects reachable from a starting object

///|
let refs = pdf.objects_referenced([], [], start_obj)

#Removing Unreferenced Objects

// Garbage collect unreferenced objects
pdf.remove_unreferenced!()

#Document Operations

#Renumbering Objects

// Calculate changes to renumber 1..n

///|
let change_table = pdf.changes()

// Apply renumbering

///|
let renumbered = pdf.renumber(change_table)

#Deep Copy

// Create an independent copy

///|
let copy = pdf.deep_copy()

#Renumbering Multiple PDFs

// Make object numbers mutually exclusive across documents

///|
let renumbered = @pdf.renumber_pdfs([pdf1, pdf2, pdf3])

#Name Trees

// Lookup in a name tree

///|
let value = pdf.nametree_lookup(@pdf.PdfObject::String("key"), tree)

// Get all entries

///|
let entries = pdf.contents_of_nametree(tree)

#Character Classification

///|
test "is_delimiter" {
  inspect(is_delimiter('('), content="true") // internal function
  inspect(is_delimiter('/'), content="true")
  inspect(is_delimiter('a'), content="false")
}

///|
test "is_whitespace" {
  inspect(@pdf.is_whitespace(' '), content="true")
  inspect(@pdf.is_whitespace('\n'), content="true")
  inspect(@pdf.is_whitespace('a'), content="false")
}

#Error Handling

///|
pub(all) suberror PdfError {
  Msg(String)
}