rpdfium_edit/

document.rs

// Derived from PDFium's cpdf_indirect_object_holder.cpp / cpdf_creator.cpp
// Original: Copyright 2014 The PDFium Authors
// Licensed under BSD-3-Clause / Apache-2.0
// See pdfium-upstream/LICENSE for the original license.

//! EditDocument — mutable overlay on top of an immutable ObjectStore.
//!
//! Implements the same pattern as PDFium's `CPDF_IndirectObjectHolder`:
//! modifications are tracked in a separate layer, leaving the base
//! ObjectStore unchanged.

use std::collections::{HashMap, HashSet};
use std::sync::Arc;

use rpdfium_core::Name;
use rpdfium_core::error::PdfError;
use rpdfium_parser::object::{Object, ObjectId, StreamData};
use rpdfium_parser::store::ObjectStore;
use rpdfium_parser::trailer::TrailerInfo;

use crate::cpdf_flateencoder::create_compressed_stream;
use crate::error::EditError;
use crate::font_reg::{FontRegistration, FontType};
use crate::page_object::PageObject;

/// Specification for a new interactive form field.
#[derive(Debug, Clone)]
pub struct FormFieldSpec {
    /// The PDF field type name (`Tx`, `Btn`, or `Ch`).
    pub field_type: Name,
    /// The partial field name (`/T`).
    pub name: String,
    /// Widget annotation rectangle `[x1, y1, x2, y2]` in page coordinates.
    pub rect: [f32; 4],
    /// Page index on which the widget annotation is placed (0-based).
    pub page_index: usize,
    /// Optional default value (`/DV`).
    pub default_value: Option<String>,
    /// Field flags (`/Ff`).
    pub flags: u32,
}

/// A mutable document that layers modifications on top of an immutable
/// `ObjectStore`.
///
/// Resolution order: `deleted` → `modified` → `new_objects` → `base.resolve()`.
pub struct EditDocument {
    /// The original immutable object store (may be empty for blank docs).
    store: Option<ObjectStore<Arc<[u8]>>>,
    /// Objects from the base store that have been modified.
    modified: HashMap<ObjectId, Object>,
    /// Newly created objects.
    new_objects: HashMap<ObjectId, Object>,
    /// Object IDs that have been deleted.
    deleted: HashSet<ObjectId>,
    /// Next object number for allocation.
    next_object_number: u32,
    /// Ordered list of page dictionary object IDs.
    page_ids: Vec<ObjectId>,
    /// The catalog object ID.
    catalog_id: ObjectId,
    /// Whether any modifications have been made.
    dirty: bool,
    /// Page objects owned by each annotation (keyed by annotation ObjectId).
    ///
    /// Used to build the annotation's AP stream on `update_annotation_ap()`.
    pub(crate) ap_objects: HashMap<ObjectId, Vec<PageObject>>,
}

impl EditDocument {
    /// Create an `EditDocument` from an existing `ObjectStore`.
    pub fn from_store(
        store: ObjectStore<Arc<[u8]>>,
        page_ids: Vec<ObjectId>,
        catalog_id: ObjectId,
    ) -> Self {
        let next = store.last_obj_num() + 1;
        Self {
            store: Some(store),
            modified: HashMap::new(),
            new_objects: HashMap::new(),
            deleted: HashSet::new(),
            next_object_number: next,
            page_ids,
            catalog_id,
            dirty: false,
            ap_objects: HashMap::new(),
        }
    }

    /// Create a new blank document with minimal Catalog and Pages structure.
    pub fn new_blank() -> Self {
        let catalog_id = ObjectId::new(1, 0);
        let pages_id = ObjectId::new(2, 0);

        let mut pages_dict = HashMap::new();
        pages_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"Pages".to_vec())),
        );
        pages_dict.insert(Name::kids(), Object::Array(Vec::new()));
        pages_dict.insert(Name::count(), Object::Integer(0));

        let mut catalog_dict = HashMap::new();
        catalog_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"Catalog".to_vec())),
        );
        catalog_dict.insert(Name::pages(), Object::Reference(pages_id));

        let mut new_objects = HashMap::new();
        new_objects.insert(catalog_id, Object::Dictionary(catalog_dict));
        new_objects.insert(pages_id, Object::Dictionary(pages_dict));

        Self {
            store: None,
            modified: HashMap::new(),
            new_objects,
            deleted: HashSet::new(),
            next_object_number: 3,
            page_ids: Vec::new(),
            catalog_id,
            dirty: true,
            ap_objects: HashMap::new(),
        }
    }

    /// Resolve an object by ID, checking the overlay layers first.
    pub fn resolve(&self, id: ObjectId) -> Result<&Object, EditError> {
        if self.deleted.contains(&id) {
            return Err(EditError::Parse(PdfError::UnknownObject(id)));
        }
        if let Some(obj) = self.modified.get(&id) {
            return Ok(obj);
        }
        if let Some(obj) = self.new_objects.get(&id) {
            return Ok(obj);
        }
        if let Some(store) = &self.store {
            return Ok(store.resolve(id)?);
        }
        Err(EditError::Parse(PdfError::UnknownObject(id)))
    }

    /// Get a mutable reference to an object, cloning from base on first access.
    pub fn get_mut(&mut self, id: ObjectId) -> Result<&mut Object, EditError> {
        if self.deleted.contains(&id) {
            return Err(EditError::Parse(PdfError::UnknownObject(id)));
        }
        self.dirty = true;

        // Already in modified layer
        if self.modified.contains_key(&id) {
            return Ok(self.modified.get_mut(&id).unwrap());
        }

        // In new_objects layer
        if self.new_objects.contains_key(&id) {
            return Ok(self.new_objects.get_mut(&id).unwrap());
        }

        // Clone from base store
        if let Some(store) = &self.store {
            let obj = store.resolve(id)?.clone();
            self.modified.insert(id, obj);
            return Ok(self.modified.get_mut(&id).unwrap());
        }

        Err(EditError::Parse(PdfError::UnknownObject(id)))
    }

    /// Add a new object and return its allocated ID.
    pub fn add_object(&mut self, obj: Object) -> ObjectId {
        let id = self.allocate_id();
        self.new_objects.insert(id, obj);
        self.dirty = true;
        id
    }

    /// Delete an object by ID.
    pub fn delete_object(&mut self, id: ObjectId) {
        self.modified.remove(&id);
        self.new_objects.remove(&id);
        self.deleted.insert(id);
        self.dirty = true;
    }

    /// Set/replace an object at a specific ID.
    pub fn set_object(&mut self, id: ObjectId, obj: Object) {
        if self.store.as_ref().is_some_and(|s| s.contains(id)) {
            self.modified.insert(id, obj);
        } else {
            self.new_objects.insert(id, obj);
        }
        self.deleted.remove(&id);
        self.dirty = true;
    }

    /// Allocate a new unique object ID.
    pub fn allocate_id(&mut self) -> ObjectId {
        let id = ObjectId::new(self.next_object_number, 0);
        self.next_object_number += 1;
        id
    }

    /// Iterator over IDs of modified + new objects.
    pub fn changed_ids(&self) -> impl Iterator<Item = ObjectId> + '_ {
        self.modified.keys().chain(self.new_objects.keys()).copied()
    }

    /// Iterator over all valid (non-deleted) object IDs.
    pub fn all_ids(&self) -> Vec<ObjectId> {
        let mut ids: HashSet<ObjectId> = HashSet::new();

        // Add base store IDs
        if let Some(store) = &self.store {
            for id in store.object_ids() {
                ids.insert(*id);
            }
        }

        // Add new/modified IDs
        for id in self.modified.keys() {
            ids.insert(*id);
        }
        for id in self.new_objects.keys() {
            ids.insert(*id);
        }

        // Remove deleted IDs
        for id in &self.deleted {
            ids.remove(id);
        }

        let mut result: Vec<ObjectId> = ids.into_iter().collect();
        result.sort_by_key(|id| (id.number, id.generation));
        result
    }

    /// Whether any modifications have been made.
    #[inline]
    pub fn is_dirty(&self) -> bool {
        self.dirty
    }

    /// Returns the security handler from the base store, if the document is encrypted.
    pub fn security_handler(&self) -> Option<&rpdfium_parser::security::SecurityHandler> {
        self.store.as_ref().and_then(|s| s.security_handler())
    }

    /// Returns a reference to the base object store, if present.
    pub fn base_store(&self) -> Option<&ObjectStore<Arc<[u8]>>> {
        self.store.as_ref()
    }

    /// Returns the trailer info from the base store.
    pub fn trailer(&self) -> Option<&TrailerInfo> {
        self.store.as_ref().map(|s| s.trailer())
    }

    /// Number of pages in the document.
    pub fn page_count(&self) -> usize {
        self.page_ids.len()
    }

    /// Get the object ID of a page by index.
    pub fn page_id(&self, index: usize) -> Option<ObjectId> {
        self.page_ids.get(index).copied()
    }

    /// The catalog object ID.
    #[inline]
    pub fn catalog_id(&self) -> ObjectId {
        self.catalog_id
    }

    /// Mutable access to the page_ids list (for page management).
    pub(crate) fn page_ids_mut(&mut self) -> &mut Vec<ObjectId> {
        &mut self.page_ids
    }

    /// The page IDs list.
    #[inline]
    pub fn page_ids(&self) -> &[ObjectId] {
        &self.page_ids
    }

    /// The set of deleted object IDs.
    #[inline]
    pub fn deleted_ids(&self) -> &HashSet<ObjectId> {
        &self.deleted
    }

    /// The next object number that will be allocated.
    #[inline]
    pub fn next_object_number(&self) -> u32 {
        self.next_object_number
    }

    /// Decode a stream from the base store.
    pub fn decode_stream(&self, stream: &Object) -> Result<Vec<u8>, EditError> {
        // For Decoded streams, return directly
        if let Object::Stream {
            data: StreamData::Decoded { data },
            ..
        } = stream
        {
            return Ok(data.clone());
        }
        // For Raw streams, delegate to base store
        if let Some(store) = &self.store {
            Ok(store.decode_stream(stream)?)
        } else {
            Err(EditError::Other(
                "no base store for raw stream decoding".into(),
            ))
        }
    }

    /// Find the Pages dictionary ID from the catalog.
    pub fn pages_id(&self) -> Result<ObjectId, EditError> {
        let catalog = self.resolve(self.catalog_id)?;
        let dict = catalog
            .as_dict()
            .ok_or(EditError::Other("catalog is not a dictionary".into()))?;
        match dict.get(&Name::pages()) {
            Some(Object::Reference(id)) => Ok(*id),
            _ => Err(EditError::Other("catalog missing /Pages reference".into())),
        }
    }

    /// Register a Standard-14 font in the document.
    ///
    /// Creates a minimal `/Font` dictionary with `/Type /Font`, `/Subtype /Type1`,
    /// and `/BaseFont /<name>`.  The returned [`FontRegistration`] holds the
    /// object ID of that dictionary and can be used with
    /// [`TextObject::with_font`](crate::page_object::TextObject::with_font).
    ///
    /// Corresponds to `FPDFText_LoadStandardFont`.
    pub fn load_standard_font(&mut self, name: &str) -> Result<FontRegistration, EditError> {
        let mut dict = HashMap::new();
        dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"Font".to_vec())),
        );
        dict.insert(
            Name::from_bytes(b"Subtype".to_vec()),
            Object::Name(Name::from_bytes(b"Type1".to_vec())),
        );
        dict.insert(
            Name::from_bytes(b"BaseFont".to_vec()),
            Object::Name(Name::from_bytes(name.as_bytes().to_vec())),
        );

        let id = self.add_object(Object::Dictionary(dict));
        Ok(FontRegistration::new_standard(id, name))
    }

    /// Embed arbitrary font data in the document.
    ///
    /// For TrueType fonts three objects are created:
    /// 1. A Flate-compressed `/FontFile2` stream containing the raw font bytes.
    /// 2. A `/FontDescriptor` dictionary pointing to the stream.
    /// 3. A `/Font` dictionary of the requested subtype.
    ///
    /// `is_cid=true` is not yet supported (returns [`EditError::NotSupported`]).
    ///
    /// Corresponds to `FPDFText_LoadFont`.
    pub fn load_font_from_data(
        &mut self,
        data: &[u8],
        font_type: FontType,
        is_cid: bool,
    ) -> Result<FontRegistration, EditError> {
        if is_cid {
            return Err(EditError::NotSupported(
                "CID font embedding (is_cid=true) is not yet supported".into(),
            ));
        }

        // Choose subtype and FontFile key based on font_type.
        let (subtype_bytes, font_file_key): (&[u8], &[u8]) = match font_type {
            FontType::TrueType => (b"TrueType", b"FontFile2"),
            FontType::Type1 => (b"Type1", b"FontFile"),
        };

        // 1. Font file stream (Flate-compressed).
        let mut stream_dict = HashMap::new();
        stream_dict.insert(
            Name::from_bytes(b"Subtype".to_vec()),
            Object::Name(Name::from_bytes(font_file_key.to_vec())),
        );
        let font_stream = create_compressed_stream(data, stream_dict);
        let stream_id = self.add_object(font_stream);

        // 2. FontDescriptor dictionary.
        let mut desc_dict = HashMap::new();
        desc_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"FontDescriptor".to_vec())),
        );
        desc_dict.insert(
            Name::from_bytes(b"FontName".to_vec()),
            Object::Name(Name::from_bytes(b"EmbeddedFont".to_vec())),
        );
        desc_dict.insert(
            Name::from_bytes(b"Flags".to_vec()),
            Object::Integer(4), // Symbolic
        );
        desc_dict.insert(
            Name::from_bytes(font_file_key.to_vec()),
            Object::Reference(stream_id),
        );
        let desc_id = self.add_object(Object::Dictionary(desc_dict));

        // 3. Font dictionary.
        let mut font_dict = HashMap::new();
        font_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"Font".to_vec())),
        );
        font_dict.insert(
            Name::from_bytes(b"Subtype".to_vec()),
            Object::Name(Name::from_bytes(subtype_bytes.to_vec())),
        );
        font_dict.insert(
            Name::from_bytes(b"BaseFont".to_vec()),
            Object::Name(Name::from_bytes(b"EmbeddedFont".to_vec())),
        );
        font_dict.insert(
            Name::from_bytes(b"FontDescriptor".to_vec()),
            Object::Reference(desc_id),
        );
        let font_id = self.add_object(Object::Dictionary(font_dict));

        let mut reg =
            FontRegistration::new_embedded(font_id, "EmbeddedFont", font_type, data.to_vec());
        // Populate flags, weight, and italic angle from the FontDescriptor we just created.
        reg.set_flags(4); // Symbolic
        reg.set_weight(400); // Regular weight (default)
        reg.set_italic_angle(0.0); // Default upright; caller may override after loading
        Ok(reg)
    }

    /// Upstream-aligned alias for [`load_font_from_data()`](Self::load_font_from_data).
    ///
    /// Corresponds to `FPDFText_LoadFont`.
    #[inline]
    pub fn text_load_font(
        &mut self,
        data: &[u8],
        font_type: FontType,
        is_cid: bool,
    ) -> Result<FontRegistration, EditError> {
        self.load_font_from_data(data, font_type, is_cid)
    }

    /// Non-upstream alias — use [`text_load_font()`](Self::text_load_font).
    #[deprecated(note = "use `text_load_font()` — matches upstream `FPDFText_LoadFont`")]
    #[inline]
    pub fn load_font(
        &mut self,
        data: &[u8],
        font_type: FontType,
        is_cid: bool,
    ) -> Result<FontRegistration, EditError> {
        self.load_font_from_data(data, font_type, is_cid)
    }

    /// Load a CID Type2 (TrueType-based CID-keyed) font for embedding.
    ///
    /// # Not Supported
    ///
    /// CID Type2 font loading requires direct font embedding with CID-keyed
    /// glyph subsetting, which is not yet implemented in rpdfium's font layer.
    ///
    /// Corresponds to `FPDFText_LoadCidType2Font`.
    pub fn load_cid_type2_font(
        &mut self,
        _font_data: &[u8],
        _to_unicode_cmap: Option<&[u8]>,
        _cid_to_gid_map: Option<&[u8]>,
        _is_cjk: bool,
    ) -> Result<FontRegistration, EditError> {
        Err(EditError::NotSupported(
            "load_cid_type2_font: CID Type2 font embedding not yet implemented".into(),
        ))
    }

    /// Returns the rotation of the page at `page_index` in degrees (0, 90, 180, or 270).
    ///
    /// Reads the `/Rotate` key from the page dictionary. Defaults to 0 if
    /// absent. Negative values are normalised via `rem_euclid(360)`.
    ///
    /// Corresponds to `FPDFPage_GetRotation`.
    pub fn page_rotation(&self, page_index: usize) -> Result<u32, EditError> {
        let page_id = self
            .page_ids
            .get(page_index)
            .copied()
            .ok_or(EditError::PageOutOfRange {
                index: page_index,
                count: self.page_ids.len(),
            })?;
        let page_obj = self.resolve(page_id)?;
        let dict = page_obj
            .as_dict()
            .ok_or(EditError::Other("page not a dict".into()))?;
        let rotate = dict
            .get(&Name::rotate())
            .and_then(|o| o.as_i64())
            .unwrap_or(0);
        Ok(rotate.rem_euclid(360) as u32)
    }

    /// Upstream-aligned alias for [`page_rotation()`](Self::page_rotation).
    ///
    /// Corresponds to `FPDFPage_GetRotation`.
    #[inline]
    pub fn page_get_rotation(&self, page_index: usize) -> Result<u32, EditError> {
        self.page_rotation(page_index)
    }

    /// Non-upstream alias — use [`page_get_rotation()`](Self::page_get_rotation).
    ///
    /// There is no upstream `FPDFPage_GetPageRotation`; the exact upstream
    /// function is `FPDFPage_GetRotation` → `page_get_rotation()`.
    #[deprecated(note = "use `page_get_rotation()` — matches upstream `FPDFPage_GetRotation`")]
    #[inline]
    pub fn get_page_rotation(&self, page_index: usize) -> Result<u32, EditError> {
        self.page_rotation(page_index)
    }

    /// Non-upstream alias — use [`page_get_rotation()`](Self::page_get_rotation).
    #[deprecated(note = "use `page_get_rotation()` — matches upstream `FPDFPage_GetRotation`")]
    #[inline]
    pub fn get_rotation(&self, page_index: usize) -> Result<u32, EditError> {
        self.page_rotation(page_index)
    }

    /// Update the /Kids array and /Count in the Pages dictionary.
    pub(crate) fn sync_pages_tree(&mut self) -> Result<(), EditError> {
        let pages_id = self.pages_id()?;
        // Collect page data before the mutable borrow of self via get_mut.
        let kids: Vec<Object> = self
            .page_ids
            .iter()
            .map(|id| Object::Reference(*id))
            .collect();
        let count = self.page_ids.len() as i64;

        let pages = self.get_mut(pages_id)?;
        let dict = pages
            .as_dict_mut()
            .ok_or(EditError::Other("pages node is not a dictionary".into()))?;
        dict.insert(Name::kids(), Object::Array(kids));
        dict.insert(Name::count(), Object::Integer(count));
        Ok(())
    }

    /// Add a new form field (with widget annotation) to the document.
    ///
    /// Creates both a field dictionary in the AcroForm `/Fields` array and a
    /// widget annotation on the target page's `/Annots` array.  Returns the
    /// object ID of the new field dictionary.
    ///
    /// If no AcroForm dictionary exists in the catalog it is created.
    pub fn add_form_field(&mut self, spec: FormFieldSpec) -> Result<ObjectId, EditError> {
        let count = self.page_count();
        if spec.page_index >= count {
            return Err(EditError::PageOutOfRange {
                index: spec.page_index,
                count,
            });
        }

        // --- Ensure AcroForm exists ---
        let acroform_id = self.ensure_acroform()?;

        // --- Create widget annotation dict ---
        let mut widget_dict = HashMap::new();
        widget_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"Annot".to_vec())),
        );
        widget_dict.insert(
            Name::subtype(),
            Object::Name(Name::from_bytes(b"Widget".to_vec())),
        );
        widget_dict.insert(
            Name::rect(),
            Object::Array(vec![
                Object::Real(spec.rect[0] as f64),
                Object::Real(spec.rect[1] as f64),
                Object::Real(spec.rect[2] as f64),
                Object::Real(spec.rect[3] as f64),
            ]),
        );
        let page_id = self.page_ids()[spec.page_index];
        widget_dict.insert(Name::p(), Object::Reference(page_id));
        let widget_id = self.add_object(Object::Dictionary(widget_dict));

        // --- Create field dict ---
        let mut field_dict = HashMap::new();
        field_dict.insert(Name::ft(), Object::Name(spec.field_type.clone()));
        field_dict.insert(
            Name::t(),
            Object::String(rpdfium_core::PdfString::from_bytes(
                spec.name.as_bytes().to_vec(),
            )),
        );
        field_dict.insert(
            Name::rect(),
            Object::Array(vec![
                Object::Real(spec.rect[0] as f64),
                Object::Real(spec.rect[1] as f64),
                Object::Real(spec.rect[2] as f64),
                Object::Real(spec.rect[3] as f64),
            ]),
        );
        if spec.flags != 0 {
            field_dict.insert(Name::ff(), Object::Integer(spec.flags as i64));
        }
        if let Some(ref dv) = spec.default_value {
            field_dict.insert(
                Name::dv(),
                Object::String(rpdfium_core::PdfString::from_bytes(dv.as_bytes().to_vec())),
            );
        }
        // Widget is the sole kid
        field_dict.insert(
            Name::from_bytes(b"Kids".to_vec()),
            Object::Array(vec![Object::Reference(widget_id)]),
        );
        let field_id = self.add_object(Object::Dictionary(field_dict));

        // --- Append to AcroForm /Fields ---
        {
            let acroform = self.get_mut(acroform_id)?;
            if let Object::Dictionary(dict) = acroform {
                let fields_key = Name::from_bytes(b"Fields".to_vec());
                let fields = dict
                    .entry(fields_key)
                    .or_insert_with(|| Object::Array(Vec::new()));
                if let Object::Array(arr) = fields {
                    arr.push(Object::Reference(field_id));
                }
            }
        }

        // --- Append widget to page /Annots ---
        {
            let page = self.get_mut(page_id)?;
            if let Object::Dictionary(dict) = page {
                let annots = dict
                    .entry(Name::annots())
                    .or_insert_with(|| Object::Array(Vec::new()));
                if let Object::Array(arr) = annots {
                    arr.push(Object::Reference(widget_id));
                }
            }
        }

        Ok(field_id)
    }

    /// Delete a form field (and its widget annotations) from the document.
    ///
    /// Finds the field in the AcroForm `/Fields` array by partial name (`/T`),
    /// removes its widget annotations from their pages' `/Annots` arrays, and
    /// deletes both the widget and field objects.
    pub fn delete_form_field(&mut self, field_name: &str) -> Result<(), EditError> {
        // --- Find field ID from AcroForm /Fields ---
        let catalog_id = self.catalog_id();
        let acroform_id = {
            let catalog = self.resolve(catalog_id)?;
            let dict = catalog
                .as_dict()
                .ok_or(EditError::Other("catalog is not a dict".into()))?;
            match dict.get(&Name::from_bytes(b"AcroForm".to_vec())) {
                Some(Object::Reference(id)) => *id,
                _ => {
                    return Err(EditError::FieldNotFound(field_name.to_string()));
                }
            }
        };

        let field_id = {
            let acroform = self.resolve(acroform_id)?;
            let adict = acroform
                .as_dict()
                .ok_or(EditError::Other("AcroForm is not a dict".into()))?;
            let fields_arr = adict
                .get(&Name::from_bytes(b"Fields".to_vec()))
                .and_then(|o| o.as_array())
                .ok_or(EditError::FieldNotFound(field_name.to_string()))?;

            let mut found_id: Option<ObjectId> = None;
            for item in fields_arr {
                if let Object::Reference(fid) = item {
                    if let Ok(fobj) = self.resolve(*fid) {
                        if let Some(fdict) = fobj.as_dict() {
                            let t_name = fdict
                                .get(&Name::t())
                                .and_then(|o| o.as_string())
                                .map(|s| String::from_utf8_lossy(s.as_bytes()).into_owned())
                                .unwrap_or_default();
                            if t_name == field_name {
                                found_id = Some(*fid);
                                break;
                            }
                        }
                    }
                }
            }
            found_id.ok_or(EditError::FieldNotFound(field_name.to_string()))?
        };

        // --- Collect widget IDs from /Kids ---
        let widget_ids: Vec<ObjectId> = {
            let field_obj = self.resolve(field_id)?;
            if let Some(fdict) = field_obj.as_dict() {
                fdict
                    .get(&Name::from_bytes(b"Kids".to_vec()))
                    .and_then(|o| o.as_array())
                    .map(|arr| arr.iter().filter_map(|o| o.as_reference()).collect())
                    .unwrap_or_default()
            } else {
                Vec::new()
            }
        };

        // --- Remove widgets from page /Annots ---
        for widget_id in &widget_ids {
            // Find which page contains this widget annotation
            let page_ids_clone: Vec<ObjectId> = self.page_ids.clone();
            for pid in &page_ids_clone {
                let page = self.get_mut(*pid)?;
                if let Object::Dictionary(dict) = page {
                    if let Some(Object::Array(annots)) = dict.get_mut(&Name::annots()) {
                        let wid = *widget_id;
                        annots.retain(|obj| {
                            if let Object::Reference(id) = obj {
                                *id != wid
                            } else {
                                true
                            }
                        });
                    }
                }
            }
        }

        // --- Delete widget objects ---
        for widget_id in widget_ids {
            self.delete_object(widget_id);
        }

        // --- Remove from AcroForm /Fields ---
        {
            let acroform = self.get_mut(acroform_id)?;
            if let Object::Dictionary(adict) = acroform {
                if let Some(Object::Array(fields)) =
                    adict.get_mut(&Name::from_bytes(b"Fields".to_vec()))
                {
                    fields.retain(|obj| {
                        if let Object::Reference(id) = obj {
                            *id != field_id
                        } else {
                            true
                        }
                    });
                }
            }
        }

        // --- Delete field object ---
        self.delete_object(field_id);
        Ok(())
    }

    /// Copy the `/ViewerPreferences` dictionary from `src` into this document.
    ///
    /// If `src` has no `/ViewerPreferences` entry in its catalog, this is a
    /// no-op.  Otherwise, the preferences object is cloned into this document
    /// and linked from the catalog.
    ///
    /// Corresponds to `FPDF_CopyViewerPreferences`.
    pub fn copy_viewer_preferences_from(&mut self, src: &EditDocument) -> Result<(), EditError> {
        let vp_key = Name::from_bytes(b"ViewerPreferences".to_vec());

        // Resolve ViewerPreferences from src catalog
        let src_catalog_id = src.catalog_id();
        let src_catalog = src.resolve(src_catalog_id)?;
        let src_dict = src_catalog
            .as_dict()
            .ok_or(EditError::Other("src catalog not a dict".into()))?;

        let vp_obj = match src_dict.get(&vp_key) {
            None => return Ok(()), // nothing to copy
            Some(Object::Reference(id)) => src.resolve(*id)?.clone(),
            Some(obj) => obj.clone(),
        };

        // Add the cloned viewer preferences to dest
        let vp_id = self.add_object(vp_obj);

        // Link from dest catalog
        let dest_catalog_id = self.catalog_id();
        let dest_catalog = self.get_mut(dest_catalog_id)?;
        if let Object::Dictionary(dict) = dest_catalog {
            dict.insert(vp_key, Object::Reference(vp_id));
        }

        Ok(())
    }

    /// Wraps a source page as a Form XObject in this document.
    ///
    /// Clones the source page's `/Resources` (deeply) and content bytes into
    /// `self`, creating a Form XObject stream.  Returns `(xobj_id, (width,
    /// height))` where the dimensions come from the source page's `/MediaBox`.
    ///
    /// The returned `xobj_id` can be passed to
    /// [`crate::page_object::FormObject::from_xobject`] to place the XObject
    /// on a page.
    ///
    /// Corresponds to `FPDF_NewXObjectFromPage`.
    pub fn new_xobject_from_page(
        &mut self,
        src: &EditDocument,
        src_page_index: usize,
    ) -> Result<(rpdfium_parser::object::ObjectId, (f64, f64)), EditError> {
        crate::cpdf_npagetooneexporter::make_xobject_from_page(src, src_page_index, self)
    }

    // -----------------------------------------------------------------------
    // Page box setters (FPDFPage_Set*Box)
    // -----------------------------------------------------------------------

    /// Set the `/MediaBox` of a page.
    ///
    /// Corresponds to `FPDFPage_SetMediaBox`.
    pub fn set_media_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_page_box(page_index, Name::media_box(), rect)
    }

    /// Upstream alias for [`EditDocument::set_media_box`].
    ///
    /// Tier-2 name for `FPDFPage_SetMediaBox`.
    #[inline]
    pub fn page_set_media_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_media_box(page_index, rect)
    }

    /// Set the `/CropBox` of a page.
    ///
    /// Corresponds to `FPDFPage_SetCropBox`.
    pub fn set_crop_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_page_box(page_index, Name::crop_box(), rect)
    }

    /// Upstream alias for [`EditDocument::set_crop_box`].
    ///
    /// Tier-2 name for `FPDFPage_SetCropBox`.
    #[inline]
    pub fn page_set_crop_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_crop_box(page_index, rect)
    }

    /// Set the `/BleedBox` of a page.
    ///
    /// Corresponds to `FPDFPage_SetBleedBox`.
    pub fn set_bleed_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_page_box(page_index, Name::bleed_box(), rect)
    }

    /// Upstream alias for [`EditDocument::set_bleed_box`].
    ///
    /// Tier-2 name for `FPDFPage_SetBleedBox`.
    #[inline]
    pub fn page_set_bleed_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_bleed_box(page_index, rect)
    }

    /// Set the `/TrimBox` of a page.
    ///
    /// Corresponds to `FPDFPage_SetTrimBox`.
    pub fn set_trim_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_page_box(page_index, Name::trim_box(), rect)
    }

    /// Upstream alias for [`EditDocument::set_trim_box`].
    ///
    /// Tier-2 name for `FPDFPage_SetTrimBox`.
    #[inline]
    pub fn page_set_trim_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_trim_box(page_index, rect)
    }

    /// Set the `/ArtBox` of a page.
    ///
    /// Corresponds to `FPDFPage_SetArtBox`.
    pub fn set_art_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_page_box(page_index, Name::art_box(), rect)
    }

    /// Upstream alias for [`EditDocument::set_art_box`].
    ///
    /// Tier-2 name for `FPDFPage_SetArtBox`.
    #[inline]
    pub fn page_set_art_box(
        &mut self,
        page_index: usize,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        self.set_art_box(page_index, rect)
    }

    /// Helper: write a named box key on the page dict as a four-element array.
    fn set_page_box(
        &mut self,
        page_index: usize,
        key: Name,
        rect: rpdfium_core::Rect,
    ) -> Result<(), EditError> {
        let page_id = self
            .page_ids
            .get(page_index)
            .copied()
            .ok_or(EditError::PageOutOfRange {
                index: page_index,
                count: self.page_ids.len(),
            })?;
        let page = self.get_mut(page_id)?;
        let dict = page
            .as_dict_mut()
            .ok_or(EditError::Other("page is not a dict".into()))?;
        dict.insert(
            key,
            Object::Array(vec![
                Object::Real(rect.left),
                Object::Real(rect.bottom),
                Object::Real(rect.right),
                Object::Real(rect.top),
            ]),
        );
        Ok(())
    }

    // -----------------------------------------------------------------------
    // Attachment mutation (FPDFDoc_AddAttachment / FPDFDoc_DeleteAttachment)
    // -----------------------------------------------------------------------

    /// Add a new empty file attachment to the document.
    ///
    /// Creates a `/Filespec` dictionary with the given name and an empty
    /// embedded file stream, then inserts it into the `/Names/EmbeddedFiles`
    /// name tree.  Returns the index of the new attachment in the name tree.
    ///
    /// Corresponds to `FPDFDoc_AddAttachment`.
    pub fn add_attachment(&mut self, name: &str) -> Result<usize, EditError> {
        // Create empty embedded file stream
        let mut stream_dict = HashMap::new();
        stream_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"EmbeddedFile".to_vec())),
        );
        let stream = Object::Stream {
            dict: stream_dict,
            data: rpdfium_parser::object::StreamData::Decoded { data: Vec::new() },
        };
        let stream_id = self.add_object(stream);

        // Create EF sub-dict
        let mut ef_dict = HashMap::new();
        ef_dict.insert(Name::f(), Object::Reference(stream_id));

        // Create Filespec dict
        let mut fs_dict = HashMap::new();
        fs_dict.insert(Name::r#type(), Object::Name(Name::file_spec_type()));
        fs_dict.insert(
            Name::uf(),
            Object::String(rpdfium_core::PdfString::from_bytes(
                name.as_bytes().to_vec(),
            )),
        );
        fs_dict.insert(
            Name::f(),
            Object::String(rpdfium_core::PdfString::from_bytes(
                name.as_bytes().to_vec(),
            )),
        );
        fs_dict.insert(Name::ef(), Object::Dictionary(ef_dict));
        let fs_id = self.add_object(Object::Dictionary(fs_dict));

        // Ensure /Names/EmbeddedFiles exists and add entry
        let ef_names_id = self.ensure_embedded_files()?;
        let ef_names = self.get_mut(ef_names_id)?;
        let dict = ef_names
            .as_dict_mut()
            .ok_or(EditError::Other("EmbeddedFiles is not a dict".into()))?;
        let names_key = Name::names();
        let names_arr = dict
            .entry(names_key)
            .or_insert_with(|| Object::Array(Vec::new()));
        if let Object::Array(arr) = names_arr {
            let index = arr.len() / 2;
            arr.push(Object::String(rpdfium_core::PdfString::from_bytes(
                name.as_bytes().to_vec(),
            )));
            arr.push(Object::Reference(fs_id));
            Ok(index)
        } else {
            Err(EditError::Other(
                "EmbeddedFiles/Names is not an array".into(),
            ))
        }
    }

    /// Non-upstream alias — use [`add_attachment()`](Self::add_attachment).
    ///
    /// There is no upstream `FPDFDoc_AddDocAttachment`; the exact upstream
    /// function is `FPDFDoc_AddAttachment` → `add_attachment()`.
    #[deprecated(note = "use `add_attachment()` — matches upstream FPDFDoc_AddAttachment")]
    #[inline]
    pub fn add_doc_attachment(&mut self, name: &str) -> Result<usize, EditError> {
        self.add_attachment(name)
    }

    /// Delete an attachment by index from the `/Names/EmbeddedFiles` name tree.
    ///
    /// Corresponds to `FPDFDoc_DeleteAttachment`.
    pub fn delete_attachment(&mut self, index: usize) -> Result<(), EditError> {
        let ef_names_id = self.find_embedded_files_id()?;
        let ef_names = self.get_mut(ef_names_id)?;
        let dict = ef_names
            .as_dict_mut()
            .ok_or(EditError::Other("EmbeddedFiles is not a dict".into()))?;
        let names_arr = dict
            .get_mut(&Name::names())
            .and_then(|o| {
                if let Object::Array(arr) = o {
                    Some(arr)
                } else {
                    None
                }
            })
            .ok_or(EditError::Other(
                "EmbeddedFiles/Names is not an array".into(),
            ))?;

        // Each entry is a name-value pair: [name0, ref0, name1, ref1, ...]
        let pair_start = index * 2;
        if pair_start + 1 >= names_arr.len() {
            return Err(EditError::Other(format!(
                "attachment index {index} out of range (have {} attachments)",
                names_arr.len() / 2
            )));
        }

        // Delete the referenced Filespec object
        if let Object::Reference(fs_id) = names_arr[pair_start + 1] {
            self.delete_object(fs_id);
        }

        // Re-borrow to remove from the array
        let ef_names = self.get_mut(ef_names_id)?;
        let dict = ef_names.as_dict_mut().unwrap();
        if let Some(Object::Array(arr)) = dict.get_mut(&Name::names()) {
            let pair_start = index * 2;
            if pair_start + 1 < arr.len() {
                arr.remove(pair_start + 1);
                arr.remove(pair_start);
            }
        }
        Ok(())
    }

    /// Non-upstream alias — use [`delete_attachment()`](Self::delete_attachment).
    ///
    /// There is no upstream `FPDFDoc_DeleteDocAttachment`; the exact upstream
    /// function is `FPDFDoc_DeleteAttachment` → `delete_attachment()`.
    #[deprecated(note = "use `delete_attachment()` — matches upstream FPDFDoc_DeleteAttachment")]
    #[inline]
    pub fn delete_doc_attachment(&mut self, index: usize) -> Result<(), EditError> {
        self.delete_attachment(index)
    }

    /// Returns `true` if the attachment at `index` has the given key in its
    /// `/Filespec` dictionary.
    ///
    /// Corresponds to `FPDFAttachment_HasKey`.
    pub fn attachment_has_key(&self, index: usize, key: &str) -> Result<bool, EditError> {
        let fs_dict = self.resolve_attachment_dict(index)?;
        Ok(fs_dict.contains_key(&Name::from_bytes(key.as_bytes().to_vec())))
    }

    /// Non-upstream alias — use [`attachment_has_key()`](Self::attachment_has_key).
    #[deprecated(note = "use `attachment_has_key()` — matches upstream `FPDFAttachment_HasKey`")]
    #[inline]
    pub fn has_key(&self, index: usize, key: &str) -> Result<bool, EditError> {
        self.attachment_has_key(index, key)
    }

    /// Returns the PDF object type name for a key in the attachment's
    /// `/Filespec` dictionary, or `None` if the key is absent.
    ///
    /// Type names: `"boolean"`, `"number"`, `"string"`, `"name"`, `"array"`,
    /// `"dictionary"`, `"stream"`, `"reference"`.
    ///
    /// Corresponds to `FPDFAttachment_GetValueType`.
    pub fn attachment_value_type(
        &self,
        index: usize,
        key: &str,
    ) -> Result<Option<&'static str>, EditError> {
        let fs_dict = self.resolve_attachment_dict(index)?;
        let name_key = Name::from_bytes(key.as_bytes().to_vec());
        match fs_dict.get(&name_key) {
            None => Ok(None),
            Some(obj) => Ok(Some(object_type_name(obj))),
        }
    }

    /// Upstream-aligned alias for [`attachment_value_type()`](Self::attachment_value_type).
    ///
    /// Corresponds to `FPDFAttachment_GetValueType`.
    #[inline]
    pub fn attachment_get_value_type(
        &self,
        index: usize,
        key: &str,
    ) -> Result<Option<&'static str>, EditError> {
        self.attachment_value_type(index, key)
    }

    /// Non-upstream alias — use [`attachment_get_value_type()`](Self::attachment_get_value_type).
    #[deprecated(
        note = "use `attachment_get_value_type()` — matches upstream `FPDFAttachment_GetValueType`"
    )]
    #[inline]
    pub fn get_value_type(
        &self,
        index: usize,
        key: &str,
    ) -> Result<Option<&'static str>, EditError> {
        self.attachment_value_type(index, key)
    }

    /// Non-upstream alias — use [`attachment_get_value_type()`](Self::attachment_get_value_type).
    ///
    /// There is no upstream `FPDFAttachment_GetAttachmentValueType`; the exact
    /// upstream function is `FPDFAttachment_GetValueType` → `attachment_get_value_type()`.
    #[deprecated(
        note = "use `attachment_get_value_type()` — matches upstream `FPDFAttachment_GetValueType`"
    )]
    #[inline]
    pub fn get_attachment_value_type(
        &self,
        index: usize,
        key: &str,
    ) -> Result<Option<&'static str>, EditError> {
        self.attachment_value_type(index, key)
    }

    /// Set a string value on the attachment's `/Filespec` dictionary.
    ///
    /// Corresponds to `FPDFAttachment_SetStringValue`.
    pub fn set_attachment_string(
        &mut self,
        index: usize,
        key: &str,
        value: &str,
    ) -> Result<(), EditError> {
        let fs_id = self.resolve_attachment_object_id(index)?;
        let fs_obj = self.get_mut(fs_id)?;
        let dict = fs_obj
            .as_dict_mut()
            .ok_or(EditError::Other("filespec is not a dict".into()))?;
        dict.insert(
            Name::from_bytes(key.as_bytes().to_vec()),
            Object::String(rpdfium_core::PdfString::from_bytes(
                value.as_bytes().to_vec(),
            )),
        );
        Ok(())
    }

    /// Upstream-aligned alias for [`set_attachment_string()`](Self::set_attachment_string).
    ///
    /// Corresponds to `FPDFAttachment_SetStringValue`.
    #[inline]
    pub fn attachment_set_string_value(
        &mut self,
        index: usize,
        key: &str,
        value: &str,
    ) -> Result<(), EditError> {
        self.set_attachment_string(index, key, value)
    }

    /// Non-upstream alias — use [`attachment_set_string_value()`](Self::attachment_set_string_value).
    #[deprecated(
        note = "use `attachment_set_string_value()` — matches upstream `FPDFAttachment_SetStringValue`"
    )]
    #[inline]
    pub fn set_string_value(
        &mut self,
        index: usize,
        key: &str,
        value: &str,
    ) -> Result<(), EditError> {
        self.set_attachment_string(index, key, value)
    }

    /// Get a string value from the attachment's `/Filespec` dictionary.
    ///
    /// Corresponds to `FPDFAttachment_GetStringValue`.
    pub fn attachment_string(&self, index: usize, key: &str) -> Result<Option<String>, EditError> {
        let fs_dict = self.resolve_attachment_dict(index)?;
        let name_key = Name::from_bytes(key.as_bytes().to_vec());
        Ok(fs_dict
            .get(&name_key)
            .and_then(|o| o.as_string())
            .map(|s| s.to_string_lossy()))
    }

    /// Upstream-aligned alias for [`attachment_string()`](Self::attachment_string).
    ///
    /// Corresponds to `FPDFAttachment_GetStringValue`.
    #[inline]
    pub fn attachment_get_string_value(
        &self,
        index: usize,
        key: &str,
    ) -> Result<Option<String>, EditError> {
        self.attachment_string(index, key)
    }

    /// Non-upstream alias — use [`attachment_get_string_value()`](Self::attachment_get_string_value).
    #[deprecated(
        note = "use `attachment_get_string_value()` — matches upstream `FPDFAttachment_GetStringValue`"
    )]
    #[inline]
    pub fn get_string_value(&self, index: usize, key: &str) -> Result<Option<String>, EditError> {
        self.attachment_string(index, key)
    }

    /// Non-upstream alias — use [`attachment_get_string_value()`](Self::attachment_get_string_value).
    ///
    /// There is no upstream `FPDFAttachment_GetAttachmentString`; the exact
    /// upstream function is `FPDFAttachment_GetStringValue` → `attachment_get_string_value()`.
    #[deprecated(
        note = "use `attachment_get_string_value()` — matches upstream `FPDFAttachment_GetStringValue`"
    )]
    #[inline]
    pub fn get_attachment_string(
        &self,
        index: usize,
        key: &str,
    ) -> Result<Option<String>, EditError> {
        self.attachment_string(index, key)
    }

    /// Set the content data for an attachment's embedded file stream.
    ///
    /// Writes raw bytes into the `/EF /F` stream of the attachment at `index`.
    ///
    /// Corresponds to `FPDFAttachment_SetFile`.
    pub fn set_attachment_file(&mut self, index: usize, data: &[u8]) -> Result<(), EditError> {
        // Get the EF/F stream reference from the Filespec dict
        let stream_id = {
            let fs_dict = self.resolve_attachment_dict(index)?;
            let ef_obj = fs_dict
                .get(&Name::ef())
                .ok_or(EditError::Other("filespec missing /EF".into()))?;
            let ef_dict = ef_obj
                .as_dict()
                .ok_or(EditError::Other("/EF is not a dict".into()))?;
            ef_dict
                .get(&Name::f())
                .and_then(|o| o.as_reference())
                .ok_or(EditError::Other("/EF/F is not a reference".into()))?
        };

        // Replace stream content
        let mut stream_dict = HashMap::new();
        stream_dict.insert(
            Name::r#type(),
            Object::Name(Name::from_bytes(b"EmbeddedFile".to_vec())),
        );
        let stream = Object::Stream {
            dict: stream_dict,
            data: rpdfium_parser::object::StreamData::Decoded {
                data: data.to_vec(),
            },
        };
        self.set_object(stream_id, stream);
        Ok(())
    }

    /// Upstream-aligned alias for [`set_attachment_file()`](Self::set_attachment_file).
    ///
    /// Corresponds to `FPDFAttachment_SetFile`.
    #[inline]
    pub fn attachment_set_file(&mut self, index: usize, data: &[u8]) -> Result<(), EditError> {
        self.set_attachment_file(index, data)
    }

    /// Non-upstream alias — use [`attachment_set_file()`](Self::attachment_set_file).
    #[deprecated(note = "use `attachment_set_file()` — matches upstream `FPDFAttachment_SetFile`")]
    #[inline]
    pub fn set_file(&mut self, index: usize, data: &[u8]) -> Result<(), EditError> {
        self.set_attachment_file(index, data)
    }

    /// Return the raw content bytes of the embedded file stream at `index`.
    ///
    /// Reads the `/EF /F` stream from the attachment's `/Filespec` dictionary
    /// and returns the decoded stream bytes.  Returns `Ok(None)` if the
    /// attachment exists but has no embedded file stream.
    ///
    /// Corresponds to `FPDFAttachment_GetFile`.
    pub fn attachment_file(&self, index: usize) -> Result<Option<Vec<u8>>, EditError> {
        let fs_dict = self.resolve_attachment_dict(index)?;
        let ef_obj = match fs_dict.get(&Name::ef()) {
            Some(o) => o.clone(),
            None => return Ok(None),
        };
        let ef_dict = match ef_obj.as_dict() {
            Some(d) => d.clone(),
            None => return Ok(None),
        };
        let stream_id = match ef_dict.get(&Name::f()).and_then(|o| o.as_reference()) {
            Some(id) => id,
            None => return Ok(None),
        };
        // Clone the stream object to avoid holding a borrow on `self` across
        // the `decode_stream` call below.
        let stream_obj = self.resolve(stream_id)?.clone();
        match &stream_obj {
            Object::Stream { data, .. } => match data {
                StreamData::Decoded { data } => Ok(Some(data.clone())),
                StreamData::Raw { .. } => {
                    // decode_stream takes &Object; stream_obj is a local owned clone.
                    self.decode_stream(&stream_obj).map(Some)
                }
            },
            _ => Ok(None),
        }
    }

    /// Upstream-aligned alias for [`attachment_file()`](Self::attachment_file).
    ///
    /// Corresponds to `FPDFAttachment_GetFile`.
    #[inline]
    pub fn attachment_get_file(&self, index: usize) -> Result<Option<Vec<u8>>, EditError> {
        self.attachment_file(index)
    }

    /// Non-upstream alias — use [`attachment_get_file()`](Self::attachment_get_file).
    ///
    /// Corresponds to `FPDFAttachment_GetFile`.
    #[deprecated(note = "use `attachment_get_file()` — matches upstream `FPDFAttachment_GetFile`")]
    #[inline]
    pub fn get_file(&self, index: usize) -> Result<Option<Vec<u8>>, EditError> {
        self.attachment_file(index)
    }

    // -----------------------------------------------------------------------
    // Attachment helpers
    // -----------------------------------------------------------------------

    /// Find the ObjectId of the `/Names/EmbeddedFiles` name tree dict.
    fn find_embedded_files_id(&self) -> Result<ObjectId, EditError> {
        let catalog_id = self.catalog_id();
        let catalog = self.resolve(catalog_id)?;
        let catalog_dict = catalog
            .as_dict()
            .ok_or(EditError::Other("catalog is not a dict".into()))?;

        let names_ref = catalog_dict
            .get(&Name::names())
            .and_then(|o| o.as_reference())
            .ok_or(EditError::Other("catalog missing /Names reference".into()))?;

        let names_obj = self.resolve(names_ref)?;
        let names_dict = names_obj
            .as_dict()
            .ok_or(EditError::Other("/Names is not a dict".into()))?;

        names_dict
            .get(&Name::embedded_files())
            .and_then(|o| o.as_reference())
            .ok_or(EditError::Other("/Names missing /EmbeddedFiles".into()))
    }

    /// Ensure `/Names/EmbeddedFiles` name tree exists in the catalog.
    fn ensure_embedded_files(&mut self) -> Result<ObjectId, EditError> {
        let catalog_id = self.catalog_id();
        let catalog = self.resolve(catalog_id)?;
        let catalog_dict = catalog
            .as_dict()
            .ok_or(EditError::Other("catalog is not a dict".into()))?;

        // Check if /Names already exists
        let names_id = if let Some(Object::Reference(id)) = catalog_dict.get(&Name::names()) {
            *id
        } else {
            // Create /Names dict
            let names_dict = HashMap::new();
            let id = self.add_object(Object::Dictionary(names_dict));
            let catalog_mut = self.get_mut(catalog_id)?;
            if let Object::Dictionary(d) = catalog_mut {
                d.insert(Name::names(), Object::Reference(id));
            }
            id
        };

        // Check if /EmbeddedFiles exists in /Names
        let names_obj = self.resolve(names_id)?;
        let names_dict = names_obj
            .as_dict()
            .ok_or(EditError::Other("/Names is not a dict".into()))?;

        if let Some(Object::Reference(ef_id)) = names_dict.get(&Name::embedded_files()) {
            Ok(*ef_id)
        } else {
            // Create EmbeddedFiles name tree
            let mut ef_dict = HashMap::new();
            ef_dict.insert(Name::names(), Object::Array(Vec::new()));
            let ef_id = self.add_object(Object::Dictionary(ef_dict));

            let names_mut = self.get_mut(names_id)?;
            if let Object::Dictionary(d) = names_mut {
                d.insert(Name::embedded_files(), Object::Reference(ef_id));
            }
            Ok(ef_id)
        }
    }

    /// Resolve the Filespec dictionary for the attachment at `index`.
    fn resolve_attachment_dict(&self, index: usize) -> Result<HashMap<Name, Object>, EditError> {
        let fs_id = self.resolve_attachment_object_id(index)?;
        let fs_obj = self.resolve(fs_id)?;
        fs_obj
            .as_dict()
            .cloned()
            .ok_or(EditError::Other("filespec is not a dict".into()))
    }

    /// Get the ObjectId of the Filespec at `index` in the EmbeddedFiles name tree.
    fn resolve_attachment_object_id(&self, index: usize) -> Result<ObjectId, EditError> {
        let ef_names_id = self.find_embedded_files_id()?;
        let ef_names = self.resolve(ef_names_id)?;
        let dict = ef_names
            .as_dict()
            .ok_or(EditError::Other("EmbeddedFiles is not a dict".into()))?;
        let names_arr =
            dict.get(&Name::names())
                .and_then(|o| o.as_array())
                .ok_or(EditError::Other(
                    "EmbeddedFiles/Names is not an array".into(),
                ))?;

        let pair_start = index * 2;
        if pair_start + 1 >= names_arr.len() {
            return Err(EditError::Other(format!(
                "attachment index {index} out of range (have {} attachments)",
                names_arr.len() / 2
            )));
        }

        names_arr[pair_start + 1]
            .as_reference()
            .ok_or(EditError::Other(
                "attachment value is not a reference".into(),
            ))
    }

    /// Ensure an AcroForm dictionary exists in the catalog, creating it if
    /// absent.  Returns the `ObjectId` of the AcroForm dictionary.
    fn ensure_acroform(&mut self) -> Result<ObjectId, EditError> {
        let catalog_id = self.catalog_id();
        let catalog = self.resolve(catalog_id)?;
        let acroform_key = Name::from_bytes(b"AcroForm".to_vec());

        // Check if AcroForm already present as a reference
        if let Some(Object::Reference(id)) = catalog.as_dict().and_then(|d| d.get(&acroform_key)) {
            return Ok(*id);
        }

        // Create a new AcroForm dict
        let mut acroform_dict = HashMap::new();
        acroform_dict.insert(
            Name::from_bytes(b"Fields".to_vec()),
            Object::Array(Vec::new()),
        );
        let acroform_id = self.add_object(Object::Dictionary(acroform_dict));

        // Link it from the catalog
        let catalog_mut = self.get_mut(catalog_id)?;
        if let Object::Dictionary(dict) = catalog_mut {
            dict.insert(acroform_key, Object::Reference(acroform_id));
        }
        Ok(acroform_id)
    }
}

/// Returns a human-readable type name for a PDF object.
fn object_type_name(obj: &Object) -> &'static str {
    match obj {
        Object::Boolean(_) => "boolean",
        Object::Integer(_) | Object::Real(_) => "number",
        Object::String(_) => "string",
        Object::Name(_) => "name",
        Object::Array(_) => "array",
        Object::Dictionary(_) => "dictionary",
        Object::Stream { .. } => "stream",
        Object::Reference(_) => "reference",
        Object::Null => "null",
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_new_blank_has_catalog_and_pages() {
        let doc = EditDocument::new_blank();
        assert_eq!(doc.catalog_id(), ObjectId::new(1, 0));
        assert_eq!(doc.page_count(), 0);
        assert!(doc.is_dirty());

        // Can resolve catalog
        let catalog = doc.resolve(doc.catalog_id()).unwrap();
        let dict = catalog.as_dict().unwrap();
        assert!(dict.contains_key(&Name::r#type()));

        // Can resolve pages
        let pages_ref = dict.get(&Name::pages()).unwrap();
        if let Object::Reference(pages_id) = pages_ref {
            let pages = doc.resolve(*pages_id).unwrap();
            let pdict = pages.as_dict().unwrap();
            assert_eq!(pdict.get(&Name::count()).and_then(|o| o.as_i64()), Some(0));
        } else {
            panic!("expected reference to Pages");
        }
    }

    #[test]
    fn test_add_object_returns_unique_ids() {
        let mut doc = EditDocument::new_blank();
        let id1 = doc.add_object(Object::Integer(1));
        let id2 = doc.add_object(Object::Integer(2));
        assert_ne!(id1, id2);

        let obj1 = doc.resolve(id1).unwrap();
        assert_eq!(obj1.as_i64(), Some(1));
        let obj2 = doc.resolve(id2).unwrap();
        assert_eq!(obj2.as_i64(), Some(2));
    }

    #[test]
    fn test_delete_object_makes_unresolvable() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Integer(42));
        assert!(doc.resolve(id).is_ok());

        doc.delete_object(id);
        assert!(doc.resolve(id).is_err());
    }

    #[test]
    fn test_set_object_replaces_value() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Integer(1));
        doc.set_object(id, Object::Integer(2));

        let obj = doc.resolve(id).unwrap();
        assert_eq!(obj.as_i64(), Some(2));
    }

    #[test]
    fn test_get_mut_modifies_in_place() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Integer(1));
        let obj = doc.get_mut(id).unwrap();
        *obj = Object::Integer(99);

        let resolved = doc.resolve(id).unwrap();
        assert_eq!(resolved.as_i64(), Some(99));
    }

    #[test]
    fn test_all_ids_includes_all_non_deleted() {
        let mut doc = EditDocument::new_blank();
        let id1 = doc.add_object(Object::Integer(1));
        let id2 = doc.add_object(Object::Integer(2));
        doc.delete_object(id2);

        let all = doc.all_ids();
        assert!(all.contains(&id1));
        assert!(!all.contains(&id2));
        // Should include catalog and pages
        assert!(all.contains(&ObjectId::new(1, 0)));
        assert!(all.contains(&ObjectId::new(2, 0)));
    }

    #[test]
    fn test_changed_ids_lists_modifications() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Integer(42));

        let changed: Vec<ObjectId> = doc.changed_ids().collect();
        // Should include catalog, pages, and the new object
        assert!(changed.contains(&id));
    }

    #[test]
    fn test_pages_id_resolves_from_catalog() {
        let doc = EditDocument::new_blank();
        let pages_id = doc.pages_id().unwrap();
        assert_eq!(pages_id, ObjectId::new(2, 0));
    }

    #[test]
    fn test_sync_pages_tree_updates_kids() {
        let mut doc = EditDocument::new_blank();
        let page_id = ObjectId::new(10, 0);
        doc.page_ids_mut().push(page_id);
        doc.new_objects.insert(
            page_id,
            Object::Dictionary({
                let mut d = HashMap::new();
                d.insert(
                    Name::r#type(),
                    Object::Name(Name::from_bytes(b"Page".to_vec())),
                );
                d
            }),
        );
        doc.sync_pages_tree().unwrap();

        let pages_id = doc.pages_id().unwrap();
        let pages = doc.resolve(pages_id).unwrap();
        let dict = pages.as_dict().unwrap();
        assert_eq!(dict.get(&Name::count()).and_then(|o| o.as_i64()), Some(1));
        let kids = dict.get(&Name::kids()).and_then(|o| o.as_array()).unwrap();
        assert_eq!(kids.len(), 1);
    }

    #[test]
    fn test_allocate_id_increments() {
        let mut doc = EditDocument::new_blank();
        let first = doc.next_object_number();
        let id1 = doc.allocate_id();
        assert_eq!(id1.number, first);
        let id2 = doc.allocate_id();
        assert_eq!(id2.number, first + 1);
    }

    #[test]
    fn test_deleted_ids_tracked() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Null);
        assert!(doc.deleted_ids().is_empty());
        doc.delete_object(id);
        assert!(doc.deleted_ids().contains(&id));
    }

    // ------------------------------------------------------------------
    // Font loading tests
    // ------------------------------------------------------------------

    #[test]
    fn test_load_standard_font_creates_font_object() {
        let mut doc = EditDocument::new_blank();
        let reg = doc.load_standard_font("Helvetica").unwrap();

        // The returned registration holds a valid object ID
        assert!(reg.object_id.number > 0);

        // The object is resolvable and is a Font dictionary
        let obj = doc.resolve(reg.object_id).unwrap();
        let dict = obj.as_dict().unwrap();

        let subtype = dict
            .get(&Name::from_bytes(b"Subtype".to_vec()))
            .and_then(|o| o.as_name())
            .map(|n| n.as_bytes().to_vec());
        assert_eq!(subtype, Some(b"Type1".to_vec()));

        let base = dict
            .get(&Name::from_bytes(b"BaseFont".to_vec()))
            .and_then(|o| o.as_name())
            .map(|n| n.as_bytes().to_vec());
        assert_eq!(base, Some(b"Helvetica".to_vec()));
    }

    #[test]
    fn test_load_font_from_data_creates_embedded_objects() {
        let mut doc = EditDocument::new_blank();
        let initial_count = doc.all_ids().len();

        // Minimal fake font bytes
        let fake_data = b"FAKE_TRUETYPE_DATA_BYTES";
        let reg = doc
            .load_font_from_data(fake_data, crate::font_reg::FontType::TrueType, false)
            .unwrap();

        // Three new objects: stream + descriptor + font
        let new_count = doc.all_ids().len();
        assert_eq!(new_count, initial_count + 3);

        // The Font dict is resolvable
        let font_obj = doc.resolve(reg.object_id).unwrap();
        let font_dict = font_obj.as_dict().unwrap();
        let subtype = font_dict
            .get(&Name::from_bytes(b"Subtype".to_vec()))
            .and_then(|o| o.as_name())
            .map(|n| n.as_bytes().to_vec());
        assert_eq!(subtype, Some(b"TrueType".to_vec()));
    }

    // ------------------------------------------------------------------
    // copy_viewer_preferences_from tests
    // ------------------------------------------------------------------

    #[test]
    fn test_copy_viewer_preferences_from_noop_when_src_has_none() {
        let src = EditDocument::new_blank();
        let mut dest = EditDocument::new_blank();
        // src has no /ViewerPreferences — should be a no-op
        dest.copy_viewer_preferences_from(&src).unwrap();
        // dest catalog should not have /ViewerPreferences
        let catalog = dest.resolve(dest.catalog_id()).unwrap();
        let dict = catalog.as_dict().unwrap();
        assert!(!dict.contains_key(&Name::from_bytes(b"ViewerPreferences".to_vec())));
    }

    #[test]
    fn test_copy_viewer_preferences_from_copies_dict() {
        let mut src = EditDocument::new_blank();

        // Add ViewerPreferences to src catalog
        let vp_key = Name::from_bytes(b"ViewerPreferences".to_vec());
        let fit_window_key = Name::from_bytes(b"FitWindow".to_vec());
        let mut vp_dict = std::collections::HashMap::new();
        vp_dict.insert(fit_window_key.clone(), Object::Boolean(true));
        let vp_id = src.add_object(Object::Dictionary(vp_dict));
        let catalog_id = src.catalog_id();
        let catalog = src.get_mut(catalog_id).unwrap();
        if let Object::Dictionary(dict) = catalog {
            dict.insert(vp_key.clone(), Object::Reference(vp_id));
        }

        let mut dest = EditDocument::new_blank();
        dest.copy_viewer_preferences_from(&src).unwrap();

        // dest catalog should now have /ViewerPreferences
        let dest_catalog = dest.resolve(dest.catalog_id()).unwrap();
        let dest_dict = dest_catalog.as_dict().unwrap();
        let vp_ref = dest_dict
            .get(&vp_key)
            .expect("/ViewerPreferences not found");

        // Resolve the copied object
        let new_vp_id = match vp_ref {
            Object::Reference(id) => *id,
            _ => panic!("expected reference"),
        };
        let new_vp = dest.resolve(new_vp_id).unwrap();
        let new_vp_dict = new_vp.as_dict().unwrap();
        assert_eq!(
            new_vp_dict.get(&fit_window_key).and_then(|o| o.as_bool()),
            Some(true)
        );
    }

    #[test]
    fn test_load_font_from_data_cid_true_returns_error() {
        let mut doc = EditDocument::new_blank();
        let result = doc.load_font_from_data(b"data", crate::font_reg::FontType::TrueType, true);
        assert!(result.is_err());
        assert!(matches!(result, Err(EditError::NotSupported(_))));
    }

    // ------------------------------------------------------------------
    // Fix D: Page box setters
    // ------------------------------------------------------------------

    #[test]
    fn test_set_media_box_updates_page_dict() {
        use rpdfium_core::Rect;
        let mut doc = EditDocument::new_blank();
        doc.add_page(Rect::new(0.0, 0.0, 612.0, 792.0));
        doc.set_media_box(0, Rect::new(10.0, 20.0, 600.0, 780.0))
            .unwrap();
        let page_id = doc.page_id(0).unwrap();
        let page = doc.resolve(page_id).unwrap();
        let dict = page.as_dict().unwrap();
        let arr = dict.get(&Name::media_box()).unwrap().as_array().unwrap();
        assert_eq!(arr[0].as_f64(), Some(10.0));
        assert_eq!(arr[1].as_f64(), Some(20.0));
        assert_eq!(arr[2].as_f64(), Some(600.0));
        assert_eq!(arr[3].as_f64(), Some(780.0));
    }

    #[test]
    fn test_set_crop_box_updates_page_dict() {
        use rpdfium_core::Rect;
        let mut doc = EditDocument::new_blank();
        doc.add_page(Rect::new(0.0, 0.0, 612.0, 792.0));
        doc.set_crop_box(0, Rect::new(5.0, 5.0, 607.0, 787.0))
            .unwrap();
        let page_id = doc.page_id(0).unwrap();
        let page = doc.resolve(page_id).unwrap();
        let dict = page.as_dict().unwrap();
        assert!(dict.contains_key(&Name::crop_box()));
    }

    #[test]
    fn test_set_bleed_box_updates_page_dict() {
        use rpdfium_core::Rect;
        let mut doc = EditDocument::new_blank();
        doc.add_page(Rect::new(0.0, 0.0, 612.0, 792.0));
        doc.set_bleed_box(0, Rect::new(-3.0, -3.0, 615.0, 795.0))
            .unwrap();
        let page_id = doc.page_id(0).unwrap();
        let page = doc.resolve(page_id).unwrap();
        let dict = page.as_dict().unwrap();
        assert!(dict.contains_key(&Name::bleed_box()));
    }

    #[test]
    fn test_set_trim_box_updates_page_dict() {
        use rpdfium_core::Rect;
        let mut doc = EditDocument::new_blank();
        doc.add_page(Rect::new(0.0, 0.0, 595.0, 842.0));
        doc.set_trim_box(0, Rect::new(8.0, 8.0, 587.0, 834.0))
            .unwrap();
        let page_id = doc.page_id(0).unwrap();
        let page = doc.resolve(page_id).unwrap();
        let dict = page.as_dict().unwrap();
        assert!(dict.contains_key(&Name::trim_box()));
    }

    #[test]
    fn test_set_art_box_updates_page_dict() {
        use rpdfium_core::Rect;
        let mut doc = EditDocument::new_blank();
        doc.add_page(Rect::new(0.0, 0.0, 595.0, 842.0));
        doc.set_art_box(0, Rect::new(12.0, 12.0, 583.0, 830.0))
            .unwrap();
        let page_id = doc.page_id(0).unwrap();
        let page = doc.resolve(page_id).unwrap();
        let dict = page.as_dict().unwrap();
        assert!(dict.contains_key(&Name::art_box()));
    }

    #[test]
    fn test_set_page_box_out_of_range_returns_error() {
        use rpdfium_core::Rect;
        let mut doc = EditDocument::new_blank();
        assert!(
            doc.set_media_box(0, Rect::new(0.0, 0.0, 612.0, 792.0))
                .is_err()
        );
    }

    #[test]
    fn test_get_page_rotation_default_zero() {
        let mut doc = EditDocument::new_blank();
        doc.add_page(rpdfium_core::Rect::new(0.0, 0.0, 612.0, 792.0));
        assert_eq!(doc.page_rotation(0).unwrap(), 0);
    }

    #[test]
    fn test_get_page_rotation_after_set() {
        let mut doc = EditDocument::new_blank();
        doc.add_page(rpdfium_core::Rect::new(0.0, 0.0, 612.0, 792.0));
        doc.page_set_rotation(0, 90).unwrap();
        assert_eq!(doc.page_rotation(0).unwrap(), 90);
    }

    #[test]
    fn test_get_page_rotation_out_of_range() {
        let doc = EditDocument::new_blank();
        assert!(doc.page_rotation(0).is_err());
    }

    // ------------------------------------------------------------------
    // B2: Font registration populates flags for embedded fonts
    // ------------------------------------------------------------------

    #[test]
    fn test_load_standard_font_returns_flags_and_weight() {
        let mut doc = EditDocument::new_blank();
        let reg = doc.load_standard_font("Helvetica").unwrap();
        assert_eq!(reg.flags(), Some(32));
        assert_eq!(reg.weight(), Some(400));
    }

    #[test]
    fn test_load_font_from_data_returns_flags_and_weight() {
        let mut doc = EditDocument::new_blank();
        let fake_data = b"FAKE_TRUETYPE_DATA";
        let reg = doc
            .load_font_from_data(fake_data, crate::font_reg::FontType::TrueType, false)
            .unwrap();
        // The Symbolic flag (4) is set in the FontDescriptor created by load_font_from_data
        assert_eq!(reg.flags(), Some(4));
        // Default weight (400) is set
        assert_eq!(reg.weight(), Some(400));
    }

    // -----------------------------------------------------------------------
    // Attachment mutation tests
    // -----------------------------------------------------------------------

    #[test]
    fn test_add_attachment_creates_embedded_file() {
        let mut doc = EditDocument::new_blank();
        let idx = doc.add_attachment("test.pdf").unwrap();
        assert_eq!(idx, 0);

        // Verify the attachment exists and has the right name
        let name = doc.attachment_string(0, "UF").unwrap();
        assert_eq!(name.as_deref(), Some("test.pdf"));
        let name_f = doc.attachment_string(0, "F").unwrap();
        assert_eq!(name_f.as_deref(), Some("test.pdf"));
    }

    #[test]
    fn test_add_multiple_attachments() {
        let mut doc = EditDocument::new_blank();
        let idx0 = doc.add_attachment("a.pdf").unwrap();
        let idx1 = doc.add_attachment("b.pdf").unwrap();
        assert_eq!(idx0, 0);
        assert_eq!(idx1, 1);

        assert_eq!(
            doc.attachment_string(0, "UF").unwrap().as_deref(),
            Some("a.pdf")
        );
        assert_eq!(
            doc.attachment_string(1, "UF").unwrap().as_deref(),
            Some("b.pdf")
        );
    }

    #[test]
    fn test_delete_attachment_removes_entry() {
        let mut doc = EditDocument::new_blank();
        doc.add_attachment("a.pdf").unwrap();
        doc.add_attachment("b.pdf").unwrap();

        doc.delete_attachment(0).unwrap();

        // After deleting index 0, what was index 1 is now index 0
        assert_eq!(
            doc.attachment_string(0, "UF").unwrap().as_deref(),
            Some("b.pdf")
        );
        // Index 1 should be out of range
        assert!(doc.attachment_string(1, "UF").is_err());
    }

    #[test]
    fn test_delete_attachment_out_of_range_returns_error() {
        let mut doc = EditDocument::new_blank();
        doc.add_attachment("a.pdf").unwrap();
        assert!(doc.delete_attachment(5).is_err());
    }

    #[test]
    fn test_attachment_has_key_returns_correct_result() {
        let mut doc = EditDocument::new_blank();
        doc.add_attachment("test.pdf").unwrap();

        assert!(doc.attachment_has_key(0, "UF").unwrap());
        assert!(doc.attachment_has_key(0, "F").unwrap());
        assert!(doc.attachment_has_key(0, "EF").unwrap());
        assert!(!doc.attachment_has_key(0, "NonExistent").unwrap());
    }

    #[test]
    fn test_attachment_value_type_returns_correct_type() {
        let mut doc = EditDocument::new_blank();
        doc.add_attachment("test.pdf").unwrap();

        assert_eq!(doc.attachment_value_type(0, "UF").unwrap(), Some("string"));
        assert_eq!(doc.attachment_value_type(0, "Type").unwrap(), Some("name"));
        assert_eq!(
            doc.attachment_value_type(0, "EF").unwrap(),
            Some("dictionary")
        );
        assert_eq!(doc.attachment_value_type(0, "NoSuchKey").unwrap(), None);
    }

    #[test]
    fn test_set_attachment_string_writes_value() {
        let mut doc = EditDocument::new_blank();
        doc.add_attachment("test.pdf").unwrap();

        doc.set_attachment_string(0, "Desc", "A test file").unwrap();
        assert_eq!(
            doc.attachment_string(0, "Desc").unwrap().as_deref(),
            Some("A test file")
        );
    }

    #[test]
    fn test_set_attachment_file_writes_data() {
        let mut doc = EditDocument::new_blank();
        doc.add_attachment("test.txt").unwrap();

        doc.set_attachment_file(0, b"Hello, World!").unwrap();

        // Verify the stream was replaced — we can check by resolving
        // the /EF /F reference and checking the stream data
        let fs_dict = doc.resolve_attachment_dict(0).unwrap();
        let ef_dict = fs_dict.get(&Name::ef()).unwrap().as_dict().unwrap();
        let stream_id = ef_dict.get(&Name::f()).unwrap().as_reference().unwrap();
        let stream_obj = doc.resolve(stream_id).unwrap();
        if let Object::Stream {
            data: rpdfium_parser::object::StreamData::Decoded { data },
            ..
        } = stream_obj
        {
            assert_eq!(data, b"Hello, World!");
        } else {
            panic!("expected decoded stream");
        }
    }

    #[test]
    fn test_attachment_index_out_of_range_returns_error() {
        let doc = EditDocument::new_blank();
        // No attachments exist, so index 0 should fail
        assert!(doc.attachment_string(0, "UF").is_err());
        assert!(doc.attachment_has_key(0, "UF").is_err());
    }

    // ===================================================================
    // Upstream-ported mutation tests
    // ===================================================================

    /// Upstream: PDFObjectsTest::SetString
    ///
    /// Test setting string value via edit API.
    #[test]
    fn test_set_string_value() {
        use rpdfium_core::PdfString;
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::String(PdfString::from_bytes(b"hello".to_vec())));
        doc.set_object(id, Object::String(PdfString::from_bytes(b"world".to_vec())));
        let obj = doc.resolve(id).unwrap();
        assert_eq!(
            obj.as_string().map(|s| s.as_bytes()),
            Some(b"world".as_slice())
        );
    }

    /// Upstream: PDFObjectsTest::Clone
    ///
    /// Deep-clone via Rust Clone trait.
    #[test]
    fn test_object_clone() {
        use rpdfium_core::PdfString;
        let original = Object::Dictionary({
            let mut d = HashMap::new();
            d.insert(
                Name::from_bytes(b"Key".to_vec()),
                Object::String(PdfString::from_bytes(b"Value".to_vec())),
            );
            d.insert(
                Name::from_bytes(b"Array".to_vec()),
                Object::Array(vec![Object::Integer(1), Object::Integer(2)]),
            );
            d
        });
        let cloned = original.clone();
        // Object doesn't implement PartialEq; verify structure manually
        let orig_dict = original.as_dict().unwrap();
        let clone_dict = cloned.as_dict().unwrap();
        assert_eq!(orig_dict.len(), clone_dict.len());
        assert!(clone_dict.contains_key(&Name::from_bytes(b"Key".to_vec())));
        assert!(clone_dict.contains_key(&Name::from_bytes(b"Array".to_vec())));
    }

    /// Upstream: PDFArrayTest::AddNumber, AddInteger, AddStringAndName
    ///
    /// Build arrays with different value types.
    #[test]
    fn test_array_building() {
        use rpdfium_core::PdfString;
        let mut doc = EditDocument::new_blank();

        // Add numbers
        let arr = Object::Array(vec![
            Object::Integer(1),
            Object::Integer(2),
            Object::Real(3.14),
        ]);
        let id = doc.add_object(arr);
        let obj = doc.resolve(id).unwrap();
        let a = obj.as_array().unwrap();
        assert_eq!(a.len(), 3);
        assert_eq!(a[0].as_i64(), Some(1));
        assert_eq!(a[1].as_i64(), Some(2));
        assert!((a[2].as_f64().unwrap() - 3.14).abs() < 0.01);

        // Add string and name
        let arr2 = Object::Array(vec![
            Object::String(PdfString::from_bytes(b"test".to_vec())),
            Object::Name(Name::from_bytes(b"Name1".to_vec())),
        ]);
        let id2 = doc.add_object(arr2);
        let obj2 = doc.resolve(id2).unwrap();
        let a2 = obj2.as_array().unwrap();
        assert_eq!(
            a2[0].as_string().map(|s| s.as_bytes()),
            Some(b"test".as_slice())
        );
        assert_eq!(
            a2[1].as_name().map(|n| n.as_bytes()),
            Some(b"Name1".as_slice())
        );
    }

    /// Upstream: PDFArrayTest::AddReferenceAndGetObjectAt
    ///
    /// Add indirect reference + retrieve.
    #[test]
    fn test_array_add_reference_and_get() {
        let mut doc = EditDocument::new_blank();
        let target_id = doc.add_object(Object::Integer(42));
        let arr = Object::Array(vec![Object::Reference(target_id)]);
        let arr_id = doc.add_object(arr);

        let obj = doc.resolve(arr_id).unwrap();
        let a = obj.as_array().unwrap();
        assert_eq!(a.len(), 1);
        match &a[0] {
            Object::Reference(ref_id) => {
                let resolved = doc.resolve(*ref_id).unwrap();
                assert_eq!(resolved.as_i64(), Some(42));
            }
            _ => panic!("expected reference"),
        }
    }

    /// Upstream: PDFStreamTest::SetData, SetDataAndRemoveFilter
    ///
    /// Stream data replacement.
    #[test]
    fn test_stream_set_data() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Stream {
            dict: {
                let mut d = HashMap::new();
                d.insert(Name::from_bytes(b"Length".to_vec()), Object::Integer(5));
                d
            },
            data: StreamData::Decoded {
                data: b"hello".to_vec(),
            },
        });

        // Replace stream data
        doc.set_object(
            id,
            Object::Stream {
                dict: {
                    let mut d = HashMap::new();
                    d.insert(Name::from_bytes(b"Length".to_vec()), Object::Integer(5));
                    d
                },
                data: StreamData::Decoded {
                    data: b"world".to_vec(),
                },
            },
        );

        let obj = doc.resolve(id).unwrap();
        if let Object::Stream {
            data: StreamData::Decoded { data },
            ..
        } = obj
        {
            assert_eq!(data, b"world");
        } else {
            panic!("expected decoded stream");
        }
    }

    /// Upstream: PDFDictionaryTest::CloneDirectObject
    ///
    /// Clone a dictionary and verify independence.
    #[test]
    fn test_dictionary_clone_direct() {
        use rpdfium_core::PdfString;
        let mut doc = EditDocument::new_blank();
        let mut d = HashMap::new();
        d.insert(Name::from_bytes(b"Key1".to_vec()), Object::Integer(1));
        d.insert(
            Name::from_bytes(b"Key2".to_vec()),
            Object::String(PdfString::from_bytes(b"val".to_vec())),
        );
        let id = doc.add_object(Object::Dictionary(d));

        let obj = doc.resolve(id).unwrap().clone();
        let dict = obj.as_dict().unwrap();
        assert_eq!(
            dict.get(&Name::from_bytes(b"Key1".to_vec()))
                .and_then(|o| o.as_i64()),
            Some(1)
        );

        // Modify original, clone should be unaffected
        doc.set_object(id, Object::Integer(99));
        let original = doc.resolve(id).unwrap();
        assert_eq!(original.as_i64(), Some(99));
        // Our clone is still a dictionary
        assert!(dict.contains_key(&Name::from_bytes(b"Key1".to_vec())));
    }

    /// Upstream: PDFArrayTest::RemoveAt, Clear, InsertAt, Clone
    ///
    /// Array mutation operations via edit API.
    #[test]
    fn test_array_mutations() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Array(vec![
            Object::Integer(10),
            Object::Integer(20),
            Object::Integer(30),
        ]));

        // Remove at index 1 (value 20)
        let obj = doc.get_mut(id).unwrap();
        if let Object::Array(arr) = obj {
            arr.remove(1);
        }
        let obj = doc.resolve(id).unwrap();
        let a = obj.as_array().unwrap();
        assert_eq!(a.len(), 2);
        assert_eq!(a[0].as_i64(), Some(10));
        assert_eq!(a[1].as_i64(), Some(30));

        // Insert at index 1
        let obj = doc.get_mut(id).unwrap();
        if let Object::Array(arr) = obj {
            arr.insert(1, Object::Integer(25));
        }
        let obj = doc.resolve(id).unwrap();
        let a = obj.as_array().unwrap();
        assert_eq!(a.len(), 3);
        assert_eq!(a[1].as_i64(), Some(25));

        // Clear
        let obj = doc.get_mut(id).unwrap();
        if let Object::Array(arr) = obj {
            arr.clear();
        }
        let obj = doc.resolve(id).unwrap();
        let a = obj.as_array().unwrap();
        assert!(a.is_empty());

        // Clone array
        let arr_obj = Object::Array(vec![Object::Integer(1), Object::Integer(2)]);
        let cloned = arr_obj.clone();
        let ca = cloned.as_array().unwrap();
        assert_eq!(ca.len(), 2);
        assert_eq!(ca[0].as_i64(), Some(1));
        assert_eq!(ca[1].as_i64(), Some(2));
    }

    /// Upstream: PDFObjectTest::CloneCheckLoop
    ///
    /// Clone cycle detection — a reference to itself should not cause infinite recursion.
    #[test]
    fn test_clone_does_not_stack_overflow() {
        let mut doc = EditDocument::new_blank();
        // Create a self-referential structure
        let id = doc.allocate_id();
        let obj = Object::Array(vec![Object::Reference(id)]);
        doc.new_objects.insert(id, obj);

        // Cloning the object should work fine since Clone is structural,
        // not a deep-resolve operation
        let resolved = doc.resolve(id).unwrap();
        let cloned = resolved.clone();
        if let Object::Array(arr) = &cloned {
            assert_eq!(arr.len(), 1);
            assert!(matches!(&arr[0], Object::Reference(r) if *r == id));
        } else {
            panic!("expected array");
        }
    }

    /// Upstream: PDFReferenceTest::MakeReferenceToReference
    ///
    /// A reference to a reference should be resolvable.
    #[test]
    fn test_reference_to_reference() {
        let mut doc = EditDocument::new_blank();
        let inner_id = doc.add_object(Object::Integer(42));
        let outer_id = doc.add_object(Object::Reference(inner_id));

        // Resolve outer reference → should get the Reference object
        let outer = doc.resolve(outer_id).unwrap();
        match outer {
            Object::Reference(ref_id) => {
                let inner = doc.resolve(*ref_id).unwrap();
                assert_eq!(inner.as_i64(), Some(42));
            }
            _ => panic!("expected reference object"),
        }
    }

    /// Upstream: PDFStreamTest::SetDataAndRemoveFilter
    ///
    /// Replace stream data and strip the Filter/DecodeParms keys.
    #[test]
    fn test_stream_set_data_and_remove_filter() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Stream {
            dict: {
                let mut d = HashMap::new();
                d.insert(Name::from_bytes(b"Length".to_vec()), Object::Integer(5));
                d.insert(
                    Name::from_bytes(b"Filter".to_vec()),
                    Object::Name(Name::from_bytes(b"FlateDecode".to_vec())),
                );
                d.insert(
                    Name::from_bytes(b"DecodeParms".to_vec()),
                    Object::Dictionary(HashMap::new()),
                );
                d
            },
            data: StreamData::Decoded {
                data: b"hello".to_vec(),
            },
        });

        // Replace data and remove filter
        let obj = doc.get_mut(id).unwrap();
        if let Object::Stream { dict, data } = obj {
            *data = StreamData::Decoded {
                data: b"new data without filter".to_vec(),
            };
            dict.remove(&Name::from_bytes(b"Filter".to_vec()));
            dict.remove(&Name::from_bytes(b"DecodeParms".to_vec()));
            dict.insert(Name::from_bytes(b"Length".to_vec()), Object::Integer(23));
        }

        let obj = doc.resolve(id).unwrap();
        if let Object::Stream { dict, data } = obj {
            // Filter and DecodeParms should be removed
            assert!(
                !dict.contains_key(&Name::from_bytes(b"Filter".to_vec())),
                "Filter should be removed"
            );
            assert!(
                !dict.contains_key(&Name::from_bytes(b"DecodeParms".to_vec())),
                "DecodeParms should be removed"
            );
            // Length updated
            assert_eq!(
                dict.get(&Name::from_bytes(b"Length".to_vec()))
                    .and_then(|o| o.as_i64()),
                Some(23)
            );
            if let StreamData::Decoded { data: d } = data {
                assert_eq!(d, b"new data without filter");
            } else {
                panic!("expected decoded stream");
            }
        } else {
            panic!("expected stream");
        }
    }

    /// Upstream: PDFStreamTest::LengthInDictionaryOnCreate
    ///
    /// In upstream, stream objects auto-set the Length key on creation.
    /// rpdfium does not auto-set Length — it must be set explicitly.
    /// This test documents the behavior.
    #[test]
    fn test_stream_length_in_dictionary() {
        let mut doc = EditDocument::new_blank();
        // Create stream with explicit Length
        let id = doc.add_object(Object::Stream {
            dict: {
                let mut d = HashMap::new();
                d.insert(Name::from_bytes(b"Length".to_vec()), Object::Integer(100));
                d
            },
            data: StreamData::Decoded {
                data: vec![0u8; 100],
            },
        });
        let obj = doc.resolve(id).unwrap();
        if let Object::Stream { dict, .. } = obj {
            assert_eq!(
                dict.get(&Name::from_bytes(b"Length".to_vec()))
                    .and_then(|o| o.as_i64()),
                Some(100)
            );
        } else {
            panic!("expected stream");
        }
    }

    /// Upstream: PDFObjectsTest::MakeReferenceGeneric
    ///
    /// Creating a reference to an existing object.
    #[test]
    fn test_make_reference() {
        let mut doc = EditDocument::new_blank();
        let target_id = doc.add_object(Object::Integer(42));
        // Create a reference to the target
        let ref_obj = Object::Reference(target_id);
        let ref_id = doc.add_object(ref_obj);
        let resolved = doc.resolve(ref_id).unwrap();
        match resolved {
            Object::Reference(id) => {
                assert_eq!(*id, target_id);
                let inner = doc.resolve(*id).unwrap();
                assert_eq!(inner.as_i64(), Some(42));
            }
            _ => panic!("expected reference"),
        }
    }

    /// Upstream: PDFDictionaryTest::ExtractObjectOnRemove
    ///
    /// Remove a key from dictionary and retrieve the removed value.
    #[test]
    fn test_extract_object_on_remove() {
        let mut doc = EditDocument::new_blank();
        let id = doc.add_object(Object::Dictionary({
            let mut d = HashMap::new();
            d.insert(Name::from_bytes(b"child".to_vec()), Object::Integer(42));
            d
        }));
        let obj = doc.get_mut(id).unwrap();
        if let Object::Dictionary(dict) = obj {
            let removed = dict.remove(&Name::from_bytes(b"child".to_vec()));
            assert!(removed.is_some());
            assert_eq!(removed.unwrap().as_i64(), Some(42));
            // Removing non-existent key returns None
            let missing = dict.remove(&Name::from_bytes(b"non_exists".to_vec()));
            assert!(missing.is_none());
        }
    }

    /// Upstream: PDFDictionaryTest::ConvertIndirect
    ///
    /// In rpdfium, all objects in EditDocument are already indirect.
    /// This test verifies the equivalent: replacing a direct dict value
    /// with a reference to a newly created indirect object.
    #[test]
    fn test_convert_to_indirect() {
        let mut doc = EditDocument::new_blank();
        let dict_id = doc.add_object(Object::Dictionary({
            let mut d = HashMap::new();
            d.insert(Name::from_bytes(b"clams".to_vec()), Object::Integer(42));
            d
        }));
        // "Convert to indirect": extract value, make it an indirect object,
        // and replace the dict entry with a reference
        let value_id = doc.add_object(Object::Integer(42));
        let obj = doc.get_mut(dict_id).unwrap();
        if let Object::Dictionary(dict) = obj {
            dict.insert(
                Name::from_bytes(b"clams".to_vec()),
                Object::Reference(value_id),
            );
        }
        // Verify the dict entry is now a reference
        let obj = doc.resolve(dict_id).unwrap();
        let dict = obj.as_dict().unwrap();
        let entry = dict.get(&Name::from_bytes(b"clams".to_vec())).unwrap();
        assert!(entry.is_reference());
        // Resolve the reference to get the original value
        if let Object::Reference(ref_id) = entry {
            let resolved = doc.resolve(*ref_id).unwrap();
            assert_eq!(resolved.as_i64(), Some(42));
        }
    }
}