use std::sync::Arc;

use pdfcraft_cos::{Document, Object, SaveOptions, write_incremental};

use super::*;

/// One page with a form: text fields (plain, multiline, comb, password, read-only, nested),
/// a check box with appearances, one without, a radio group, a combo and a multi-select list,
/// and a push button.
fn fixture() -> Document {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),                                             // 1
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),                              // 2
        "<< /Type /Page /Parent 2 0 R /Annots [10 0 R 11 0 R 12 0 R 13 0 R 14 0 R 16 0 R 17 0 R 21 0 R 22 0 R 23 0 R 24 0 R 25 0 R 26 0 R] >>".into(), // 3
        "<< /Fields [10 0 R 11 0 R 12 0 R 13 0 R 14 0 R 15 0 R 17 0 R 20 0 R 23 0 R 24 0 R 25 0 R 26 0 R] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 5 0 R /ZaDb 6 0 R >> >> >>".into(), // 4
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(),               // 5
        "<< /Type /Font /Subtype /Type1 /BaseFont /ZapfDingbats >>".into(),                                      // 6
        "<< /Length 0 >>\nstream\n\nendstream".into(),                                                            // 7 (empty appearance)
        "<< /Length 0 >>\nstream\n\nendstream".into(),                                                            // 8
        "null".into(),                                                                                            // 9
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (name) /Rect [50 700 250 720] /P 3 0 R /V (Ada) /DV (Ada) /MK << /BG [1 1 0.9] /BC [0 0 0] >> >>".into(), // 10
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (notes) /Ff 4096 /DA (/Helv 10 Tf 0 0 1 rg) /Rect [50 600 250 680] /P 3 0 R >>".into(), // 11
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (zip) /Ff 16777216 /MaxLen 5 /Rect [50 560 150 580] /P 3 0 R >>".into(), // 12
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (pin) /Ff 8192 /Rect [50 530 150 550] /P 3 0 R >>".into(), // 13
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (id) /Ff 1 /V (A-1) /Rect [50 500 150 520] /P 3 0 R >>".into(), // 14
        "<< /T (address) /Kids [16 0 R] >>".into(),                                                               // 15
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (city) /Parent 15 0 R /Q 1 /Rect [50 470 250 490] /P 3 0 R >>".into(), // 16
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (agree) /V /Off /AS /Off /Rect [300 700 315 715] /P 3 0 R /AP << /N << /Yes 7 0 R /Off 8 0 R >> >> >>".into(), // 17
        "null".into(),                                                                                            // 18
        "null".into(),                                                                                            // 19
        "<< /FT /Btn /T (size) /Ff 49152 /V /Off /DV /S /Kids [21 0 R 22 0 R] >>".into(),                        // 20 radio, NoToggleToOff
        "<< /Type /Annot /Subtype /Widget /Parent 20 0 R /AS /Off /Rect [300 650 315 665] /P 3 0 R /AP << /N << /S 7 0 R /Off 8 0 R >> >> >>".into(), // 21
        "<< /Type /Annot /Subtype /Widget /Parent 20 0 R /AS /Off /Rect [330 650 345 665] /P 3 0 R /AP << /N << /L 7 0 R /Off 8 0 R >> >> >>".into(), // 22
        "<< /Type /Annot /Subtype /Widget /FT /Ch /T (country) /Ff 131072 /Opt [[(ca) (Canada)] [(fr) (France)]] /Rect [300 600 450 620] /P 3 0 R >>".into(), // 23
        "<< /Type /Annot /Subtype /Widget /FT /Ch /T (toppings) /Ff 2097152 /Opt [(Cheese) (Ham) (Olives)] /Rect [300 500 450 580] /P 3 0 R >>".into(), // 24
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (go) /Ff 65536 /Rect [300 450 380 470] /P 3 0 R >>".into(), // 25
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (bare) /Rect [400 700 415 715] /P 3 0 R /Foo (kept) >>".into(), // 26 check box without AP
    ];
    document(&objs)
}

/// A PDF of the given objects (numbered from 1).
fn document(objs: &[String]) -> Document {
    let mut out = b"%PDF-1.7\n".to_vec();
    let mut offsets = Vec::new();
    for (i, o) in objs.iter().enumerate() {
        offsets.push(out.len());
        out.extend_from_slice(format!("{} 0 obj\n{o}\nendobj\n", i + 1).as_bytes());
    }
    let xref = out.len();
    out.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", objs.len() + 1).as_bytes());
    for o in offsets {
        out.extend_from_slice(format!("{o:010} 00000 n \n").as_bytes());
    }
    out.extend_from_slice(format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", objs.len() + 1).as_bytes());
    Document::open(Arc::new(out)).expect("opens")
}

fn reopen(doc: &Document) -> Document {
    let bytes = write_incremental(doc, &SaveOptions::default()).expect("writes");
    hayro_syntax::Pdf::new(bytes.clone()).expect("hayro-syntax parses the output");
    Document::open(Arc::new(bytes)).expect("reopens")
}

fn legacy_two_call_enumeration(doc: &Document) -> (Vec<Field>, usize) {
    (enumerate(doc).0, enumerate(doc).1)
}

fn assert_combined_matches_legacy(doc: &Document, adopted: usize) {
    let (old_fields, old_adopted) = legacy_two_call_enumeration(doc);
    let combined = fields_with_adopted(doc);
    assert_eq!(combined.items, old_fields);
    assert_eq!(combined.adopted_page_fields, old_adopted);
    assert_eq!(combined.adopted_page_fields, adopted);
    assert_eq!(fields(doc), old_fields, "the compatibility wrapper keeps the old fields");
    assert_eq!(adopted_page_fields(doc), old_adopted, "the compatibility wrapper keeps the old count");
}

fn field<'a>(all: &'a [Field], name: &str) -> &'a Field {
    all.iter().find(|f| f.name == name).unwrap_or_else(|| panic!("no field {name}"))
}

fn ap(doc: &Document, w: &Widget) -> String {
    let wd = doc.get(w.obj).as_dict().cloned().unwrap();
    let n = wd.get(b"AP").unwrap().as_dict().unwrap().reference(b"N").expect("normal appearance stream");
    let Object::Stream(s) = &*doc.get(n) else { panic!() };
    String::from_utf8_lossy(&s.decoded().unwrap()).into_owned()
}

#[test]
fn button_caption_preserves_other_widgets_and_shared_dictionaries() {
    for indirect_caption in [false, true] {
        let mut doc = one_page();
        let a = add_field(&mut doc, 0, [40.0, 600.0, 200.0, 630.0], &NewField::Button { caption: "Original".into() }, Some("first")).unwrap();
        let b = add_field(&mut doc, 0, [40.0, 500.0, 200.0, 530.0], &NewField::Button { caption: "Original".into() }, Some("second")).unwrap();
        let all = fields(&doc);
        let (first, second) = (field(&all, &a).obj, field(&all, &b).obj);
        let mut parent = Dict::new();
        parent.set(b"FT".to_vec(), Object::name("Btn"));
        parent.set(b"Ff".to_vec(), Object::Int(flags::PUSH_BUTTON as i64));
        parent.set(b"T".to_vec(), PdfString::text("clear_button"));
        parent.set(b"Kids".to_vec(), Object::Array(vec![Object::Ref(first), Object::Ref(second)]));
        let mut action = Dict::new();
        action.set(b"S".to_vec(), Object::name("ResetForm"));
        parent.set(b"A".to_vec(), Object::Dict(action.clone()));
        let parent = doc.add(parent);
        let mut mk = Dict::new();
        let ca = Object::String(PdfString::text("Original"));
        let ca = if indirect_caption { Object::Ref(doc.add(ca)) } else { ca };
        mk.set(b"CA".to_vec(), ca);
        mk.set(b"TP".to_vec(), Object::Int(0));
        mk.set(b"R".to_vec(), Object::Int(90));
        mk.set(b"VendorNote".to_vec(), PdfString::text("kept"));
        let mk = doc.add(mk);
        let mut shared_ap = doc.get(first).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().clone();
        let normal = shared_ap.get(b"N").unwrap().clone();
        shared_ap.set(b"R".to_vec(), normal.clone());
        shared_ap.set(b"D".to_vec(), normal);
        shared_ap.set(b"VendorAP".to_vec(), PdfString::text("kept"));
        let shared_ap = doc.add(shared_ap);
        for widget in [first, second] {
            doc.update_dict(widget, |d| {
                for key in [b"FT".as_slice(), b"Ff", b"T"] {
                    d.remove(key);
                }
                d.set(b"Parent".to_vec(), Object::Ref(parent));
                d.set(b"MK".to_vec(), Object::Ref(mk));
                d.set(b"AP".to_vec(), Object::Ref(shared_ap));
            })
            .unwrap();
        }
        let af = doc.get(doc.root().unwrap()).as_dict().unwrap().reference(b"AcroForm").unwrap();
        doc.update_dict(af, |d| d.set(b"Fields".to_vec(), Object::Array(vec![Object::Ref(parent)]))).unwrap();
        let original = pdfcraft_cos::write_full(&doc, &SaveOptions::default()).unwrap();
        let original = Document::open(Arc::new(original)).unwrap();
        // Full saves can renumber objects: reacquire references from the reopened model.
        let f = field(&fields(&original), "clear_button").clone();
        let first = f.widgets[0].obj;
        let mk = original.get(first).as_dict().unwrap().reference(b"MK").unwrap();
        for full in [false, true] {
            let mut doc = original.clone();
            let untouched = doc.get(first).clone();
            let shared_mk = doc.get(mk).clone();
            assert_eq!(field(&fields(&doc), "clear_button").widgets[1].caption.as_deref(), Some("Original"));
            set_props(&mut doc, "clear_button", &FieldProps { caption: Some((1, "Clear Form".into())), ..Default::default() }).unwrap();
            assert_eq!(doc.get(first), untouched, "the other widget and all its appearances are untouched");
            assert_eq!(doc.get(mk), shared_mk, "shared MK is not patched in place");
            let bytes = if full {
                pdfcraft_cos::write_full(&doc, &SaveOptions::default()).unwrap()
            } else {
                let bytes = write_incremental(&doc, &SaveOptions::default()).unwrap();
                assert!(bytes.starts_with(original.bytes().as_slice()));
                assert!(bytes.len() > original.bytes().len());
                bytes
            };
            let doc = Document::open(Arc::new(bytes)).unwrap();
            let f = field(&fields(&doc), "clear_button").clone();
            assert_eq!(f.widgets.iter().map(|w| w.caption.as_deref()).collect::<Vec<_>>(), [Some("Original"), Some("Clear Form")]);
            assert_eq!(f.button, Some(af::ButtonAction::Reset { fields: Vec::new(), exclude: false }));
            assert_eq!(doc.get(f.obj).as_dict().unwrap().get(b"A"), Some(&Object::Dict(action.clone())));
            let w = doc.get(f.widgets[1].obj);
            let mk = w.as_dict().unwrap().get(b"MK").unwrap().as_dict().unwrap();
            assert_eq!(mk.get(b"VendorNote").unwrap().as_string().unwrap().to_text(), "kept");
            assert_eq!(mk.get(b"R").unwrap().as_int(), Some(90));
            assert_eq!(mk.get(b"TP").unwrap().as_int(), Some(0));
            let apd = w.as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap();
            assert!(apd.contains(b"VendorAP"));
            assert!(!apd.contains(b"R") && !apd.contains(b"D"), "stale hover/pressed text must not survive");
            assert!(ap(&doc, &f.widgets[1]).contains("(Clear Form) Tj"));
        }
    }
}

#[test]
fn button_caption_rejects_wrong_type_and_index_before_mutation() {
    let mut doc = fixture();
    for (name, wi) in [("name", 0), ("agree", 0), ("go", usize::MAX)] {
        let before = pdfcraft_cos::write_full(&doc, &SaveOptions::default()).unwrap();
        let props = FieldProps { caption: Some((wi, "Clear Form".into())), name: Some("renamed".into()), ..Default::default() };
        assert!(set_props(&mut doc, name, &props).is_err());
        assert_eq!(pdfcraft_cos::write_full(&doc, &SaveOptions::default()).unwrap(), before);
    }
    set_props(&mut doc, "go", &FieldProps { caption: Some((0, "提交".into())), ..Default::default() }).unwrap();
    assert_eq!(field(&fields(&doc), "go").widgets[0].caption.as_deref(), Some("提交"));
    assert_eq!(undrawn_fields(&doc), [("go".to_string(), '提')]);
    set_props(&mut doc, "go", &FieldProps { caption: Some((0, String::new())), ..Default::default() }).unwrap();
    assert_eq!(field(&fields(&doc), "go").widgets[0].caption.as_deref(), Some(""));
    assert!(undrawn_fields(&doc).is_empty());
    assert!(!ap(&doc, &field(&fields(&doc), "go").widgets[0]).contains(" Tj"));
}

/// Read the drawn strings together with the appearance's actual font after saving and reopening.
fn appearance_text(doc: &Document, w: &Widget, font_name: &[u8]) -> (Object, Vec<Vec<u8>>) {
    let widget = doc.get(w.obj);
    let normal = widget.as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
    let appearance = doc.get(normal);
    let Object::Stream(stream) = appearance.as_ref() else { panic!("appearance stream") };
    let resources = doc.resolve(stream.dict.get(b"Resources").unwrap());
    let fonts = doc.resolve(resources.as_dict().unwrap().get(b"Font").unwrap());
    let font = doc.resolve(fonts.as_dict().unwrap().get(font_name).unwrap());
    let shown = pdfcraft_content::parse(&stream.decoded().unwrap())
        .ops
        .into_iter()
        .filter(|op| op.is("Tj"))
        .map(|op| op.operands[0].as_string().unwrap().bytes.clone())
        .collect();
    (font.as_ref().clone(), shown)
}

#[test]
fn the_field_tree_is_read_with_inheritance() {
    let doc = fixture();
    assert_combined_matches_legacy(&doc, 0);
    let all = fields(&doc);
    let names: Vec<&str> = all.iter().map(|f| f.name.as_str()).collect();
    assert_eq!(names, ["name", "notes", "zip", "pin", "id", "address.city", "agree", "size", "country", "toppings", "go", "bare"]);
    let name = field(&all, "name");
    assert_eq!((name.kind, name.value.as_slice(), name.da.as_str()), (FieldKind::Text, &["Ada".to_string()][..], "/Helv 0 Tf 0 g"));
    assert_eq!(name.widgets[0].page, Some(0));
    assert_eq!(field(&all, "zip").max_len, Some(5));
    assert!(field(&all, "id").read_only());
    let size = field(&all, "size");
    assert_eq!(size.kind, FieldKind::Radio);
    assert_eq!(size.widgets.iter().map(|w| w.on_state.clone().unwrap()).collect::<Vec<_>>(), ["S", "L"]);
    assert!(size.value.is_empty(), "/Off is no value");
    assert_eq!(size.default, ["S"]);
    assert_eq!(field(&all, "country").options, [("ca".into(), "Canada".into()), ("fr".into(), "France".into())]);
    assert_eq!(field(&all, "toppings").kind, FieldKind::List);
    assert_eq!(field(&all, "go").kind, FieldKind::PushButton);
    assert_eq!(field(&all, "address.city").quadding, 1);
}

#[test]
fn field_flags_reject_values_outside_the_unsigned_32_bit_domain() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [] >>".into(),
        "<< /Fields [5 0 R 6 0 R 7 0 R 8 0 R 9 0 R] >>".into(),
        "<< /FT /Btn /T (valid) /Ff 65536 >>".into(),
        "<< /FT /Btn /T (negative) /Ff -1 >>".into(),
        "<< /FT /Btn /T (overflow) /Ff 4295032832 >>".into(),
        "<< /FT /Btn /T (wrong_type) /Ff (65536) >>".into(),
        "<< /FT /Btn /T (missing) >>".into(),
    ];
    let all = fields(&document(&objs));
    assert_eq!(field(&all, "valid").kind, FieldKind::PushButton);
    assert_eq!(field(&all, "valid").flags, flags::PUSH_BUTTON);
    for name in ["negative", "overflow", "wrong_type", "missing"] {
        assert_eq!(field(&all, name).kind, FieldKind::CheckBox, "{name}");
        assert_eq!(field(&all, name).flags, 0, "{name}");
    }
}

/// Some writers leave every field out of `/Fields` and put the widgets only in the page
/// annotations: the tree walk alone finds nothing, and Acrobat and the browsers fill them anyway.
/// The pages' widgets are adopted as fields, after the listed tree fields.
#[test]
fn fields_listed_only_on_the_pages_are_adopted() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),                 // 1
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(), // 2
        "<< /Type /Page /Parent 2 0 R /Annots [5 0 R 10 0 R 11 0 R 13 0 R 14 0 R 15 0 R] >>".into(), // 3
        "<< /Fields [5 0 R] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 6 0 R >> >> >>".into(), // 4
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (listed) /V (keep) /Rect [50 700 250 720] /P 3 0 R >>".into(), // 5
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(), // 6
        "null".into(),                                                              // 7
        "null".into(),                                                              // 8
        "null".into(),                                                              // 9
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (alpha) /V (one) /Rect [50 600 250 620] /P 3 0 R >>".into(), // 10
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (beta) /DA (/Helv 9 Tf 0 g) /Rect [50 560 250 580] /P 3 0 R >>".into(), // 11
        "<< /FT /Tx /T (pair) /Kids [13 0 R 14 0 R] >>".into(),                     // 12 unlisted parent field
        "<< /Type /Annot /Subtype /Widget /Parent 12 0 R /Rect [50 500 150 520] /P 3 0 R >>".into(), // 13 its widget
        "<< /Type /Annot /Subtype /Widget /Parent 12 0 R /Rect [50 460 150 480] /P 3 0 R >>".into(), // 14 its other widget
        "<< /Type /Annot /Subtype /Widget /Rect [400 700 415 715] /P 3 0 R >>".into(), // 15 no /FT, /T or /Parent: not a field
    ];
    let mut doc = document(&objs);
    assert_combined_matches_legacy(&doc, 3);
    let all = fields(&doc);
    let names: Vec<&str> = all.iter().map(|f| f.name.as_str()).collect();
    assert_eq!(names, ["listed", "alpha", "beta", "pair"]);
    assert_eq!(adopted_page_fields(&doc), 3);
    let alpha = field(&all, "alpha");
    assert_eq!((alpha.kind, alpha.value.as_slice(), alpha.widgets[0].page), (FieldKind::Text, &["one".to_string()][..], Some(0)));
    assert_eq!(field(&all, "beta").da, "/Helv 9 Tf 0 g");
    assert_eq!(field(&all, "pair").widgets.len(), 2, "one field carries both widgets");
    // They are filled and keep the value across a save.
    set_value(&mut doc, "beta", &FieldValue::Text("typed".into())).unwrap();
    assert!(ap(&doc, &field(&fields(&doc), "beta").widgets[0]).contains("typed"));
    let doc = reopen(&doc);
    assert_eq!(field(&fields(&doc), "beta").value, ["typed"]);
    // Without a /Fields list at all, everything on the pages is adopted.
    let mut objs = objs;
    objs[3] = "<< /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 6 0 R >> >> >>".into();
    let doc = document(&objs);
    assert_combined_matches_legacy(&doc, 4);
    let all = fields(&doc);
    let names: Vec<&str> = all.iter().map(|f| f.name.as_str()).collect();
    assert_eq!(names, ["listed", "alpha", "beta", "pair"]);
    assert_eq!(adopted_page_fields(&doc), 4);
}

/// pdf-lib and other writers give radio groups and check boxes an `/Opt` array and name the on
/// states by position (`/0`, `/1`): the export values select them, as in Acrobat.
#[test]
fn opt_export_values_select_button_states() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),                                                // 1
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),                                 // 2
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R 7 0 R 8 0 R] >>".into(),                                       // 3
        "<< /Fields [5 0 R 8 0 R] /DA (/Helv 0 Tf 0 g) >>".into(),                                                 // 4
        "<< /FT /Btn /T (ship) /Ff 49152 /Opt [(Post) (Pick-up)] /V /Off /Kids [6 0 R 7 0 R] >>".into(),            // 5 radio
        "<< /Type /Annot /Subtype /Widget /Parent 5 0 R /AS /Off /Rect [100 700 115 715] /P 3 0 R /AP << /N << /0 9 0 R /Off 10 0 R >> >> >>".into(), // 6
        "<< /Type /Annot /Subtype /Widget /Parent 5 0 R /AS /Off /Rect [200 700 215 715] /P 3 0 R /AP << /N << /1 9 0 R /Off 10 0 R >> >> >>".into(), // 7
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (terms) /Opt [(Accepted)] /V /Off /AS /Off /Rect [100 650 115 665] /P 3 0 R /AP << /N << /0 9 0 R /Off 10 0 R >> >> >>".into(), // 8 check box
        "<< /Length 0 >>\nstream\n\nendstream".into(),                                                              // 9
        "<< /Length 0 >>\nstream\n\nendstream".into(),                                                              // 10
    ];
    let mut doc = document(&objs);
    let all = fields(&doc);
    let ship = field(&all, "ship");
    assert_eq!((0..2).map(|i| ship.export_of(i)).collect::<Vec<_>>(), [Some("Post"), Some("Pick-up")]);
    assert_eq!((ship.state_for("Pick-up"), ship.state_for("1"), ship.state_for("Courier")), (Some("1"), Some("1"), None));
    set_value(&mut doc, "ship", &FieldValue::Radio(Some("Pick-up".into()))).unwrap();
    set_value(&mut doc, "terms", &FieldValue::Text("Accepted".into())).unwrap();
    let mut doc = reopen(&doc);
    let all = fields(&doc);
    let ship = field(&all, "ship");
    assert_eq!(ship.value, ["1"]);
    assert_eq!(ship.export_for_state("1"), "Pick-up");
    assert_eq!(ship.widgets.iter().map(|w| w.state.as_deref()).collect::<Vec<_>>(), [Some("Off"), Some("1")]);
    assert_eq!(field(&all, "terms").value, ["0"]);
    let err = set_value(&mut doc, "ship", &FieldValue::Radio(Some("Courier".into()))).unwrap_err();
    assert!(err.to_string().contains("options: Post, Pick-up"), "{err}");
}

/// Issue #1323: a text field without a format keeps a whitespace-only value as typed; only an
/// empty value clears it.
#[test]
fn whitespace_only_text_is_kept_in_a_field_without_a_format() {
    for value in [" ", "\t", "\u{a0}"] {
        let mut doc = fixture();
        set_value(&mut doc, "name", &FieldValue::Text(value.into())).unwrap();
        let doc = reopen(&doc);
        assert_eq!(field(&fields(&doc), "name").value, [value], "{value:?}");
    }
    let mut doc = fixture();
    set_value(&mut doc, "name", &FieldValue::Text(String::new())).unwrap();
    assert!(field(&fields(&reopen(&doc)), "name").value.is_empty());
}

#[test]
fn text_fields_get_new_appearances() {
    let mut doc = fixture();
    set_value(&mut doc, "name", &FieldValue::Text("Grace (Hopper)".into())).unwrap();
    set_value(&mut doc, "notes", &FieldValue::Text("A long note that has to wrap over several lines of the box".into())).unwrap();
    set_value(&mut doc, "zip", &FieldValue::Text("12345".into())).unwrap();
    set_value(&mut doc, "pin", &FieldValue::Text("1234".into())).unwrap();
    set_value(&mut doc, "address.city", &FieldValue::Text("Zürich".into())).unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    assert_eq!(field(&all, "name").value, ["Grace (Hopper)"]);
    let name_ap = ap(&doc, &field(&all, "name").widgets[0]);
    assert!(name_ap.contains("/Tx BMC") && name_ap.contains("EMC"), "{name_ap}");
    assert!(name_ap.contains("(Grace \\(Hopper\\)) Tj"), "{name_ap}");
    assert!(name_ap.contains("1 1 0.9 rg"), "background from /MK: {name_ap}");
    let notes = ap(&doc, &field(&all, "notes").widgets[0]);
    assert!(notes.matches(" Tj").count() >= 2, "wrapped: {notes}");
    assert!(notes.contains("/Helv 10 Tf") && notes.contains("0 0 1 rg"));
    let zip = ap(&doc, &field(&all, "zip").widgets[0]);
    assert_eq!(zip.matches(" Tj").count(), 5, "one cell per character: {zip}");
    let pin = ap(&doc, &field(&all, "pin").widgets[0]);
    assert!(pin.contains("(****) Tj") && !pin.contains("1234"), "{pin}");
    // WinAnsi bytes for non-ASCII text.
    let w = &field(&all, "address.city").widgets[0];
    let n = doc.get(w.obj).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
    let Object::Stream(s) = &*doc.get(n) else { panic!() };
    let raw = s.decoded().unwrap();
    assert!(raw.windows(8).any(|x| x == b"(Z\xfcrich)"));
}

#[test]
fn existing_field_font_encoding_keeps_italian_punctuation_visible() {
    // ReportLab-style Helvetica: an indirect encoding dictionary with PDFDoc-like Differences.
    // WinAnsi 0x92/0x97 would show trademark/Scaron in this font, not quoteright/emdash.
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R] >>".into(),
        "<< /Fields [6 0 R] /DA (/Helv 12 Tf 0 g) /DR << /Font << /Helv 5 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding 7 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (localita) /Rect [50 700 450 730] /P 3 0 R >>".into(),
        "<< /Type /Encoding /Differences [39 /quotesingle 96 /grave 132 /emdash 144 /quoteright 146 /trademark 151 /Scaron 224 /agrave] >>".into(),
    ];
    let mut doc = document(&objs);
    let original_font = doc.get(ObjRef::new(5, 0)).as_ref().clone();
    let value = "Città Sant’Angelo — qualità";
    set_value(&mut doc, "localita", &FieldValue::Text(value.into())).unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    let f = field(&all, "localita");
    assert_eq!(f.value, [value], "the stored value and the drawn text must agree");
    let (font, lines) = appearance_text(&doc, &f.widgets[0], b"Helv");
    assert_eq!(font, original_font, "keep the existing field's font and encoding");
    let metrics = pdfcraft_fonts::pdf::Metrics::from_dict(&doc, font.as_dict().unwrap());
    let shown = lines.concat();
    assert_eq!(metrics.decode(&shown), value, "decode the appearance with its actual font");
    assert_eq!(shown, b"Citt\xe0 Sant\x90Angelo \x84 qualit\xe0");
}

#[test]
fn unavailable_glyph_uses_an_appearance_font_without_changing_the_source_font() {
    // A subset font with only A cannot draw the newly entered accented text. Replacing its
    // encoding would corrupt every existing use of that font, so only the appearance falls back.
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R] >>".into(),
        "<< /Fields [6 0 R] /DA (/Original 12 Tf 0 g) /DR << /Font << /Original 5 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /ABCDEF+Custom /FirstChar 65 /LastChar 65 /Widths [600] /Encoding /WinAnsiEncoding >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (localita) /Rect [50 700 450 730] /P 3 0 R >>".into(),
    ];
    let mut doc = document(&objs);
    let original_font = doc.get(ObjRef::new(5, 0)).as_ref().clone();
    let value = "Città Sant’Angelo — qualità";
    set_value(&mut doc, "localita", &FieldValue::Text(value.into())).unwrap();
    let doc = reopen(&doc);
    assert_eq!(doc.get(ObjRef::new(5, 0)).as_ref(), &original_font);
    let all = fields(&doc);
    let f = field(&all, "localita");
    assert_eq!(f.value, [value]);
    let (font, lines) = appearance_text(&doc, &f.widgets[0], b"Helv");
    let font = font.as_dict().unwrap();
    assert_eq!(font.name(b"BaseFont"), Some(&b"Helvetica"[..]));
    assert_eq!(font.name(b"Encoding"), Some(&b"WinAnsiEncoding"[..]));
    let metrics = pdfcraft_fonts::pdf::Metrics::from_dict(&doc, font);
    let shown = lines.concat();
    assert_eq!(metrics.decode(&shown), value);
    assert_eq!(shown, b"Citt\xe0 Sant\x92Angelo \x97 qualit\xe0");
}

#[test]
fn multiline_wrapping_keeps_encodable_text_without_requiring_ascii_space() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R] >>".into(),
        "<< /Fields [6 0 R] /DA (/Helv 12 Tf 0 g) /DR << /Font << /Helv 5 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding 7 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (localita) /Ff 4096 /Rect [50 500 130 550] /P 3 0 R >>".into(),
        "<< /Type /Encoding /Differences [32 /.notdef 144 /quoteright 160 /nbspace 224 /agrave] >>".into(),
    ];
    let mut doc = document(&objs);
    let original_font = doc.get(ObjRef::new(5, 0)).as_ref().clone();
    // NBSP remains part of the word; wrapping splits it by character without adding spaces.
    let value = "Città\u{a0}Sant’Angelo\nqualità";
    set_value(&mut doc, "localita", &FieldValue::Text(value.into())).unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    let f = field(&all, "localita");
    assert_eq!(f.value, [value]);
    let (font, lines) = appearance_text(&doc, &f.widgets[0], b"Helv");
    assert_eq!(font, original_font);
    assert!(lines.len() >= 3 && lines.iter().all(|line| !line.is_empty()));
    let metrics = pdfcraft_fonts::pdf::Metrics::from_dict(&doc, font.as_dict().unwrap());
    assert_eq!(metrics.decode(&lines.concat()), value.replace('\n', ""));
}

#[test]
fn japanese_choices_use_the_unicode_cid_font() {
    // A choice field whose /DA names a non-embedded CID font with a predefined Unicode CMap
    // (UniJIS-UTF16-H). Selecting 令 must draw it in that font, not "?" in Helvetica.
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [8 0 R 9 0 R 10 0 R] >>".into(),
        "<< /Fields [8 0 R 9 0 R 10 0 R] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 5 0 R /HeiseiMin-W3 6 0 R /Emb 7 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(),
        "<< /Type /Font /Subtype /Type0 /BaseFont /HeiseiMin-W3 /Encoding /UniJIS-UTF16-H /DescendantFonts [<< /Type /Font /Subtype /CIDFontType0 /BaseFont /HeiseiMin-W3 /CIDSystemInfo << /Registry (Adobe) /Ordering (Japan1) /Supplement 6 >> >>] >>".into(),
        "<< /Type /Font /Subtype /Type0 /BaseFont /ABCDEF+Subset /Encoding /Identity-H /DescendantFonts [] >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Ch /T (era) /Ff 131072 /DA (/HeiseiMin-W3 10 Tf 0 g) /Q 1 /Opt [<FEFF3000> <FEFF660E> <FEFF4EE4>] /V <FEFF3000> /Rect [50 700 80 715] /P 3 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (address) /Ff 4096 /DA (/HeiseiMin-W3 10 Tf 0 g) /Rect [50 600 100 680] /P 3 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (subset) /DA (/Emb 10 Tf 0 g) /Rect [50 500 100 520] /P 3 0 R >>".into(),
    ];
    let mut doc = document(&objs);
    assert_eq!(field(&fields(&doc), "era").options.get(2), Some(&("令".to_string(), "令".to_string())));
    set_value(&mut doc, "era", &FieldValue::Text("令".into())).unwrap();
    set_value(&mut doc, "address", &FieldValue::Text("日本語のテキスト入力欄です".into())).unwrap();
    // An Identity-H subset can't be addressed by Unicode: Helvetica stands in, and can't draw 令.
    // The value is kept, drawn as `??`, marked, and other viewers are asked to redraw the form.
    set_value(&mut doc, "subset", &FieldValue::Text("令和".into())).unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    assert_eq!(field(&all, "era").value, ["令"]);
    let raw = |name: &str| {
        let w = &field(&all, name).widgets[0];
        let n = doc.get(w.obj).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
        let Object::Stream(s) = &*doc.get(n) else { panic!() };
        let fonts = doc.resolve(s.dict.get(b"Resources").unwrap()).as_dict().unwrap().get(b"Font").map(|f| doc.resolve(f)).unwrap();
        let fonts: Vec<String> = fonts.as_dict().unwrap().iter().map(|(k, _)| String::from_utf8_lossy(k).into_owned()).collect();
        (s.decoded().unwrap(), fonts)
    };
    let utf16 = |t: &str| t.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
    let (era, era_fonts) = raw("era");
    assert!(era.windows(4).any(|x| x == b"(N\xe4)"), "令 as UTF-16BE: {}", String::from_utf8_lossy(&era));
    assert!(String::from_utf8_lossy(&era).contains("/HeiseiMin-W3 10 Tf"));
    assert!(!era.windows(3).any(|x| x == b"(?)"), "no WinAnsi fallback");
    assert_eq!(era_fonts, ["HeiseiMin-W3"]);
    // Multiline Japanese wraps by character at about one em each (50 pt wide, 10 pt type).
    let (addr, _) = raw("address");
    let addr_text = String::from_utf8_lossy(&addr);
    assert!(addr_text.matches(" Tj").count() >= 4, "{addr_text}");
    assert!(addr.windows(4).any(|x| x == utf16("日本").as_slice()));
    let (sub, sub_fonts) = raw("subset");
    assert!(String::from_utf8_lossy(&sub).contains("/Helv "), "{}", String::from_utf8_lossy(&sub));
    assert!(sub.windows(4).any(|x| x == b"(??)"), "{}", String::from_utf8_lossy(&sub));
    assert_eq!(sub_fonts, ["Helv"]);
    assert_eq!(field(&all, "subset").value, ["令和"]);
    // Only that widget is marked: the CID fonts drew theirs.
    assert_eq!(undrawn_fields(&doc), [("subset".to_string(), '令')]);
    assert!(need_appearances(&doc));
}

/// Text a field's font can't hold is kept, as Acrobat keeps it: the value is stored as typed, the
/// appearance draws `?` for those characters, the widget is marked with the first one, and the
/// form asks other viewers to redraw it (`/NeedAppearances`). Drawable text clears the mark.
#[test]
fn text_a_field_font_cannot_hold_is_kept_marked_and_redrawn_elsewhere() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [7 0 R 8 0 R 9 0 R] >>".into(),
        "<< /Fields [7 0 R 8 0 R 9 0 R] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 5 0 R /CN 6 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(),
        "<< /Type /Font /Subtype /Type0 /BaseFont /STSong-Light /Encoding /UniGB-UCS2-H /DescendantFonts [<< /Type /Font /Subtype /CIDFontType0 /BaseFont /STSong-Light /CIDSystemInfo << /Registry (Adobe) /Ordering (GB1) /Supplement 4 >> >>] >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (name) /DA (/Helv 10 Tf 0 g) /V (Ada) /Rect [50 700 200 715] /P 3 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (cn) /DA (/CN 10 Tf 0 g) /Rect [50 600 200 615] /P 3 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Ch /T (city) /Ff 131072 /DA (/Helv 10 Tf 0 g) /Opt [(Zurich) <FEFF5317004E4EAC>] /Rect [50 500 200 515] /P 3 0 R >>".into(),
    ];
    let mut doc = document(&objs);
    let shown = |doc: &Document, name: &str| {
        let all = fields(doc);
        let w = &field(&all, name).widgets[0];
        let n = doc.get(w.obj).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
        let Object::Stream(s) = &*doc.get(n) else { panic!() };
        let mark = doc.get(w.obj).as_dict().and_then(pdfcraft_fonts::undrawn_mark);
        (String::from_utf8_lossy(&s.decoded().unwrap()).into_owned(), mark)
    };
    // A WinAnsi field: the Chinese value is kept and marked; Helvetica draws `?` for it.
    assert!(!need_appearances(&doc));
    set_value(&mut doc, "name", &FieldValue::Text("签名 Ada".into())).unwrap();
    assert_eq!(field(&fields(&doc), "name").value, ["签名 Ada"]);
    let (ap, mark) = shown(&doc, "name");
    assert!(ap.contains("(?? Ada) Tj"), "{ap}");
    assert_eq!(mark, Some('签'));
    assert!(need_appearances(&doc), "other viewers are asked to redraw the form");
    // A choice whose label Helvetica can't draw, the same way.
    set_value(&mut doc, "city", &FieldValue::Text("北N京".into())).unwrap();
    assert_eq!(shown(&doc, "city").1, Some('北'));
    // A UCS-2 CMap holds 签, so nothing is marked, but not a character beyond U+FFFF.
    set_value(&mut doc, "cn", &FieldValue::Text("签名".into())).unwrap();
    assert_eq!(shown(&doc, "cn").1, None);
    set_value(&mut doc, "cn", &FieldValue::Text("𠀋".into())).unwrap();
    assert_eq!(field(&fields(&doc), "cn").value, ["𠀋"]);
    assert_eq!(shown(&doc, "cn").1, Some('𠀋'));
    let mut undrawn = undrawn_fields(&doc);
    undrawn.sort();
    assert_eq!(undrawn, [("city".to_string(), '北'), ("cn".to_string(), '𠀋'), ("name".to_string(), '签')]);
    // Drawable text clears the mark; a line break in a single-line value is a space, not `?`.
    set_value(&mut doc, "name", &FieldValue::Text("Ada\nLovelace".into())).unwrap();
    let (ap, mark) = shown(&doc, "name");
    assert!(ap.contains("(Ada Lovelace) Tj") && !ap.contains('?'), "{ap}");
    assert_eq!(mark, None);
    // Kept through a save.
    let doc = reopen(&doc);
    assert_eq!(field(&fields(&doc), "city").value, ["北N京"]);
    assert!(need_appearances(&doc));
}

/// A document that declares PDF/A can't ask other viewers to redraw its fields (PDF/A forbids
/// `/NeedAppearances`): the value is still kept and its widget marked, and the flag stays off.
#[test]
fn a_pdfa_form_keeps_the_value_without_asking_viewers_to_redraw() {
    let xmp = r#"<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"><rdf:Description xmlns:pdfaid="http://www.aiim.org/pdfa/ns/id/" pdfaid:part="2" pdfaid:conformance="B"/></rdf:RDF></x:xmpmeta>"#;
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R /Metadata 7 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R] >>".into(),
        "<< /Fields [6 0 R] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 5 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (name) /DA (/Helv 10 Tf 0 g) /Rect [50 700 200 715] /P 3 0 R >>".into(),
        format!("<< /Type /Metadata /Subtype /XML /Length {} >>\nstream\n{xmp}\nendstream", xmp.len() + 1),
    ];
    let mut doc = document(&objs);
    assert!(declares_pdfa(&doc));
    set_value(&mut doc, "name", &FieldValue::Text("张三".into())).unwrap();
    assert_eq!(field(&fields(&doc), "name").value, ["张三"]);
    assert_eq!(undrawn_fields(&doc), [("name".to_string(), '张')]);
    assert!(!need_appearances(&doc), "PDF/A forbids /NeedAppearances");
}

/// A button caption Helvetica can't draw is kept and marked like a value; redrawing a value another
/// program stored (a dynamic form's layout, a property change) draws and marks it rather than
/// failing, and an edit to an unrelated field never fails because of it.
#[test]
fn captions_and_redrawn_values_are_kept_and_marked() {
    let mut doc = fixture();
    let go = add_field(&mut doc, 0, [50.0, 50.0, 150.0, 80.0], &NewField::Button { caption: "提交".into() }, Some("go2")).unwrap();
    assert_eq!(undrawn_fields(&doc), [(go.clone(), '提')]);
    assert!(need_appearances(&doc));
    // A value stored by another program that Helvetica can't draw.
    let name = field(&fields(&doc), "name").clone();
    doc.update_dict(name.obj, |d| d.set(b"V".to_vec(), PdfString::text("张三"))).unwrap();
    redraw_field(&mut doc, "name").unwrap();
    let mut undrawn = undrawn_fields(&doc);
    undrawn.sort();
    assert_eq!(undrawn, [(go, '提'), ("name".to_string(), '张')]);
    set_value(&mut doc, "notes", &FieldValue::Text("Unrelated".into())).unwrap();
    // Drawable again: the mark goes.
    doc.update_dict(name.obj, |d| d.set(b"V".to_vec(), PdfString::text("Ada"))).unwrap();
    redraw_field(&mut doc, "name").unwrap();
    assert!(!undrawn_fields(&doc).iter().any(|(n, _)| n == "name"));
}

#[test]
fn check_boxes_and_radios_switch_states() {
    let mut doc = fixture();
    set_value(&mut doc, "agree", &FieldValue::Check(true)).unwrap();
    set_value(&mut doc, "size", &FieldValue::Radio(Some("L".into()))).unwrap();
    set_value(&mut doc, "bare", &FieldValue::Text("yes".into())).unwrap();
    let doc2 = reopen(&doc);
    let all = fields(&doc2);
    assert_eq!(field(&all, "agree").value, ["Yes"]);
    assert_eq!(field(&all, "agree").widgets[0].state.as_deref(), Some("Yes"));
    let size = field(&all, "size");
    assert_eq!(size.value, ["L"]);
    assert_eq!(size.widgets.iter().map(|w| w.state.clone().unwrap()).collect::<Vec<_>>(), ["Off", "L"]);
    // The bare check box got PdfCraft's own appearances and kept its other keys.
    let bare = field(&all, "bare");
    assert_eq!(bare.value, ["Yes"]);
    assert_eq!(bare.widgets[0].on_state.as_deref(), Some("Yes"));
    assert!(doc2.get(bare.widgets[0].obj).as_dict().unwrap().contains(b"Foo"));
    let mut doc = doc2;
    // Radio validation and NoToggleToOff.
    assert!(matches!(set_value(&mut doc, "size", &FieldValue::Radio(Some("XL".into()))), Err(FormError::Invalid(_))));
    assert!(matches!(set_value(&mut doc, "size", &FieldValue::Radio(None)), Err(FormError::Invalid(_))));
    set_value(&mut doc, "agree", &FieldValue::Check(false)).unwrap();
    assert!(field(&fields(&doc), "agree").value.is_empty());
}

#[test]
fn check_boxes_keep_non_utf8_state_names() {
    // Japanese forms often name a check box's on state 「はい」 in Shift-JIS: ticking it has to
    // write those exact bytes to /AS and /V, or no appearance matches and no mark shows.
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [5 0 R] >>".into(),
        "<< /Fields [5 0 R] >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (agree) /AS /Off /Rect [50 700 56 706] /P 3 0 R /AP << /N << /Off 6 0 R /#82#CD#82#A2 7 0 R >> >> >>".into(),
        "<< /Length 0 >>\nstream\n\nendstream".into(),
        "<< /Length 0 >>\nstream\n\nendstream".into(),
    ];
    let sjis_hai: &[u8] = b"\x82\xcd\x82\xa2";
    let mut doc = document(&objs);
    let all = fields(&doc);
    assert_eq!(field(&all, "agree").widgets[0].on_state.as_deref(), Some("#82#CD#82#A2"));
    set_value(&mut doc, "agree", &FieldValue::Check(true)).unwrap();
    let doc = reopen(&doc);
    let f = field(&fields(&doc), "agree").clone();
    let wd = doc.get(f.widgets[0].obj).as_dict().cloned().unwrap();
    assert_eq!(wd.name(b"AS"), Some(sjis_hai));
    assert_eq!(doc.get(f.obj).as_dict().unwrap().name(b"V"), Some(sjis_hai));
    assert_eq!(f.value, ["#82#CD#82#A2"]);
    let mut doc = doc;
    set_value(&mut doc, "agree", &FieldValue::Check(false)).unwrap();
    assert_eq!(doc.get(f.widgets[0].obj).as_dict().unwrap().name(b"AS"), Some(&b"Off"[..]));
}

#[test]
fn name_text_round_trips() {
    for bytes in [&b"Yes"[..], b"\x82\xcd\x82\xa2", "はい".as_bytes(), b"A#1", b"a b", b"", b"\xff#\x00"] {
        assert_eq!(name_bytes(&name_text(bytes)), bytes, "{bytes:?}");
    }
    assert_eq!(name_text("はい".as_bytes()), "はい");
    assert_eq!(name_text(b"A#1"), "A#231");
    // Malformed escapes stay as they are.
    assert_eq!(name_bytes("#G1#4"), b"#G1#4");
}

#[test]
fn choices_accept_exports_or_display_text() {
    let mut doc = fixture();
    set_value(&mut doc, "country", &FieldValue::Text("France".into())).unwrap();
    set_value(&mut doc, "toppings", &FieldValue::Choice(vec!["Ham".into(), "Olives".into()])).unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    let country = field(&all, "country");
    assert_eq!(country.value, ["fr"]);
    assert_eq!(country.display_value(), "France");
    assert!(ap(&doc, &country.widgets[0]).contains("(France) Tj"));
    let toppings = field(&all, "toppings");
    assert_eq!(toppings.value, ["Ham", "Olives"]);
    let list = ap(&doc, &toppings.widgets[0]);
    assert_eq!(list.matches("0.6 0.75 0.86 rg").count(), 2, "two highlighted rows: {list}");
    assert_eq!(doc.get(toppings.obj).as_dict().unwrap().get(b"I").unwrap().as_array().unwrap().len(), 2);
    let mut doc = doc;
    assert!(matches!(set_value(&mut doc, "country", &FieldValue::Text("Spain".into())), Err(FormError::Invalid(_))));
    assert!(matches!(set_value(&mut doc, "country", &FieldValue::Choice(vec!["ca".into(), "fr".into()])), Err(FormError::Invalid(_))));
}

#[test]
fn list_box_selection_scrolls_to_show_selected_options() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R] >>".into(),
        "<< /Fields [6 0 R] /DA (/Helv 10 Tf 0 g) /DR << /Font << /Helv 5 0 R >> >> >>".into(),
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Ch /T (days) /Ff 2097152 /Opt [(Mon) (Tue) (Wed) (Thu) (Fri)] /Rect [50 700 200 746] /P 3 0 R >>"
            .into(),
    ];
    let mut doc = document(&objs);
    // Setting value to Tue and Thu (indices 1 and 3) in a 46 pt high box (fits 3 rows).
    // It should scroll /TI to 1 so Tue (1), Wed (2), Thu (3) are drawn and highlighted.
    set_value(&mut doc, "days", &FieldValue::Choice(vec!["Tue".into(), "Thu".into()])).unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    let days = field(&all, "days");
    assert_eq!(days.value, ["Tue", "Thu"]);
    let ti = doc.get(days.obj).as_dict().unwrap().get(b"TI").and_then(|o| o.as_int());
    assert_eq!(ti, Some(1), "TI scrolled to 1 so both selected options are visible");
    let appearance = ap(&doc, &days.widgets[0]);
    assert!(appearance.contains("(Tue) Tj"), "Tue is drawn: {appearance}");
    assert!(appearance.contains("(Thu) Tj"), "Thu is drawn: {appearance}");
    assert_eq!(appearance.matches("0.6 0.75 0.86 rg").count(), 2, "both Tue and Thu highlighted");
}

#[test]
fn multiselect_choice_indices_are_sorted_without_reordering_values() {
    let mut forward_appearance = None;
    for values in [["Ham", "Olives"], ["Olives", "Ham"]] {
        let mut doc = fixture();
        let chosen: Vec<String> = values.iter().map(|value| (*value).into()).collect();
        set_value(&mut doc, "toppings", &FieldValue::Choice(chosen.clone())).unwrap();
        let doc = reopen(&doc);
        let all = fields(&doc);
        let list = field(&all, "toppings");
        assert_eq!(list.value, chosen, "saving preserves the caller's /V order");
        let object = doc.get(list.obj);
        let indices = object.as_dict().unwrap().get(b"I").unwrap().as_array().unwrap();
        assert_eq!(indices.iter().map(|index| index.as_int().unwrap()).collect::<Vec<_>>(), [1, 2], "saved option indices are ascending");
        let appearance = ap(&doc, &list.widgets[0]);
        assert_eq!(appearance.matches("0.6 0.75 0.86 rg").count(), 2, "both selected rows stay highlighted");
        if let Some(forward) = &forward_appearance {
            assert_eq!(&appearance, forward, "the same selected rows have the same appearance in either selection order");
        } else {
            forward_appearance = Some(appearance);
        }
    }
}

#[test]
fn errors_are_specific_and_change_nothing() {
    let mut doc = fixture();
    assert_eq!(set_value(&mut doc, "nope", &FieldValue::Text("x".into())), Err(FormError::NoSuchField("nope".into())));
    assert_eq!(set_value(&mut doc, "id", &FieldValue::Text("x".into())), Err(FormError::ReadOnly("id".into())));
    assert!(matches!(set_value(&mut doc, "zip", &FieldValue::Text("123456".into())), Err(FormError::Invalid(_))));
    assert!(matches!(set_value(&mut doc, "go", &FieldValue::Text("x".into())), Err(FormError::Invalid(_))));
    assert!(matches!(set_value(&mut doc, "agree", &FieldValue::Text("maybe".into())), Err(FormError::Invalid(_))));
    assert!(!doc.is_modified());
}

#[test]
fn reset_restores_defaults() {
    let mut doc = fixture();
    set_value(&mut doc, "name", &FieldValue::Text("Grace".into())).unwrap();
    set_value(&mut doc, "agree", &FieldValue::Check(true)).unwrap();
    set_value(&mut doc, "size", &FieldValue::Radio(Some("L".into()))).unwrap();
    assert_eq!(reset(&mut doc, Some(&["agree".to_string()])).unwrap(), 1);
    assert!(field(&fields(&doc), "agree").value.is_empty());
    assert_eq!(field(&fields(&doc), "name").value, ["Grace"], "only the named field");
    let n = reset(&mut doc, None).unwrap();
    assert!(n >= 2);
    let all = fields(&reopen(&doc));
    assert_eq!(field(&all, "name").value, ["Ada"]);
    assert_eq!(field(&all, "size").value, ["S"], "back to /DV");
    assert!(matches!(reset(&mut doc, Some(&["nope".to_string()])), Err(FormError::NoSuchField(_))));
}

#[test]
fn documents_without_forms_say_so() {
    let mut doc = Document::new_empty();
    assert_combined_matches_legacy(&doc, 0);
    assert!(fields(&doc).is_empty());
    assert_eq!(set_value(&mut doc, "x", &FieldValue::Text("y".into())), Err(FormError::NoForm));
}

#[test]
fn combined_enumeration_keeps_page_order_across_pages() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 5 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [6 0 R] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [7 0 R] >>".into(),
        "<< /Fields [6 0 R] >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (listed) /Rect [50 700 250 720] /P 3 0 R >>".into(),
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (adopted) /Rect [50 700 250 720] /P 4 0 R >>".into(),
    ];
    let doc = document(&objs);
    assert_combined_matches_legacy(&doc, 1);

    let combined = fields_with_adopted(&doc);
    assert_eq!(combined.items.iter().map(|f| f.name.as_str()).collect::<Vec<_>>(), ["listed", "adopted"]);
    assert_eq!(combined.items.iter().map(|f| f.widgets[0].page).collect::<Vec<_>>(), [Some(0), Some(1)]);
}

#[test]
fn combined_enumeration_keeps_leniency_for_dangling_field_entries() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 4 0 R >>".into(),
        "<< /Type /Pages /Kids [3 0 R] /Count 1 /MediaBox [0 0 600 800] >>".into(),
        "<< /Type /Page /Parent 2 0 R /Annots [] >>".into(),
        "<< /Fields [99 0 R null 5 0 R] >>".into(),
        "<< /FT /Tx /T (valid) >>".into(),
    ];
    let doc = document(&objs);
    assert_combined_matches_legacy(&doc, 0);
    assert_eq!(fields_with_adopted(&doc).items.iter().map(|f| f.name.as_str()).collect::<Vec<_>>(), ["valid"]);
}

#[test]
fn every_field_type_can_be_added_named_and_drawn() {
    let mut doc = Document::new_empty();
    {
        // One page.
        let pages = doc.get(doc.root().unwrap()).as_dict().unwrap().reference(b"Pages").unwrap();
        let mut p = pdfcraft_cos::Dict::new();
        p.set(b"Type".to_vec(), Object::name("Page"));
        p.set(b"Parent".to_vec(), Object::Ref(pages));
        p.set(b"MediaBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 600.into(), 800.into()]));
        let r = doc.add(p);
        doc.update_dict(pages, |d| {
            d.set(b"Kids".to_vec(), Object::Array(vec![Object::Ref(r)]));
            d.set(b"Count".to_vec(), Object::Int(1));
        })
        .unwrap();
    }
    let r = |y: f64| [50.0, y, 250.0, y + 20.0];
    let names: Vec<String> = [
        (NewField::Text { multiline: false }, r(700.0)),
        (NewField::Text { multiline: true }, [50.0, 600.0, 250.0, 680.0]),
        (NewField::Date, r(560.0)),
        (NewField::CheckBox, [50.0, 520.0, 64.0, 534.0]),
        (NewField::Radio { group: None, export: "Small".into() }, [50.0, 480.0, 64.0, 494.0]),
        (NewField::Combo { options: vec!["Red".into(), "Blue".into()], editable: false }, r(440.0)),
        (NewField::List { options: vec!["A".into(), "B".into(), "C".into()], multi: true }, [50.0, 340.0, 250.0, 420.0]),
        (NewField::Button { caption: "Submit".into() }, r(300.0)),
        (NewField::Signature, [50.0, 220.0, 250.0, 270.0]),
    ]
    .iter()
    .map(|(k, rect)| add_field(&mut doc, 0, *rect, k, None).unwrap())
    .collect();
    assert_eq!(names, ["Text1", "Text2", "Date1", "Check Box1", "Group1", "Dropdown1", "List Box1", "Button1", "Signature1"]);
    // A second radio button joins the group.
    assert_eq!(
        add_field(&mut doc, 0, [80.0, 480.0, 94.0, 494.0], &NewField::Radio { group: Some("Group1".into()), export: "Large".into() }, None).unwrap(),
        "Group1"
    );
    let doc = reopen(&doc);
    let all = fields(&doc);
    assert_eq!(all.len(), 9);
    let group = field(&all, "Group1");
    assert_eq!(group.widgets.iter().filter_map(|w| w.on_state.clone()).collect::<Vec<_>>(), ["Small", "Large"]);
    assert!(field(&all, "Text2").has(flags::MULTILINE));
    assert_eq!(field(&all, "Dropdown1").options.len(), 2);
    assert!(field(&all, "List Box1").has(flags::MULTI_SELECT));
    assert_eq!(field(&all, "Button1").kind, FieldKind::PushButton);
    assert!(ap(&doc, &field(&all, "Button1").widgets[0]).contains("(Submit) Tj"));
    // Every widget is on the page and has an appearance.
    for f in &all {
        for w in &f.widgets {
            assert_eq!(w.page, Some(0), "{}", f.name);
            assert!(doc.get(w.obj).as_dict().unwrap().contains(b"AP"), "{} has an appearance", f.name);
        }
    }
    // The new fields can be filled.
    let mut doc = doc;
    set_value(&mut doc, "Text1", &FieldValue::Text("hello".into())).unwrap();
    set_value(&mut doc, "Group1", &FieldValue::Radio(Some("Large".into()))).unwrap();
    assert!(add_field(&mut doc, 0, r(100.0), &NewField::CheckBox, Some("Text1")).is_err(), "names are unique");
    assert!(add_field(&mut doc, 0, [0.0, 0.0, 2.0, 2.0], &NewField::CheckBox, None).is_err(), "too small");
}

#[test]
fn properties_rename_and_delete() {
    let mut doc = fixture();
    let renamed = set_props(
        &mut doc,
        "name",
        &FieldProps {
            name: Some("full_name".into()),
            tooltip: Some("Your name".into()),
            required: Some(true),
            max_len: Some(Some(20)),
            font_size: Some(9.0),
            ..FieldProps::default()
        },
    )
    .unwrap();
    assert_eq!(renamed, "full_name");
    let all = fields(&doc);
    let f = field(&all, "full_name");
    assert!(f.has(flags::REQUIRED) && f.max_len == Some(20) && f.tooltip.as_deref() == Some("Your name"));
    assert!(ap(&doc, &f.widgets[0]).contains("/Helv 9 Tf"), "redrawn with the new size");
    let nested = set_props(&mut doc, "address.city", &FieldProps { name: Some("town".into()), ..FieldProps::default() }).unwrap();
    assert_eq!(nested, "address.town", "only the last part changes");
    set_props(&mut doc, "country", &FieldProps { options: Some(vec!["Japan".into()]), ..FieldProps::default() }).unwrap();
    assert_eq!(field(&fields(&doc), "country").options, [("Japan".to_string(), "Japan".to_string())]);
    assert!(set_props(&mut doc, "zip", &FieldProps { name: Some("pin".into()), ..FieldProps::default() }).is_err(), "taken");
    set_props(&mut doc, "full_name", &FieldProps { rect: Some((0, [10.0, 10.0, 110.0, 30.0])), ..FieldProps::default() }).unwrap();
    let f = field(&fields(&doc), "full_name").clone();
    assert_eq!(f.widgets[0].rect, [10.0, 10.0, 110.0, 30.0]);
    assert!(ap(&doc, &f.widgets[0]).contains("100"), "the appearance takes the new size");
    assert!(set_props(&mut doc, "full_name", &FieldProps { rect: Some((0, [0.0, 0.0, 2.0, 2.0])), ..FieldProps::default() }).is_err());
    let before = fields(&doc).len();
    delete_field(&mut doc, "size").unwrap();
    delete_field(&mut doc, "address.town").unwrap();
    let doc = reopen(&doc);
    let all = fields(&doc);
    assert_eq!(all.len(), before - 2);
    assert!(!all.iter().any(|f| f.name == "size" || f.name == "address.town"));
    let p = &page_refs(&doc)[0];
    let annots = doc.resolve(doc.get(*p).as_dict().unwrap().get(b"Annots").unwrap());
    assert_eq!(annots.as_array().unwrap().len(), 13 - 3, "the deleted widgets left the page");
}

#[test]
fn deleting_works_with_a_form_dictionary_inside_the_catalog() {
    let mut doc = fixture();
    let root = doc.root().unwrap();
    let af = doc.get(pdfcraft_cos::ObjRef::new(4, 0)).as_dict().cloned().unwrap();
    doc.update_dict(root, |d| d.set(b"AcroForm".to_vec(), Object::Dict(af))).unwrap();
    let before = fields(&doc).len();
    delete_field(&mut doc, "name").unwrap();
    let all = fields(&reopen(&doc));
    assert_eq!(all.len(), before - 1);
    assert!(!all.iter().any(|f| f.name == "name"));
}

fn one_page() -> Document {
    let mut doc = Document::new_empty();
    let pages = doc.get(doc.root().unwrap()).as_dict().unwrap().reference(b"Pages").unwrap();
    let mut p = pdfcraft_cos::Dict::new();
    p.set(b"Type".to_vec(), Object::name("Page"));
    p.set(b"Parent".to_vec(), Object::Ref(pages));
    p.set(b"MediaBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 600.into(), 800.into()]));
    let r = doc.add(p);
    doc.update_dict(pages, |d| {
        d.set(b"Kids".to_vec(), Object::Array(vec![Object::Ref(r)]));
        d.set(b"Count".to_vec(), Object::Int(1));
    })
    .unwrap();
    doc
}

#[test]
fn formats_validation_and_calculations_run_like_acrobat() {
    use crate::af::{CalcOp, Calculate, Format, Validate};
    let mut doc = one_page();
    let text = NewField::Text { multiline: false };
    for (name, y) in [("Price", 700.0), ("Qty", 660.0), ("Total", 620.0), ("Count", 580.0), ("Due", 540.0)] {
        add_field(&mut doc, 0, [50.0, y, 250.0, y + 20.0], &text, Some(name)).unwrap();
    }
    let money = Format::Number { decimals: 2, sep: 0, neg: 0, currency: "$".into(), prepend: true };
    set_props(
        &mut doc,
        "Price",
        &FieldProps { format: Some(money.clone()), validate: Some(Validate::Range { min: Some(0.0), max: None }), ..FieldProps::default() },
    )
    .unwrap();
    set_props(
        &mut doc,
        "Qty",
        &FieldProps {
            format: Some(Format::Number { decimals: 0, sep: 0, neg: 0, currency: String::new(), prepend: true }),
            validate: Some(Validate::Range { min: Some(1.0), max: Some(99.0) }),
            ..FieldProps::default()
        },
    )
    .unwrap();
    set_props(
        &mut doc,
        "Total",
        &FieldProps {
            format: Some(money),
            calculate: Some(Calculate::Notation("Price * Qty".into())),
            read_only: Some(true),
            ..FieldProps::default()
        },
    )
    .unwrap();
    set_props(
        &mut doc,
        "Count",
        &FieldProps { calculate: Some(Calculate::Simple { op: CalcOp::Sum, fields: vec!["Qty".into()] }), ..FieldProps::default() },
    )
    .unwrap();
    set_props(&mut doc, "Due", &FieldProps { format: Some(Format::Date("mmm d, yyyy".into())), ..FieldProps::default() }).unwrap();
    // The scripts are Acrobat's, so Acrobat (and we, after a save) read them back.
    let doc2 = reopen(&doc);
    let total = field(&fields(&doc2), "Total").clone();
    assert_eq!(total.actions.calculate, Calculate::Notation("Price * Qty".into()));
    assert!(matches!(total.actions.format, Format::Number { decimals: 2, .. }));
    let co =
        doc2.get(doc2.root().unwrap()).as_dict().unwrap().get(b"AcroForm").cloned().map(|a| doc2.resolve(&a).as_dict().cloned().unwrap()).unwrap();
    assert_eq!(doc2.resolve(co.get(b"CO").unwrap()).as_array().unwrap().len(), 2, "both calculated fields are in the calculation order");
    let mut doc = doc2;
    // Typing a formatted number stores the number and shows it formatted.
    set_value(&mut doc, "Price", &FieldValue::Text("$1,234.5".into())).unwrap();
    set_value(&mut doc, "Qty", &FieldValue::Text("2".into())).unwrap();
    let all = fields(&doc);
    assert_eq!(field(&all, "Price").value, ["1234.5"]);
    assert!(ap(&doc, &field(&all, "Price").widgets[0]).contains("($1,234.50) Tj"));
    // Calculations ran in order.
    assert_eq!(field(&all, "Total").value, ["2469"]);
    assert!(ap(&doc, &field(&all, "Total").widgets[0]).contains("($2,469.00) Tj"));
    assert_eq!(field(&all, "Count").value, ["2"]);
    // Keystroke and validation errors use Acrobat's messages and change nothing.
    assert_eq!(
        set_value(&mut doc, "Qty", &FieldValue::Text("lots".into())),
        Err(FormError::Invalid("The value entered does not match the format of the field [ Qty ]".into()))
    );
    assert_eq!(
        set_value(&mut doc, "Qty", &FieldValue::Text("120".into())),
        Err(FormError::Invalid("Invalid value: must be greater than or equal to 1 and less than or equal to 99.".into()))
    );
    assert_eq!(field(&fields(&doc), "Qty").value, ["2"]);
    // Dates: stored as typed, shown in the format; impossible dates are refused.
    set_value(&mut doc, "Due", &FieldValue::Text("10/1/2026".into())).unwrap();
    assert!(ap(&doc, &field(&fields(&doc), "Due").widgets[0]).contains("(Oct 1, 2026) Tj"));
    assert!(set_value(&mut doc, "Due", &FieldValue::Text("2/30/2026".into())).is_err());
    // Clear form recalculates.
    reset(&mut doc, None).unwrap();
    assert_eq!(field(&fields(&doc), "Total").value, ["0"]);
    // Removing a format.
    set_props(&mut doc, "Price", &FieldProps { format: Some(Format::None), ..FieldProps::default() }).unwrap();
    assert_eq!(field(&fields(&doc), "Price").actions.format, Format::None);
}

#[test]
fn new_text_fields_fit_their_box() {
    // #1888: a fixed 12 pt was clipped in a short box. New text and date fields take Acrobat's
    // Auto size: 12 pt where there is room, smaller where there isn't.
    let mut doc = one_page();
    let tf_size = |ap: &str| {
        ap.split("/Helv ")
            .nth(1)
            .and_then(|s| s.split(' ').next())
            .and_then(|n| n.parse::<f64>().ok())
            .unwrap_or_else(|| panic!("no /Helv size in {ap}"))
    };
    for (kind, name, value) in [(NewField::Text { multiline: false }, "short", "Hello world"), (NewField::Date, "date", "10/13/2026")] {
        add_field(&mut doc, 0, [20.0, 20.0, 200.0, 28.0], &kind, Some(name)).unwrap();
        set_value(&mut doc, name, &FieldValue::Text(value.into())).unwrap();
        let f = field(&fields(&doc), name).clone();
        assert_eq!(f.da, "/Helv 0 Tf 0 g", "{name}");
        let size = tf_size(&ap(&doc, &f.widgets[0]));
        assert!(size > 0.0 && size <= 8.0, "{name}: {size} pt in an 8 pt box");
    }
    add_field(&mut doc, 0, [20.0, 50.0, 200.0, 72.0], &NewField::Text { multiline: false }, Some("tall")).unwrap();
    set_value(&mut doc, "tall", &FieldValue::Text("Hello world".into())).unwrap();
    assert_eq!(tf_size(&ap(&doc, &field(&fields(&doc), "tall").widgets[0])), 12.0, "a box with room keeps the 12 pt look");
    // An explicit size still wins.
    set_props(&mut doc, "short", &FieldProps { font_size: Some(12.0), ..FieldProps::default() }).unwrap();
    assert_eq!(tf_size(&ap(&doc, &field(&fields(&doc), "short").widgets[0])), 12.0);
}

#[test]
fn appearance_properties_restyle_every_widget() {
    let mut doc = one_page();
    add_field(&mut doc, 0, [50.0, 700.0, 250.0, 720.0], &NewField::Text { multiline: false }, Some("name")).unwrap();
    set_value(&mut doc, "name", &FieldValue::Text("Ada".into())).unwrap();
    let f = field(&fields(&doc), "name").clone();
    let before = look(&doc, &f);
    assert_eq!((before.font, before.style, before.text), (FieldFont::Helvetica, BorderStyle::Solid, [0.0; 3]));
    let new = Look {
        border: Some([1.0, 0.0, 0.0]),
        fill: Some([1.0, 1.0, 0.8]),
        width: 2.0,
        style: BorderStyle::Dashed,
        text: [0.0, 0.0, 1.0],
        font: FieldFont::Times,
    };
    set_props(&mut doc, "name", &FieldProps { look: Some(new), font_size: Some(14.0), ..FieldProps::default() }).unwrap();
    let doc = reopen(&doc);
    let f = field(&fields(&doc), "name").clone();
    assert_eq!(look(&doc, &f), new);
    let a = ap(&doc, &f.widgets[0]);
    assert!(a.contains("/TiRo 14 Tf") && a.contains("0 0 1 rg") && a.contains("[3] 0 d") && a.contains("(Ada) Tj"), "{a}");
    let mut doc = doc;
    set_props(&mut doc, "name", &FieldProps { look: Some(Look { style: BorderStyle::Underline, fill: None, ..new }), ..FieldProps::default() })
        .unwrap();
    let a = ap(&doc, &field(&fields(&doc), "name").widgets[0]);
    assert!(!a.contains(" re S") && a.contains(" l S"), "underline only: {a}");
}

#[test]
fn tab_order_follows_the_page_setting() {
    let mut doc = one_page();
    let text = NewField::Text { multiline: false };
    // Added in a scrambled order: annotation order is C, A, D, B.
    // Layout:  A (50,700)  B (300,700)
    //          C (50,600)  D (300,600)
    for (name, x, y) in [("C", 50.0, 600.0), ("A", 50.0, 700.0), ("D", 300.0, 600.0), ("B", 300.0, 700.0)] {
        add_field(&mut doc, 0, [x, y, x + 200.0, y + 20.0], &text, Some(name)).unwrap();
    }
    let order = |doc: &Document| -> String {
        let mut all: Vec<(usize, String)> = fields(doc).into_iter().map(|f| (f.widgets[0].tab, f.name)).collect();
        all.sort();
        all.into_iter().map(|x| x.1).collect()
    };
    assert_eq!(order(&doc), "CADB", "unspecified: annotation order");
    set_tab_order(&mut doc, &[0], TabOrder::Row).unwrap();
    assert_eq!(order(&doc), "ABCD");
    set_tab_order(&mut doc, &[0], TabOrder::Column).unwrap();
    assert_eq!(order(&doc), "ACBD");
    let doc = reopen(&doc);
    assert_eq!(order(&doc), "ACBD", "saved as /Tabs");
    assert!(set_tab_order(&mut doc.clone(), &[3], TabOrder::Row).is_err());
}

#[test]
fn options_tab_flags_alignment_and_defaults() {
    let mut doc = one_page();
    let text = add_field(&mut doc, 0, [50.0, 700.0, 250.0, 720.0], &NewField::Text { multiline: false }, None).unwrap();
    let combo = add_field(
        &mut doc,
        0,
        [50.0, 600.0, 250.0, 620.0],
        &NewField::Combo { options: vec!["Pear".into(), "apple".into(), "Fig".into()], editable: false },
        None,
    )
    .unwrap();
    let check = add_field(&mut doc, 0, [50.0, 500.0, 64.0, 514.0], &NewField::CheckBox, None).unwrap();
    // A comb needs a limit.
    let comb = FieldProps { flags: vec![(flags::COMB, true)], ..FieldProps::default() };
    assert!(matches!(set_props(&mut doc, &text, &comb), Err(FormError::Invalid(_))));
    set_props(
        &mut doc,
        &text,
        &FieldProps {
            flags: vec![(flags::COMB, true), (flags::DO_NOT_SPELL_CHECK, true)],
            max_len: Some(Some(6)),
            quadding: Some(1),
            default_value: Some(Some("ABC123".into())),
            ..FieldProps::default()
        },
    )
    .unwrap();
    let f = fields(&doc).into_iter().find(|f| f.name == text).unwrap();
    assert!(f.has(flags::COMB) && f.has(flags::DO_NOT_SPELL_CHECK) && !f.has(flags::MULTILINE));
    assert_eq!((f.max_len, f.quadding, f.default.clone()), (Some(6), 1, vec!["ABC123".to_string()]));
    // Reset form restores the default.
    set_value(&mut doc, &text, &FieldValue::Text("XYZ".into())).unwrap();
    reset(&mut doc, None).unwrap();
    assert_eq!(fields(&doc).into_iter().find(|f| f.name == text).unwrap().value, vec!["ABC123".to_string()]);
    // Sort items orders the list; custom text allowed.
    set_props(&mut doc, &combo, &FieldProps { flags: vec![(flags::SORT, true), (flags::EDIT, true)], ..FieldProps::default() }).unwrap();
    let c = fields(&doc).into_iter().find(|f| f.name == combo).unwrap();
    assert_eq!(c.options.iter().map(|(_, d)| d.as_str()).collect::<Vec<_>>(), vec!["apple", "Fig", "Pear"]);
    assert!(c.has(flags::EDIT));
    // Checked by default: the on state is the default.
    let on = fields(&doc).into_iter().find(|f| f.name == check).unwrap().widgets[0].on_state.clone().unwrap();
    set_props(&mut doc, &check, &FieldProps { default_value: Some(Some(on.clone())), ..FieldProps::default() }).unwrap();
    reset(&mut doc, None).unwrap();
    assert_eq!(fields(&doc).into_iter().find(|f| f.name == check).unwrap().value, vec![on]);
    assert!(set_props(&mut doc, &text, &FieldProps { quadding: Some(5), ..FieldProps::default() }).is_err());
}

#[test]
fn check_box_styles_change_the_mark() {
    // #94: Field Properties ▸ Options ▸ Check Box Style (stored as /MK /CA).
    let mut doc = one_page();
    let check = add_field(&mut doc, 0, [50.0, 700.0, 70.0, 720.0], &NewField::CheckBox, None).unwrap();
    let radio = add_field(&mut doc, 0, [50.0, 600.0, 70.0, 620.0], &NewField::Radio { group: None, export: "A".into() }, None).unwrap();
    let text = add_field(&mut doc, 0, [50.0, 500.0, 250.0, 520.0], &NewField::Text { multiline: false }, None).unwrap();
    let style = |doc: &Document, name: &str| check_style(doc, field(&fields(doc), name));
    assert_eq!((style(&doc, &check), style(&doc, &radio)), (CheckStyle::Check, CheckStyle::Circle), "the defaults");
    // The "on" appearance: the widget's /AP /N entry for its on state.
    let on_ap = |doc: &Document, name: &str| {
        let all = fields(doc);
        let w = &field(&all, name).widgets[0];
        let on = w.on_state.clone().unwrap();
        let n = doc
            .get(w.obj)
            .as_dict()
            .unwrap()
            .get(b"AP")
            .unwrap()
            .as_dict()
            .unwrap()
            .get(b"N")
            .unwrap()
            .as_dict()
            .unwrap()
            .reference(on.as_bytes())
            .unwrap();
        let Object::Stream(s) = &*doc.get(n) else { panic!() };
        String::from_utf8_lossy(&s.decoded().unwrap()).into_owned()
    };
    let before = on_ap(&doc, &check);
    for (s, code) in
        [(CheckStyle::Cross, "8"), (CheckStyle::Square, "n"), (CheckStyle::Star, "H"), (CheckStyle::Diamond, "u"), (CheckStyle::Circle, "l")]
    {
        set_props(&mut doc, &check, &FieldProps { check_style: Some(s), ..FieldProps::default() }).unwrap();
        let doc2 = reopen(&doc);
        assert_eq!(style(&doc2, &check), s, "saved and read back");
        let mk = doc2.get(field(&fields(&doc2), &check).widgets[0].obj).as_dict().unwrap().get(b"MK").unwrap().as_dict().cloned().unwrap();
        assert_eq!(mk.get(b"CA").and_then(|c| c.as_string()).map(|c| c.to_text()).as_deref(), Some(code));
        assert!(mk.get(b"BC").is_some(), "the border colour is kept");
        assert_ne!(on_ap(&doc, &check), before, "{s:?} draws a different mark");
    }
    assert!(on_ap(&doc, &check).contains(" c f"), "a circle is a filled curve");
    set_props(&mut doc, &radio, &FieldProps { check_style: Some(CheckStyle::Square), ..FieldProps::default() }).unwrap();
    assert!(on_ap(&doc, &radio).contains(" re f"), "a square");
    assert!(
        set_props(&mut doc, &text, &FieldProps { check_style: Some(CheckStyle::Star), ..FieldProps::default() }).is_err(),
        "text fields have no style"
    );
}

#[test]
fn ordering_tabs_manually() {
    let mut doc = one_page();
    let text = NewField::Text { multiline: false };
    for (name, x, y) in [("A", 50.0, 700.0), ("B", 300.0, 700.0), ("C", 50.0, 600.0)] {
        add_field(&mut doc, 0, [x, y, x + 200.0, y + 20.0], &text, Some(name)).unwrap();
    }
    // A comment between the widgets keeps its place.
    let page = page_refs(&doc)[0];
    let mut note = pdfcraft_cos::Dict::new();
    note.set(b"Type".to_vec(), Object::name("Annot"));
    note.set(b"Subtype".to_vec(), Object::name("Text"));
    note.set(b"Rect".to_vec(), Object::Array(vec![0.into(), 0.into(), 10.into(), 10.into()]));
    let note = doc.add(Object::Dict(note));
    doc.update_dict(page, |d| {
        if let Some(Object::Array(a)) = d.get_mut(b"Annots") {
            a.insert(1, Object::Ref(note));
        }
    })
    .unwrap();
    set_tab_order(&mut doc, &[0], TabOrder::Row).unwrap();
    let order = |doc: &Document| -> String {
        let mut all: Vec<(usize, String)> = fields(doc).into_iter().map(|f| (f.widgets[0].tab, f.name)).collect();
        all.sort();
        all.into_iter().map(|x| x.1).collect()
    };
    assert_eq!(order(&doc), "ABC");
    move_in_tab_order(&mut doc, "C", true).unwrap();
    assert_eq!(order(&doc), "ACB", "row order became manual");
    move_in_tab_order(&mut doc, "A", false).unwrap();
    assert_eq!(order(&doc), "CAB");
    move_in_tab_order(&mut doc, "B", false).unwrap();
    assert_eq!(order(&doc), "CAB", "already last");
    let annots = doc.get(page).as_dict().unwrap().get(b"Annots").unwrap().as_array().unwrap().clone();
    assert_eq!(annots[1].as_ref(), Some(note), "the comment stays where it was");
    assert!(!doc.get(page).as_dict().unwrap().contains(b"Tabs"));
    let doc = reopen(&doc);
    assert_eq!(order(&doc), "CAB", "saved");
}

#[test]
fn duplicating_a_field_across_pages_shares_its_value() {
    let mut doc = one_page();
    // A second and third page.
    let pages = doc.get(doc.root().unwrap()).as_dict().unwrap().reference(b"Pages").unwrap();
    for _ in 0..2 {
        let mut p = pdfcraft_cos::Dict::new();
        p.set(b"Type".to_vec(), Object::name("Page"));
        p.set(b"Parent".to_vec(), Object::Ref(pages));
        p.set(b"MediaBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 600.into(), 800.into()]));
        let r = doc.add(p);
        doc.update_dict(pages, |d| {
            let mut kids = d.get(b"Kids").unwrap().as_array().unwrap().clone();
            kids.push(Object::Ref(r));
            d.set(b"Count".to_vec(), Object::Int(kids.len() as i64));
            d.set(b"Kids".to_vec(), Object::Array(kids));
        })
        .unwrap();
    }
    let name = add_field(&mut doc, 0, [50.0, 750.0, 250.0, 770.0], &NewField::Text { multiline: false }, Some("Initials")).unwrap();
    assert_eq!(duplicate_field(&mut doc, &name, &[0, 1, 2]).unwrap(), 2, "page 1 already has it");
    let f = fields(&doc).into_iter().find(|f| f.name == name).unwrap();
    assert_eq!(f.widgets.iter().filter_map(|w| w.page).collect::<Vec<_>>(), vec![0, 1, 2]);
    assert!(f.widgets.iter().all(|w| w.rect == [50.0, 750.0, 250.0, 770.0]));
    set_value(&mut doc, &name, &FieldValue::Text("AL".into())).unwrap();
    let doc = reopen(&doc);
    let f = fields(&doc).into_iter().find(|f| f.name == name).unwrap();
    assert_eq!((f.value.clone(), f.widgets.len()), (vec!["AL".to_string()], 3), "one field, one value, three widgets");
    assert_eq!(fields(&doc).len(), 1);
    assert!(duplicate_field(&mut doc.clone(), &name, &[7]).is_err());
}

/// Fields with the same fully qualified name are one field (§12.7.3.1): a parent whose widgets are
/// its kids, as Duplicate Across Pages writes it, and separate field dictionaries that repeat the
/// same `/T`, as other writers do. Filling the name fills every one of them.
#[test]
fn fields_sharing_a_name_take_the_same_value() {
    let objs: Vec<String> = vec![
        "<< /Type /Catalog /Pages 2 0 R /AcroForm 5 0 R >>".into(),                         // 1
        "<< /Type /Pages /Kids [3 0 R 4 0 R] /Count 2 /MediaBox [0 0 600 800] >>".into(),   // 2
        "<< /Type /Page /Parent 2 0 R /Annots [7 0 R 11 0 R] >>".into(),                    // 3
        "<< /Type /Page /Parent 2 0 R /Annots [8 0 R 9 0 R 12 0 R] >>".into(),              // 4
        "<< /Fields [6 0 R 9 0 R 11 0 R 12 0 R] /DA (/Helv 0 Tf 0 g) /DR << /Font << /Helv 10 0 R >> >> >>".into(), // 5
        "<< /FT /Tx /T (ClientName) /Kids [7 0 R 8 0 R] >>".into(),                         // 6 parent
        "<< /Type /Annot /Subtype /Widget /Parent 6 0 R /Rect [50 700 250 720] /P 3 0 R >>".into(), // 7 its widget, page 1
        "<< /Type /Annot /Subtype /Widget /Parent 6 0 R /Rect [50 700 250 720] /P 4 0 R >>".into(), // 8 its widget, page 2
        "<< /Type /Annot /Subtype /Widget /FT /Tx /T (ClientName) /Rect [50 600 250 620] /P 4 0 R >>".into(), // 9 same name, own field
        "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>".into(), // 10
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (Agree) /V /Off /AS /Off /Rect [300 700 315 715] /P 3 0 R /AP << /N << /Yes 13 0 R /Off 14 0 R >> >> >>".into(), // 11
        "<< /Type /Annot /Subtype /Widget /FT /Btn /T (Agree) /V /Off /AS /Off /Rect [300 700 315 715] /P 4 0 R /AP << /N << /Yes 13 0 R /Off 14 0 R >> >> >>".into(), // 12
        "<< /Length 0 >>\nstream\n\nendstream".into(),                                      // 13
        "<< /Length 0 >>\nstream\n\nendstream".into(),                                      // 14
    ];
    let mut doc = document(&objs);
    set_value(&mut doc, "ClientName", &FieldValue::Text("Ada Lovelace".into())).unwrap();
    set_value(&mut doc, "Agree", &FieldValue::Check(true)).unwrap();
    let doc = reopen(&doc);
    let v = |n: u32| doc.get(ObjRef { num: n, generation: 0 }).as_dict().unwrap().get(b"V").cloned();
    let typed = Some(Object::String(PdfString::text("Ada Lovelace")));
    assert_eq!((v(6), v(9)), (typed.clone(), typed), "the value sits on the parent and on the field that repeats its name");
    assert_eq!((v(7), v(8)), (None, None), "the parent's widgets carry no value of their own");
    let all = fields(&doc);
    let named: Vec<&Field> = all.iter().filter(|f| f.name == "ClientName").collect();
    let widgets: Vec<&Widget> = named.iter().flat_map(|f| &f.widgets).collect();
    assert_eq!(widgets.iter().map(|w| w.obj.num).collect::<Vec<_>>(), [7, 8, 9]);
    for w in widgets {
        assert!(ap(&doc, w).contains("Ada Lovelace"), "widget {} shows the value", w.obj.num);
    }
    let agree: Vec<&Field> = all.iter().filter(|f| f.name == "Agree").collect();
    assert_eq!(agree.len(), 2);
    for f in agree {
        assert_eq!((f.value.as_slice(), f.widgets[0].state.as_deref()), (&["Yes".to_string()][..], Some("Yes")), "check box {}", f.obj.num);
    }
}

#[test]
fn locked_fields_only_take_unlocking() {
    let mut doc = one_page();
    let name = add_field(&mut doc, 0, [50.0, 700.0, 250.0, 720.0], &NewField::Text { multiline: false }, Some("ID")).unwrap();
    set_props(&mut doc, &name, &FieldProps { locked: Some(true), ..FieldProps::default() }).unwrap();
    assert!(fields(&doc)[0].locked());
    assert!(set_props(&mut doc, &name, &FieldProps { required: Some(true), ..FieldProps::default() }).is_err(), "locked");
    // Values can still be filled in.
    set_value(&mut doc, &name, &FieldValue::Text("42".into())).unwrap();
    set_props(&mut doc, &name, &FieldProps { locked: Some(false), required: Some(true), ..FieldProps::default() }).unwrap();
    let f = &fields(&doc)[0];
    assert!(!f.locked() && f.has(flags::REQUIRED));
}

#[test]
fn image_fields_ask_for_a_picture_and_show_it() {
    let mut doc = one_page();
    let name = add_field(&mut doc, 0, [50.0, 600.0, 250.0, 700.0], &NewField::Image, None).unwrap();
    assert_eq!(name, "Image1");
    let f = fields(&doc).into_iter().find(|f| f.name == name).unwrap();
    assert_eq!((f.kind, f.button.clone()), (FieldKind::PushButton, Some(af::ButtonAction::ImportIcon)));
    // A 4×2 image: the icon keeps its shape and is centred in the 200×100 box.
    let mut d = Dict::new();
    for (k, v) in
        [(&b"Type"[..], Object::name("XObject")), (b"Subtype", Object::name("Image")), (b"Width", Object::Int(4)), (b"Height", Object::Int(2))]
    {
        d.set(k.to_vec(), v);
    }
    let img = doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(d, vec![0; 24])));
    set_button_icon(&mut doc, &name, img, (4, 2)).unwrap();
    let w = doc.get(f.widgets[0].obj).as_dict().cloned().unwrap();
    let mk = w.get(b"MK").unwrap().as_dict().unwrap().clone();
    assert_eq!(mk.int(b"TP"), Some(1));
    let ap = w.get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
    let Object::Stream(s) = &*doc.get(ap) else { panic!("appearance") };
    let text = String::from_utf8(s.decoded().unwrap()).unwrap();
    assert!(text.contains("/Icon Do") && text.contains("49.000000 0 0 49.000000 2.000 1.000 cm"), "{text}");
    assert!(set_button_icon(&mut doc, "nope", img, (1, 1)).is_err());
}

#[test]
fn field_actions_round_trip_on_every_trigger() {
    let mut doc = fixture();
    let name = "go".to_string();
    let acts = vec![
        (Trigger::MouseUp, FieldAction::JavaScript("app.alert('hi')".into())),
        (Trigger::MouseEnter, FieldAction::ShowHide { fields: vec!["other".into()], hide: false }),
        (Trigger::OnFocus, FieldAction::Uri("https://example.org".into())),
        (Trigger::OnBlur, FieldAction::Reset(vec![])),
        (Trigger::MouseDown, FieldAction::GoTo(0)),
    ];
    set_field_actions(&mut doc, &name, &acts).unwrap();
    let mut got = field_actions(&doc, &name).unwrap();
    let mut want = acts.clone();
    let key = |x: &(Trigger, FieldAction)| Trigger::ALL.iter().position(|t| *t == x.0);
    got.sort_by_key(key);
    want.sort_by_key(key);
    assert_eq!(got, want);
    set_field_actions(&mut doc, &name, &[(Trigger::MouseExit, FieldAction::Named("NextPage".into()))]).unwrap();
    assert_eq!(field_actions(&doc, &name).unwrap(), [(Trigger::MouseExit, FieldAction::Named("NextPage".into()))]);
    // The Mouse Up script is what the button runs.
    set_field_actions(&mut doc, &name, &[(Trigger::MouseUp, FieldAction::JavaScript("this.print();".into()))]).unwrap();
    assert_combined_matches_legacy(&doc, 0);
    assert_eq!(fields(&doc).iter().find(|f| f.name == "go").unwrap().button, Some(af::ButtonAction::Named("Print".into())));
}

#[test]
fn push_buttons_read_hide_actions() {
    let mut doc = fixture();
    let go = field(&fields(&doc), "go").obj;
    let s = |t: &str| Object::String(PdfString::text(t));
    let city = ObjRef::new(16, 0);
    let null = ObjRef::new(9, 0);
    let button = |doc: &mut Document, t: Object, h: Option<bool>| {
        let mut a = Dict::new();
        a.set(b"S".to_vec(), Object::name("Hide"));
        a.set(b"T".to_vec(), t);
        if let Some(h) = h {
            a.set(b"H".to_vec(), Object::Bool(h));
        }
        doc.update_dict(go, |d| d.set(b"A".to_vec(), Object::Dict(a))).unwrap();
        field(&fields(doc), "go").button.clone()
    };
    let hide = |names: &[&str], hide: bool| Some(af::ButtonAction::ShowHide { fields: names.iter().map(|n| n.to_string()).collect(), hide });
    // A name; /H defaults to true (hide).
    assert_eq!(button(&mut doc, s("name"), None), hide(&["name"], true));
    // A widget reference names its field by its fully qualified name; /H false shows.
    assert_eq!(button(&mut doc, Object::Ref(city), Some(false)), hide(&["address.city"], false));
    // An array of both; a reference to something that isn't a field is skipped.
    assert_eq!(button(&mut doc, Object::Array(vec![s("name"), Object::Ref(city), Object::Ref(null)]), None), hide(&["name", "address.city"], true));
    // A /Parent cycle ends instead of looping.
    let looped = doc.add(Object::Dict(Dict::new()));
    doc.update_dict(looped, |d| {
        d.set(b"T".to_vec(), s("loop"));
        d.set(b"Parent".to_vec(), Object::Ref(looped));
    })
    .unwrap();
    assert_eq!(button(&mut doc, Object::Ref(looped), None), hide(&["loop"], true));
}

#[test]
fn push_buttons_read_set_layer_actions() {
    use af::LayerOp::{Off, On, Toggle};
    let mut doc = fixture();
    let go = field(&fields(&doc), "go").obj;
    let ocg = |n: u32| Object::Ref(ObjRef::new(n, 0));
    let button = |doc: &mut Document, state: Option<Object>, preserve_rb: Option<Object>| {
        let mut a = Dict::new();
        a.set(b"S".to_vec(), Object::name("SetOCGState"));
        if let Some(state) = state {
            a.set(b"State".to_vec(), state);
        }
        if let Some(p) = preserve_rb {
            a.set(b"PreserveRB".to_vec(), p);
        }
        doc.update_dict(go, |d| d.set(b"A".to_vec(), Object::Dict(a))).unwrap();
        field(&fields(doc), "go").button.clone()
    };
    let layers = |changes: &[(af::LayerOp, u32)], preserve_rb: bool| {
        Some(af::ButtonAction::SetLayers { changes: changes.iter().map(|&(op, n)| (op, (n, 0))).collect(), preserve_rb })
    };
    // Each name applies to the groups after it; /PreserveRB false is read.
    let state = Object::Array(vec![Object::name("ON"), ocg(30), ocg(31), Object::name("OFF"), ocg(32), Object::name("Toggle"), ocg(30)]);
    assert_eq!(button(&mut doc, Some(state), Some(Object::Bool(false))), layers(&[(On, 30), (On, 31), (Off, 32), (Toggle, 30)], false));
    // An indirect /State; groups before the first name or after an unknown one, and entries that
    // aren't groups, are skipped. /PreserveRB defaults to true, also when it isn't a boolean.
    let state = doc.add(Object::Array(vec![
        ocg(29),
        Object::name("OFF"),
        ocg(30),
        Object::Int(7),
        Object::name("Hide"),
        ocg(31),
        Object::name("Toggle"),
        ocg(32),
    ]));
    assert_eq!(button(&mut doc, Some(Object::Ref(state)), Some(Object::Int(0))), layers(&[(Off, 30), (Toggle, 32)], true));
    // No /State: an action that changes nothing (the button still has an action).
    assert_eq!(button(&mut doc, None, None), layers(&[], true));
}

#[test]
fn detection_finds_blanks_rules_boxes_and_names_them() {
    use crate::detect::*;
    let w = |t: &str, x0: f64, y0: f64, x1: f64| Word { text: t.into(), rect: [x0, y0, x1, y0 + 10.0] };
    let words = vec![
        w("Name:", 50.0, 700.0, 80.0),
        w("______________", 85.0, 699.0, 250.0),
        w("Date", 300.0, 700.0, 325.0),
        w("of", 328.0, 700.0, 338.0),
        w("birth", 341.0, 700.0, 365.0),
        w("I", 72.0, 602.0, 75.0),
        w("agree", 78.0, 602.0, 105.0),
        w("Comments", 50.0, 560.0, 100.0),
        w("Heading", 50.0, 750.0, 100.0),
    ];
    let shapes = Shapes {
        boxes: vec![[56.0, 600.0, 68.0, 612.0], [50.0, 500.0, 300.0, 540.0], [40.0, 20.0, 560.0, 780.0]],
        rules: vec![[370.0, 699.0, 500.0, 699.0], [50.0, 748.0, 100.0, 748.0]],
    };
    let found = detect(&words, &shapes, &[], &["Comments".into()]);
    let names: Vec<(&str, &Kind)> = found.iter().map(|c| (c.name.as_str(), &c.kind)).collect();
    assert_eq!(names, [("Name", &Kind::Text), ("Date of birth", &Kind::Text), ("I agree", &Kind::CheckBox), ("Comments2", &Kind::Text)], "{found:?}");
    // An existing field there: nothing new.
    let again = detect(&words, &shapes, &found.iter().map(|c| c.rect).collect::<Vec<_>>(), &[]);
    assert!(again.is_empty(), "{again:?}");
}

#[test]
fn detection_makes_a_row_of_touching_cells_one_comb_field() {
    use crate::detect::*;
    let w = |t: &str, x0: f64, y0: f64, x1: f64| Word { text: t.into(), rect: [x0, y0, x1, y0 + 10.0] };
    let words = vec![
        w("Postcode", 40.0, 205.0, 85.0),
        w("A", 88.0, 205.0, 95.0),
        w("Postcode", 40.0, 105.0, 85.0),
        w("B", 88.0, 105.0, 95.0),
        w("Yes", 70.0, 41.0, 90.0),
    ];
    let row = |n: usize, x: f64, y: f64, cw: f64, ch: f64| (0..n).map(move |i| [x + i as f64 * cw, y, x + (i + 1) as f64 * cw, y + ch]);
    // 18 x 22 cells (too tall for a check box), 16 x 20 cells (each one check-box sized) drawn
    // right to left, and a lone square.
    let mut boxes: Vec<[f64; 4]> = row(5, 120.0, 200.0, 18.0, 22.0).collect();
    boxes.extend(row(10, 120.0, 100.0, 16.0, 20.0).rev());
    boxes.push([50.0, 40.0, 62.0, 52.0]);
    let found = detect(&words, &Shapes { boxes, rules: Vec::new() }, &[], &[]);
    let got: Vec<(&str, &Kind, [f64; 4])> = found.iter().map(|c| (c.name.as_str(), &c.kind, c.rect)).collect();
    assert_eq!(
        got,
        [
            ("Postcode A", &Kind::Comb { cells: 5 }, [120.0, 200.0, 210.0, 222.0]),
            ("Postcode B", &Kind::Comb { cells: 10 }, [120.0, 100.0, 280.0, 120.0]),
            ("Yes", &Kind::CheckBox, [50.0, 40.0, 62.0, 52.0]),
        ],
        "{found:?}"
    );
    // Squares with a gap between them stay check boxes, and so do touching squares of
    // different sizes.
    let apart = Shapes {
        boxes: vec![[50.0, 40.0, 62.0, 52.0], [66.0, 40.0, 78.0, 52.0], [80.0, 40.0, 92.0, 52.0], [92.0, 40.0, 102.0, 52.0]],
        rules: Vec::new(),
    };
    let kinds: Vec<Kind> = detect(&[], &apart, &[], &[]).into_iter().map(|c| c.kind).collect();
    assert_eq!(kinds, [Kind::CheckBox, Kind::CheckBox, Kind::CheckBox, Kind::CheckBox]);
    // An empty table of cells wider than tall (an attendance sheet) is not a comb.
    let grid = |cw: f64, ch: f64| {
        (0..3).flat_map(move |r| {
            (0..3).map(move |c| [100.0 + c as f64 * cw, 300.0 + r as f64 * ch, 100.0 + (c + 1) as f64 * cw, 300.0 + (r + 1) as f64 * ch])
        })
    };
    for (cw, ch) in [(24.0, 18.0), (28.0, 20.0)] {
        let table = detect(&[], &Shapes { boxes: grid(cw, ch).collect(), rules: Vec::new() }, &[], &[]);
        assert!(table.is_empty(), "{cw} x {ch}: {table:?}");
    }
}

#[test]
fn page_shapes_reads_boxes_and_rules() {
    let mut doc = fixture();
    let page = pdfcraft_model::pages(&doc)[0].obj;
    let s = doc.add(pdfcraft_cos::Object::Stream(pdfcraft_cos::Stream::flate(
        Default::default(),
        b"q 2 0 0 2 0 0 cm 10 10 6 6 re S 20 50 m 120 50 l S 0 0 m 5 5 l S 30 300 100 0.5 re f Q",
    )));
    doc.update_dict(page, |d| d.set(b"Contents".to_vec(), pdfcraft_cos::Object::Ref(s))).unwrap();
    let sh = crate::detect::page_shapes(&doc, 0);
    assert_eq!(sh.boxes, [[20.0, 20.0, 32.0, 32.0]]);
    assert_eq!(sh.rules, [[40.0, 100.0, 240.0, 100.0], [60.0, 600.5, 260.0, 600.5]]);
}

fn close(a: f64, b: f64) -> bool {
    (a - b).abs() < 0.05
}

fn nums(o: &Object) -> Vec<f64> {
    o.as_array().unwrap().iter().filter_map(Object::as_f64).collect()
}

/// Normal appearance `/BBox` and `/Matrix` (absent when the widget is not rotated).
fn appearance_box(doc: &Document, w: &Widget) -> (Vec<f64>, Option<Vec<f64>>) {
    let n = doc.get(w.obj).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
    let Object::Stream(s) = &*doc.get(n) else { panic!("appearance") };
    (nums(s.dict.get(b"BBox").unwrap()), s.dict.get(b"Matrix").map(nums))
}

#[test]
fn rotated_fields_draw_in_their_quadrant() {
    let mut doc = fixture();
    // No /R: the appearance is the widget rectangle and carries no /Matrix.
    set_value(&mut doc, "name", &FieldValue::Text("Ada".into())).unwrap();
    let (bbox, matrix) = appearance_box(&doc, &field(&fields(&doc), "name").widgets[0]);
    assert!(close(bbox[2], 200.0) && close(bbox[3], 20.0), "{bbox:?}");
    assert!(matrix.is_none(), "{matrix:?}");

    let set_r = |doc: &mut Document, degrees: i64| {
        let obj = field(&fields(doc), "name").widgets[0].obj;
        doc.update_dict(obj, |d| {
            let mut mk = d.get(b"MK").and_then(|m| m.as_dict().cloned()).unwrap_or_default();
            mk.set(b"R".to_vec(), Object::Int(degrees));
            d.set(b"MK".to_vec(), Object::Dict(mk));
        })
        .unwrap();
        set_value(doc, "name", &FieldValue::Text("Ada".into())).unwrap();
    };
    // 90 and 270 lay the text out in the swapped box. 180 keeps the box and turns it over.
    set_r(&mut doc, 90);
    let (bbox, matrix) = appearance_box(&doc, &field(&fields(&doc), "name").widgets[0]);
    assert!(close(bbox[2], 20.0) && close(bbox[3], 200.0), "{bbox:?}");
    let m = matrix.unwrap();
    assert!(close(m[0], 0.0) && close(m[1], 1.0) && close(m[2], -1.0) && close(m[4], 200.0), "{m:?}");
    set_r(&mut doc, 180);
    let (bbox, matrix) = appearance_box(&doc, &field(&fields(&doc), "name").widgets[0]);
    assert!(close(bbox[2], 200.0) && close(bbox[3], 20.0), "{bbox:?}");
    let m = matrix.unwrap();
    assert!(close(m[0], -1.0) && close(m[3], -1.0) && close(m[4], 200.0) && close(m[5], 20.0), "{m:?}");
    set_r(&mut doc, 270);
    let (bbox, matrix) = appearance_box(&doc, &field(&fields(&doc), "name").widgets[0]);
    assert!(close(bbox[2], 20.0) && close(bbox[3], 200.0), "{bbox:?}");
    let m = matrix.unwrap();
    assert!(close(m[1], -1.0) && close(m[2], 1.0) && close(m[5], 20.0), "{m:?}");
    // A non-quadrant /R is drawn upright.
    set_r(&mut doc, 45);
    let (bbox, matrix) = appearance_box(&doc, &field(&fields(&doc), "name").widgets[0]);
    assert!(matrix.is_none() && close(bbox[2], 200.0) && close(bbox[3], 20.0), "{bbox:?} {matrix:?}");
    assert_eq!(field(&fields(&doc), "name").widgets[0].rotation, 0);

    let before = field(&fields(&doc), "name").widgets[0].rect;
    assert!(set_props(&mut doc, "name", &FieldProps { rotation: Some((0, 45)), ..FieldProps::default() }).is_err());
    assert!(field(&fields(&doc), "name").widgets[0].rect.iter().zip(before).all(|(a, b)| close(*a, b)));
    set_props(&mut doc, "name", &FieldProps { rotation: Some((0, 90)), ..FieldProps::default() }).unwrap();
    let turned = field(&fields(&doc), "name").widgets[0].clone();
    assert_eq!(turned.rotation, 90);
    let r = turned.rect;
    // [50 700 250 720] around its center becomes 20 wide and 200 tall.
    assert!(close(r[0], 140.0) && close(r[1], 610.0) && close(r[2], 160.0) && close(r[3], 810.0), "{r:?}");
    let widget = doc.get(turned.obj);
    let mk = widget.as_dict().unwrap().get(b"MK").unwrap().as_dict().cloned().unwrap();
    assert!(mk.contains(b"BG") && mk.contains(b"BC") && mk.int(b"R") == Some(90));
    let (_, matrix) = appearance_box(&doc, &turned);
    assert!(matrix.is_some());
    // 270 stays on the vertical axis, so the rectangle is not swapped again.
    set_props(&mut doc, "name", &FieldProps { rotation: Some((0, 270)), ..FieldProps::default() }).unwrap();
    let r270 = field(&fields(&doc), "name").widgets[0].rect;
    assert!(r270.iter().zip(r).all(|(a, b)| close(*a, b)), "{r270:?}");

    // A check box and a push button use the same matrix.
    let mut doc = one_page();
    add_field(&mut doc, 0, [20.0, 40.0, 40.0, 60.0], &NewField::CheckBox, Some("agree")).unwrap();
    add_field(&mut doc, 0, [20.0, 80.0, 120.0, 110.0], &NewField::Button { caption: "Go".into() }, Some("go")).unwrap();
    set_props(&mut doc, "agree", &FieldProps { rotation: Some((0, 90)), ..FieldProps::default() }).unwrap();
    set_props(&mut doc, "go", &FieldProps { rotation: Some((0, 90)), ..FieldProps::default() }).unwrap();
    let agree = field(&fields(&doc), "agree").widgets[0].clone();
    let widget = doc.get(agree.obj);
    let n = widget.as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().get(b"N").cloned().unwrap();
    let states = doc.resolve(&n);
    let yes = states.as_dict().unwrap().reference(b"Yes").unwrap();
    let Object::Stream(s) = &*doc.get(yes) else { panic!("check") };
    assert!(s.dict.contains(b"Matrix"), "the check mark is rotated");
    let go = field(&fields(&doc), "go").widgets[0].clone();
    let (text, matrix) = (ap(&doc, &go), appearance_box(&doc, &go).1);
    assert!(text.contains("(Go) Tj") && matrix.is_some(), "{text}");
}

#[test]
fn a_rotation_refused_as_too_small_changes_nothing_else() {
    let mut doc = one_page();
    add_field(&mut doc, 0, [50.0, 700.0, 250.0, 720.0], &NewField::Text { multiline: false }, Some("thin")).unwrap();
    // 200 x 3: turned a quarter it would be 3 wide, too small to use.
    let obj = field(&fields(&doc), "thin").widgets[0].obj;
    doc.update_dict(obj, |d| d.set(b"Rect".to_vec(), Object::Array([50.0, 700.0, 250.0, 703.0].iter().map(|v| Object::Real(*v)).collect()))).unwrap();
    let props = FieldProps { tooltip: Some("changed".into()), rotation: Some((0, 90)), ..FieldProps::default() };
    assert!(set_props(&mut doc, "thin", &props).is_err());
    let f = field(&fields(&doc), "thin").clone();
    assert_eq!(f.tooltip, None, "the tooltip was written before the rotation was refused");
    assert_eq!(f.widgets[0].rotation, 0);
}

#[test]
fn filling_and_authoring_keep_shared_appearances_and_drop_stale_alternates() {
    let alternates: [(&[u8], &[u8]); 2] = [(b"R", b"0 0 20 10 re f\n"), (b"D", b"1 1 18 8 re S\n")];
    let cases = [
        (NewField::Text { multiline: false }, true),
        (NewField::Text { multiline: false }, false),
        (NewField::CheckBox, false),
        (NewField::Button { caption: "Button".into() }, false),
        (NewField::Signature, false),
    ];
    for (kind, fill) in cases {
        for indirect in [false, true] {
            let mut doc = one_page();
            let first = add_field(&mut doc, 0, [50.0, 600.0, 250.0, 630.0], &kind, Some("First")).unwrap();
            let other = add_field(&mut doc, 0, [50.0, 550.0, 250.0, 580.0], &kind, Some("Other")).unwrap();
            let first_widget = field(&fields(&doc), &first).widgets[0].obj;
            let other_widget = field(&fields(&doc), &other).widgets[0].obj;
            let mut entries = doc.get(first_widget).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().clone();
            for (key, bytes) in alternates {
                let mut d = Dict::new();
                d.set(b"Type".to_vec(), Object::name("XObject"));
                d.set(b"Subtype".to_vec(), Object::name("Form"));
                d.set(b"BBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 20.into(), 10.into()]));
                let r = doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(d, bytes.to_vec())));
                entries.set(key.to_vec(), Object::Ref(r));
            }
            entries.set(b"VendorState".to_vec(), Object::name("Retained"));
            let shared = if indirect { Object::Ref(doc.add(Object::Dict(entries))) } else { Object::Dict(entries) };
            for widget in [first_widget, other_widget] {
                doc.update_dict(widget, |d| d.set(b"AP".to_vec(), shared.clone())).unwrap();
            }
            let original = reopen(&doc);
            for full in [false, true] {
                let mut doc = original.clone();
                let other_widget = field(&fields(&doc), &other).widgets[0].obj;
                let source = doc.get(other_widget).as_dict().unwrap().get(b"AP").unwrap().clone();
                let before = doc.resolve(&source);
                if fill {
                    set_value(&mut doc, &first, &FieldValue::Text("Updated value".into())).unwrap();
                } else {
                    set_props(&mut doc, &first, &FieldProps { tooltip: Some("Updated help".into()), ..FieldProps::default() }).unwrap();
                }
                assert_eq!(doc.resolve(&source), before, "a shared AP must not change");
                let bytes = if full {
                    pdfcraft_cos::write_full(&doc, &SaveOptions::default()).unwrap()
                } else {
                    assert!(!doc.revisions().is_empty(), "incremental save needs an existing revision");
                    assert!(!doc.encryption_changed() && !doc.full_save_required(), "this edit must not require a full rewrite");
                    let original = doc.bytes();
                    let bytes = write_incremental(&doc, &SaveOptions::default()).unwrap();
                    assert!(bytes.len() > original.len(), "incremental save appends the changed appearance");
                    assert!(bytes.starts_with(original.as_slice()), "incremental save preserves the complete original prefix");
                    bytes
                };
                hayro_syntax::Pdf::new(bytes.clone()).unwrap();
                let doc = Document::open(Arc::new(bytes)).unwrap();
                let all = fields(&doc);
                let first = field(&all, &first);
                let other = field(&all, &other);
                let first_ap = doc.resolve(doc.get(first.widgets[0].obj).as_dict().unwrap().get(b"AP").unwrap());
                let other_ap = doc.resolve(doc.get(other.widgets[0].obj).as_dict().unwrap().get(b"AP").unwrap());
                let first_ap = first_ap.as_dict().unwrap();
                let other_ap = other_ap.as_dict().unwrap();
                assert_ne!(first_ap.get(b"N"), other_ap.get(b"N"), "normal appearance was regenerated");
                assert_eq!(other_ap.len(), 4);
                // The redrawn widget keeps unknown entries, but not down/rollover looks that
                // would show its old value or caption on press or hover.
                assert_eq!(
                    first_ap.len(),
                    2,
                    "{kind:?} fill={fill} indirect={indirect} full={full}: {:?}",
                    first_ap.iter().map(|(k, _)| String::from_utf8_lossy(k).into_owned()).collect::<Vec<_>>()
                );
                for (key, bytes) in alternates {
                    assert!(first_ap.get(key).is_none(), "stale /{}", String::from_utf8_lossy(key));
                    let object = doc.resolve(other_ap.get(key).unwrap());
                    let Object::Stream(stream) = &*object else { panic!("alternate appearance") };
                    assert_eq!(stream.decoded().unwrap(), bytes);
                }
                assert_eq!(first_ap.name(b"VendorState"), Some(&b"Retained"[..]));
                assert_eq!(other_ap.name(b"VendorState"), Some(&b"Retained"[..]));
                if fill {
                    assert_eq!(first.value, ["Updated value"]);
                    assert!(ap(&doc, &first.widgets[0]).contains("(Updated value) Tj"));
                    assert!(other.value.is_empty());
                } else {
                    assert_eq!(first.tooltip.as_deref(), Some("Updated help"));
                    assert_eq!(other.tooltip, None);
                }
            }
        }
    }
}

#[test]
fn pushbutton_redraw_resolves_caption_and_layout_after_save_and_reopen() {
    fn saved(doc: &Document, full: bool) -> Document {
        let bytes = if full {
            pdfcraft_cos::write_full(doc, &SaveOptions::default()).unwrap()
        } else {
            assert!(!doc.revisions().is_empty(), "incremental save needs an existing revision");
            assert!(!doc.encryption_changed() && !doc.full_save_required(), "this edit must not require a full rewrite");
            let original = doc.bytes();
            let bytes = write_incremental(doc, &SaveOptions::default()).unwrap();
            assert!(bytes.len() > original.len(), "incremental save appends the changed appearance");
            assert!(bytes.starts_with(original.as_slice()), "incremental save preserves the complete original prefix");
            bytes
        };
        hayro_syntax::Pdf::new(bytes.clone()).unwrap();
        Document::open(Arc::new(bytes)).unwrap()
    }

    for indirect_caption in [false, true] {
        for indirect_layout in [false, true] {
            for icon_only in [false, true] {
                let mut doc = one_page();
                let name =
                    add_field(&mut doc, 0, [50.0, 600.0, 250.0, 650.0], &NewField::Button { caption: "Original caption".into() }, Some("Picture"))
                        .unwrap();
                let widget = field(&fields(&doc), &name).widgets[0].obj;
                let caption = Object::String(pdfcraft_cos::PdfString::literal(b"Original caption".to_vec()));
                let caption = if indirect_caption { Object::Ref(doc.add(caption)) } else { caption };
                let layout = Object::Int(i64::from(icon_only));
                let layout = if indirect_layout { Object::Ref(doc.add(layout)) } else { layout };
                let mut icon_dict = Dict::new();
                icon_dict.set(b"Type".to_vec(), Object::name("XObject"));
                icon_dict.set(b"Subtype".to_vec(), Object::name("Form"));
                icon_dict.set(b"BBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 4.into(), 2.into()]));
                let icon_bytes = b"0 0 4 2 re f\n";
                let icon = doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(icon_dict, icon_bytes.to_vec())));
                let mut mk = Dict::new();
                mk.set(b"CA".to_vec(), caption);
                mk.set(b"TP".to_vec(), layout);
                mk.set(b"I".to_vec(), Object::Ref(icon));
                mk.set(b"VendorNote".to_vec(), Object::name("Retained"));
                let mk = doc.add(Object::Dict(mk));
                doc.update_dict(widget, |d| d.set(b"MK".to_vec(), Object::Ref(mk))).unwrap();

                // Import the operands from a real saved file before an unrelated public edit.
                let original = saved(&doc, true);
                for full in [false, true] {
                    let mut doc = original.clone();
                    let widget = field(&fields(&doc), &name).widgets[0].obj;
                    let mk_before = doc.get(widget).as_dict().unwrap().get(b"MK").unwrap().clone();
                    let original_mk = doc.resolve(&mk_before);
                    set_props(&mut doc, &name, &FieldProps { tooltip: Some("Picture help".into()), ..FieldProps::default() }).unwrap();
                    assert_eq!(doc.get(widget).as_dict().unwrap().get(b"MK"), Some(&mk_before));
                    assert_eq!(doc.resolve(&mk_before), original_mk, "redraw must not rewrite the source MK");
                    let doc = saved(&doc, full);
                    let f = field(&fields(&doc), &name).clone();
                    assert_eq!(f.tooltip.as_deref(), Some("Picture help"));
                    let w = &f.widgets[0];
                    let wd = doc.get(w.obj);
                    let mk_object = doc.resolve(wd.as_dict().unwrap().get(b"MK").unwrap());
                    let mk = mk_object.as_dict().unwrap();
                    assert_eq!(mk.get(b"CA").unwrap().as_ref().is_some(), indirect_caption);
                    assert_eq!(doc.resolve(mk.get(b"CA").unwrap()).as_string().unwrap().bytes, b"Original caption");
                    assert_eq!(mk.get(b"TP").unwrap().as_ref().is_some(), indirect_layout);
                    assert_eq!(doc.resolve(mk.get(b"TP").unwrap()).as_int(), Some(i64::from(icon_only)));
                    assert_eq!(mk.name(b"VendorNote"), Some(&b"Retained"[..]));
                    let appearance = ap(&doc, w);
                    assert_eq!(appearance.contains("(Original caption) Tj"), !icon_only, "{appearance}");
                    assert_eq!(appearance.matches("/Icon Do").count(), 1, "{appearance}");
                    assert!(appearance.contains("24.000000 0 0 24.000000 52.000 1.000 cm"), "{appearance}");
                    let n = wd.as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().reference(b"N").unwrap();
                    let appearance_object = doc.get(n);
                    let Object::Stream(stream) = &*appearance_object else { panic!("appearance") };
                    let resource_icon =
                        stream.dict.get(b"Resources").unwrap().as_dict().unwrap().get(b"XObject").unwrap().as_dict().unwrap().get(b"Icon").unwrap();
                    assert_eq!(resource_icon, mk.get(b"I").unwrap());
                    let icon_object = doc.resolve(resource_icon);
                    let Object::Stream(icon) = &*icon_object else { panic!("icon") };
                    assert_eq!(icon.decoded().unwrap(), icon_bytes);
                }
            }
        }
    }
}

/// A check box's down appearances survive a redraw for the states it still draws (same names),
/// and a down appearance for a state it no longer has is dropped rather than left stale.
#[test]
fn check_box_redraw_keeps_down_states_it_still_draws() {
    let mut doc = one_page();
    let name = add_field(&mut doc, 0, [50.0, 600.0, 70.0, 620.0], &NewField::CheckBox, Some("agree")).unwrap();
    let widget = field(&fields(&doc), &name).widgets[0].obj;
    let on = field(&fields(&doc), &name).widgets[0].on_state.clone().unwrap_or_else(|| "Yes".into());
    let mut ap = doc.get(widget).as_dict().unwrap().get(b"AP").unwrap().as_dict().unwrap().clone();
    let mut down = Dict::new();
    for state in [on.as_bytes(), b"Off".as_slice(), b"Gone".as_slice()] {
        let mut d = Dict::new();
        d.set(b"Subtype".to_vec(), Object::name("Form"));
        d.set(b"BBox".to_vec(), Object::Array(vec![0.into(), 0.into(), 20.into(), 20.into()]));
        let r = doc.add(Object::Stream(pdfcraft_cos::Stream::from_raw(d, b"0 0 20 20 re f\n".to_vec())));
        down.set(state.to_vec(), Object::Ref(r));
    }
    ap.set(b"D".to_vec(), Object::Dict(down));
    doc.update_dict(widget, |d| d.set(b"AP".to_vec(), Object::Dict(ap))).unwrap();
    set_props(&mut doc, &name, &FieldProps { tooltip: Some("Tick to agree".into()), ..FieldProps::default() }).unwrap();
    let ap = doc.get(widget).as_dict().unwrap().get(b"AP").map(|a| doc.resolve(a)).unwrap();
    let d = ap.as_dict().unwrap().get(b"D").map(|d| doc.resolve(d)).expect("down states kept");
    let d = d.as_dict().unwrap();
    assert!(d.contains(on.as_bytes()) && d.contains(b"Off"));
    assert!(!d.contains(b"Gone"), "a state the box no longer draws");
}

#[test]
fn recalc_chain_where_script_changes_checkbox() {
    struct TestScripts;
    impl Scripts for TestScripts {
        fn run(&mut self, _event: FieldEvent, script: &str, _target: &Field, _value: &str, fields: &[Field]) -> ScriptResult {
            if script == "set_box" {
                ScriptResult {
                    rc: true,
                    value: "calc1".into(),
                    changes: vec![FieldChange {
                        name: "agree".into(),
                        value: Some(vec!["Yes".into()]),
                        read_only: None,
                        required: None,
                        display: None,
                    }],
                    message: None,
                }
            } else if script == "read_box" {
                let box_val = fields.iter().find(|f| f.name == "agree").and_then(|f| f.value.first()).cloned().unwrap_or_default();
                ScriptResult { rc: true, value: format!("box_was_{box_val}"), changes: Vec::new(), message: None }
            } else {
                ScriptResult { rc: true, value: String::new(), changes: Vec::new(), message: None }
            }
        }
    }

    let mut doc = one_page();
    add_field(&mut doc, 0, [10.0, 10.0, 100.0, 30.0], &NewField::Text { multiline: false }, Some("trigger")).unwrap();
    add_field(&mut doc, 0, [10.0, 40.0, 30.0, 60.0], &NewField::CheckBox, Some("agree")).unwrap();
    add_field(&mut doc, 0, [10.0, 70.0, 100.0, 90.0], &NewField::Text { multiline: false }, Some("result")).unwrap();

    set_field_script(&mut doc, "trigger", "calculate", Some("set_box")).unwrap();
    set_field_script(&mut doc, "result", "calculate", Some("read_box")).unwrap();

    let changed = recalculate_with(&mut doc, &mut TestScripts).unwrap();
    assert!(changed >= 2);

    let all = fields(&doc);
    assert_eq!(field(&all, "agree").value, ["Yes"], "checkbox was set by script in recalc chain");
    assert_eq!(field(&all, "result").value, ["box_was_Yes"], "second recalc saw the normalized checkbox value");
}

#[test]
fn partial_appearance_keeps_custom_default_appearance_and_font_resources() {
    let mut doc = fixture();
    let obj = field(&fields(&doc), "name").obj;
    let af = doc.get(doc.root().unwrap()).as_dict().unwrap().reference(b"AcroForm").unwrap();
    let mut dr = doc.get(af).as_dict().unwrap().get(b"DR").map(|v| doc.resolve(v)).unwrap().as_dict().cloned().unwrap();
    let mut fonts = dr.get(b"Font").map(|v| doc.resolve(v)).unwrap().as_dict().cloned().unwrap();
    let resource = fonts.get(b"Helv").cloned().unwrap();
    fonts.set(b"ProjectFont".to_vec(), resource.clone());
    dr.set(b"Font".to_vec(), Object::Dict(fonts));
    doc.update_dict(af, |d| d.set(b"DR".to_vec(), Object::Dict(dr))).unwrap();
    let da = "/ProjectFont 13 Tf 0.15 g 2 Tc";
    doc.update_dict(obj, |d| d.set(b"DA".to_vec(), pdfcraft_cos::PdfString::literal(da.as_bytes().to_vec()))).unwrap();

    let patch = LookPatch { border: Some(Some([1.0, 0.0, 0.0])), width: Some(3.0), ..Default::default() };
    set_props(&mut doc, "name", &FieldProps { appearance: Some(patch), ..Default::default() }).unwrap();
    let f = field(&fields(&doc), "name").clone();
    assert_eq!(f.da, da, "a border edit must not replace the custom font or colour space");
    assert_eq!(f.value, ["Ada"]);
    assert_eq!(look(&doc, &f).fill, Some([1.0, 1.0, 0.9]));

    set_props(&mut doc, "name", &FieldProps { font_size: Some(18.0), ..Default::default() }).unwrap();
    let f = field(&fields(&doc), "name").clone();
    // The size is rewritten in place: other operators survive and the string doesn't grow.
    assert_eq!(f.da, "/ProjectFont 18 Tf 0.15 g 2 Tc", "other default-appearance operators survive");
    assert_eq!(appearance::parse_da(&f.da).font, "ProjectFont");
    assert_eq!(appearance::parse_da(&f.da).size, 18.0);

    set_props(
        &mut doc,
        "name",
        &FieldProps { appearance: Some(LookPatch { text: Some([0.0, 0.0, 1.0]), ..Default::default() }), ..Default::default() },
    )
    .unwrap();
    let doc = reopen(&doc);
    let f = field(&fields(&doc), "name").clone();
    assert_eq!(f.da, "/ProjectFont 18 Tf 0 0 1 rg 2 Tc", "the colour is replaced where it was");
    assert_eq!(appearance::parse_da(&f.da).font, "ProjectFont");
    assert_eq!(appearance::parse_da(&f.da).color, "0 0 1 rg");
    let dr = doc.get(af).as_dict().unwrap().get(b"DR").map(|v| doc.resolve(v)).unwrap();
    let fonts = dr.as_dict().unwrap().get(b"Font").map(|v| doc.resolve(v)).unwrap();
    assert_eq!(fonts.as_dict().unwrap().get(b"ProjectFont"), Some(&resource));
}

#[test]
fn repeated_partial_appearance_edits_keep_the_default_appearance_one_operator_each() {
    let mut doc = fixture();
    for size in [9.0, 11.0, 14.0, 250.0, 400.0] {
        let props = FieldProps {
            appearance: Some(LookPatch { text: Some([0.0, 0.5, 0.0]), ..Default::default() }),
            font_size: Some(size),
            ..Default::default()
        };
        set_props(&mut doc, "name", &props).unwrap();
    }
    let da = field(&fields(&doc), "name").da.clone();
    assert_eq!(da.matches("Tf").count(), 1, "{da}");
    assert_eq!(da.matches(" rg").count() + da.matches(" g").count(), 1, "{da}");
    // Sizes up to the 300 points `parse_da` reads are kept, not cut to 100.
    assert_eq!(appearance::parse_da(&da).size, 300.0, "{da}");
}

#[test]
fn a_font_only_edit_leaves_the_widget_and_a_shared_indirect_border_untouched() {
    let mut doc = fixture();
    let widgets = field(&fields(&doc), "size").widgets.clone();
    let mut mk = pdfcraft_cos::Dict::new();
    mk.set(b"BC".to_vec(), Object::Array(vec![0.into(), 0.into(), 1.into()]));
    let shared = doc.add(Object::Dict(mk));
    for w in &widgets {
        doc.update_dict(w.obj, |d| d.set(b"MK".to_vec(), Object::Ref(shared))).unwrap();
    }
    let border = |doc: &Document| -> Vec<_> {
        widgets.iter().map(|w| doc.get(w.obj).as_dict().map(|d| (d.get(b"MK").cloned(), d.get(b"BS").cloned()))).collect()
    };
    let before = border(&doc);
    set_props(&mut doc, "size", &FieldProps { font_size: Some(12.0), ..Default::default() }).unwrap();
    assert_eq!(border(&doc), before, "a size-only edit leaves each widget's /MK and /BS alone");
    // A border edit updates the shared /MK where it lives instead of copying it into each widget.
    let patch = LookPatch { border: Some(Some([1.0, 0.0, 0.0])), ..Default::default() };
    set_props(&mut doc, "size", &FieldProps { appearance: Some(patch), ..Default::default() }).unwrap();
    for w in &widgets {
        assert_eq!(doc.get(w.obj).as_dict().unwrap().get(b"MK"), Some(&Object::Ref(shared)), "the widget still points at the shared /MK");
    }
    let shared_mk = doc.get(shared).as_dict().cloned().unwrap();
    assert_eq!(shared_mk.get(b"BC"), Some(&Object::Array(vec![Object::Real(1.0), Object::Real(0.0), Object::Real(0.0)])));
}

#[test]
fn partial_appearance_preserves_each_widgets_indirect_colours_and_border_extensions() {
    let mut doc = fixture();
    let widgets = field(&fields(&doc), "size").widgets.clone();
    let mut refs = Vec::new();
    for (i, widget) in widgets.iter().enumerate() {
        let mut mk = pdfcraft_cos::Dict::new();
        mk.set(b"BG".to_vec(), Object::Array(vec![Object::Real(i as f64), 0.into(), 1.into()]));
        mk.set(b"BC".to_vec(), Object::Array(vec![0.into(), Object::Real(i as f64), 0.into()]));
        mk.set(b"CA".to_vec(), pdfcraft_cos::PdfString::text("l"));
        mk.set(b"R".to_vec(), Object::Int(90));
        mk.set(b"VendorKey".to_vec(), Object::Int(71));
        let mk_ref = doc.add(Object::Dict(mk));
        let mut bs = pdfcraft_cos::Dict::new();
        bs.set(b"S".to_vec(), Object::name("D"));
        bs.set(b"W".to_vec(), Object::Real(1.0));
        bs.set(b"D".to_vec(), Object::Array(vec![4.into(), 2.into()]));
        bs.set(b"VendorKey".to_vec(), Object::Int(83));
        let bs_ref = doc.add(Object::Dict(bs));
        let da = if i == 0 { "/Helv 8 Tf 0.1 g" } else { "/Cour 19 Tf 0.3 g" };
        doc.update_dict(widget.obj, |d| {
            d.set(b"MK".to_vec(), Object::Ref(mk_ref));
            d.set(b"BS".to_vec(), Object::Ref(bs_ref));
            d.set(b"DA".to_vec(), pdfcraft_cos::PdfString::text(da));
        })
        .unwrap();
        refs.push(mk_ref);
    }
    let patch = LookPatch { width: Some(5.0), ..Default::default() };
    set_props(&mut doc, "size", &FieldProps { font_size: Some(16.0), appearance: Some(patch), ..Default::default() }).unwrap();
    for (i, widget) in widgets.iter().enumerate() {
        let wd = doc.get(widget.obj);
        let wd = wd.as_dict().unwrap();
        assert_eq!(wd.reference(b"MK"), Some(refs[i]), "untouched MK stays indirect");
        let bs = wd.get(b"BS").map(|v| doc.resolve(v)).unwrap();
        let bs = bs.as_dict().unwrap();
        assert_eq!(bs.get(b"W").and_then(Object::as_f64), Some(5.0));
        assert_eq!(bs.int(b"VendorKey"), Some(83));
        assert_eq!(bs.get(b"D").unwrap().as_array().unwrap().len(), 2);
        let da = wd.get(b"DA").map(|v| doc.resolve(v)).unwrap().as_string().unwrap().to_text();
        let parsed = appearance::parse_da(&da);
        assert_eq!(parsed.font, if i == 0 { "Helv" } else { "Cour" });
        assert_eq!(parsed.color, if i == 0 { "0.1 g" } else { "0.3 g" });
        assert_eq!(parsed.size, 16.0);
    }
    set_props(&mut doc, "size", &FieldProps { appearance: Some(LookPatch { fill: Some(None), ..Default::default() }), ..Default::default() })
        .unwrap();
    let doc = reopen(&doc);
    for widget in &widgets {
        let mk = doc.get(widget.obj).as_dict().unwrap().get(b"MK").map(|v| doc.resolve(v)).unwrap();
        let mk = mk.as_dict().unwrap();
        assert!(!mk.contains(b"BG"));
        assert!(mk.contains(b"BC") && mk.contains(b"CA"));
        assert_eq!(mk.int(b"R"), Some(90));
        assert_eq!(mk.int(b"VendorKey"), Some(71));
    }
}

/// A whole look sets the colours of an indirect /MK and keeps its mark, rotation and unknown
/// entries (#1322), as it already did for a direct one.
#[test]
fn a_whole_look_keeps_the_rest_of_an_indirect_mk() {
    let mut doc = fixture();
    let widget = field(&fields(&doc), "agree").widgets[0].obj;
    let mut mk = pdfcraft_cos::Dict::new();
    mk.set(b"CA".to_vec(), pdfcraft_cos::PdfString::text("8"));
    mk.set(b"R".to_vec(), Object::Int(90));
    mk.set(b"VendorKey".to_vec(), Object::Int(71));
    let mk_ref = doc.add(Object::Dict(mk));
    doc.update_dict(widget, |d| d.set(b"MK".to_vec(), Object::Ref(mk_ref))).unwrap();
    let new = Look {
        border: Some([1.0, 0.0, 0.0]),
        fill: Some([1.0, 1.0, 0.8]),
        width: 2.0,
        style: BorderStyle::Solid,
        text: [0.0; 3],
        font: FieldFont::Helvetica,
    };
    set_props(&mut doc, "agree", &FieldProps { look: Some(new), ..FieldProps::default() }).unwrap();
    let doc = reopen(&doc);
    let f = field(&fields(&doc), "agree").clone();
    assert_eq!((check_style(&doc, &f), f.widgets[0].rotation), (CheckStyle::Cross, 90));
    let mk = doc.get(widget).as_dict().unwrap().get(b"MK").map(|v| doc.resolve(v)).unwrap();
    let mk = mk.as_dict().unwrap();
    assert_eq!(mk.int(b"VendorKey"), Some(71));
    assert_eq!(look(&doc, &f).border, Some([1.0, 0.0, 0.0]));
    assert_eq!(look(&doc, &f).fill, Some([1.0, 1.0, 0.8]));
}

#[test]
fn invalid_appearance_patches_are_refused_before_anything_is_written() {
    let mut doc = fixture();
    let before = write_incremental(&doc, &SaveOptions::default()).unwrap();
    for size in [f64::NAN, f64::INFINITY, -1.0] {
        assert!(
            set_props(&mut doc, "name", &FieldProps { font_size: Some(size), tooltip: Some("Not applied".into()), ..Default::default() }).is_err()
        );
        assert_eq!(write_incremental(&doc, &SaveOptions::default()).unwrap(), before);
    }
    for patch in [
        LookPatch { width: Some(f64::NAN), ..Default::default() },
        LookPatch { width: Some(-1.0), ..Default::default() },
        LookPatch { fill: Some(Some([f64::INFINITY, 0.0, 0.0])), ..Default::default() },
        LookPatch { text: Some([1.1, 0.0, 0.0]), ..Default::default() },
    ] {
        assert!(
            set_props(&mut doc, "name", &FieldProps { appearance: Some(patch), tooltip: Some("Not applied".into()), ..Default::default() }).is_err()
        );
        assert_eq!(write_incremental(&doc, &SaveOptions::default()).unwrap(), before);
    }
    let props = FieldProps {
        appearance: Some(LookPatch { width: Some(2.0), ..Default::default() }),
        look: Some(look(&doc, &field(&fields(&doc), "name").clone())),
        ..Default::default()
    };
    assert!(set_props(&mut doc, "name", &props).is_err());
    assert_eq!(write_incremental(&doc, &SaveOptions::default()).unwrap(), before);
}

#[test]
fn page_shapes_preserves_closed_path_rectangle_height() {
    let shapes = |content: &[u8]| {
        let mut doc = fixture();
        let page = pdfcraft_model::pages(&doc)[0].obj;
        let stream = doc.add(Object::Stream(pdfcraft_cos::Stream::flate(Default::default(), content)));
        doc.update_dict(page, |d| d.set(b"Contents".to_vec(), Object::Ref(stream))).unwrap();
        crate::detect::page_shapes(&doc, 0)
    };
    let shorthand = shapes(b"50 100 120 40 re S");
    let outlined = shapes(b"50 100 m 170 100 l 170 140 l 50 140 l h S");
    assert_eq!(outlined, shorthand, "equivalent rectangle encodings must have equal detection geometry");
    let fields = crate::detect::detect(&[], &outlined, &[], &[]);
    assert_eq!(fields.len(), 1);
    assert_eq!(fields[0].rect, [51.0, 101.0, 169.0, 139.0]);
}

fn detection_test_shapes(content: &[u8]) -> crate::detect::Shapes {
    let mut doc = fixture();
    let page = pdfcraft_model::pages(&doc)[0].obj;
    let stream = doc.add(Object::Stream(pdfcraft_cos::Stream::flate(Default::default(), content)));
    doc.update_dict(page, |d| d.set(b"Contents".to_vec(), Object::Ref(stream))).unwrap();
    crate::detect::page_shapes(&doc, 0)
}

#[test]
fn page_shapes_accepts_rectangle_closure_and_paint_variants() {
    for end in ["h S", "s", "50 100 l S", "f", "F", "f*", "B", "B*", "b", "b*"] {
        let content = format!("50 100 m 170 100 l 170 140 l 50 140 l {end}");
        let shapes = detection_test_shapes(content.as_bytes());
        assert_eq!(shapes.boxes, [[50.0, 100.0, 170.0, 140.0]], "{end}");
        assert!(shapes.rules.is_empty(), "rectangle edges must not become extra fields: {end}");
    }
}

/// #2942: a cell drawn with a point in the middle of each vertical side (the French 2042 form's
/// letter cells), or on every side, is the rectangle it looks like. A point that turns back
/// along a side is not on the way between its neighbours, so such a path is still not a box.
#[test]
fn page_shapes_reads_rectangles_with_points_along_their_sides() {
    for content in [
        "100 100 m 111.1 100 l 111.1 107.35 l 111.1 114.7 l 100 114.7 l 100 107.35 l h f",
        "100 100 m 105 100 l 111.1 100 l 111.1 107.35 l 111.1 114.7 l 105 114.7 l 100 114.7 l 100 107.35 l h S",
        "100 107.35 m 100 100 l 111.1 100 l 111.1 114.7 l 100 114.7 l h f",
    ] {
        let shapes = detection_test_shapes(content.as_bytes());
        assert_eq!(shapes.boxes, [[100.0, 100.0, 111.1, 114.7]], "{content}");
    }
    for content in [
        // Out past the corner and back: a spike, not a side.
        "100 100 m 130 100 l 111.1 100 l 111.1 114.7 l 100 114.7 l h S",
        // A sixth point off the sides.
        "100 100 m 111.1 100 l 115 107 l 111.1 114.7 l 100 114.7 l 100 107.35 l h S",
    ] {
        assert!(detection_test_shapes(content.as_bytes()).boxes.is_empty(), "{content}");
    }
}

#[test]
fn page_shapes_rejects_open_diagonal_curved_and_complex_rectangles() {
    for content in [
        "50 100 m 170 100 l 170 140 l 50 140 l S",
        "50 100 m 170 110 l 170 150 l 50 140 l h S",
        "50 100 m 170 100 l 170 140 l 100 150 80 150 50 140 c h S",
        "50 100 m 170 100 l 170 140 l h 50 140 l f",
        "50 100 m 170 100 l 50 100 l 50 140 l h S",
    ] {
        assert!(detection_test_shapes(content.as_bytes()).boxes.is_empty(), "{content}");
    }
}

#[test]
fn page_shapes_preserves_multiple_subpaths_and_discards_unpainted_paths() {
    let shapes = detection_test_shapes(b"50 100 120 40 re 200 100 m 320 100 l 320 140 l 200 140 l h 50 400 m 170 400 l S");
    assert_eq!(shapes.boxes, [[50.0, 100.0, 170.0, 140.0], [200.0, 100.0, 320.0, 140.0]]);
    assert_eq!(shapes.rules, [[50.0, 400.0, 170.0, 400.0]]);
    assert_eq!(detection_test_shapes(b"50 100 m 170 100 l 170 140 l 50 140 l h W n"), crate::detect::Shapes::default());
    let continued = detection_test_shapes(b"50 100 120 40 re 170 100 l 170 140 l 50 140 l h S");
    assert_eq!(continued.boxes, [[50.0, 100.0, 170.0, 140.0]], "continuing re must not invent a second box");
}

#[test]
fn page_shapes_transforms_path_rectangles_and_preserves_rules() {
    let scaled = detection_test_shapes(b"q 2 0 0 2 0 0 cm 50 100 m 170 100 l 170 140 l 50 140 l h S Q 10 20 m 100 20 l S");
    assert_eq!(scaled.boxes, [[100.0, 200.0, 340.0, 280.0]]);
    assert_eq!(scaled.rules, [[10.0, 20.0, 100.0, 20.0]]);
    let rotated = detection_test_shapes(b"0 1 -1 0 300 0 cm 50 100 m 170 100 l 170 140 l 50 140 l h S");
    assert_eq!(rotated.boxes, [[160.0, 50.0, 200.0, 170.0]]);
}

#[test]
fn page_shapes_closes_only_last_stroked_subpath_but_all_filled_subpaths() {
    let paths = "50 100 m 170 100 l 170 140 l 50 140 l 200 100 m 320 100 l 320 140 l 200 140 l";
    let stroked = detection_test_shapes(format!("{paths} s").as_bytes());
    assert_eq!(stroked.boxes, [[200.0, 100.0, 320.0, 140.0]]);
    assert_eq!(stroked.rules, [[50.0, 100.0, 170.0, 100.0], [50.0, 140.0, 170.0, 140.0]]);
    let filled = detection_test_shapes(format!("{paths} f").as_bytes());
    assert_eq!(filled.boxes, [[50.0, 100.0, 170.0, 140.0], [200.0, 100.0, 320.0, 140.0]]);
    assert!(filled.rules.is_empty());
}

#[test]
fn auto_text_size_fits_single_and_multiline_text() {
    use crate::appearance::auto_text_size;
    use pdfcraft_fonts::{helvetica_width, wrap_with};
    let long = "Weekly progress and diligence: CoBank refi, IL and Redwood Falls";
    // Single line: the height's size for short text, shrunk to the width for long text.
    assert_eq!(auto_text_size("Hi", 94.0, 8.0, false, helvetica_width), 8.0 / 1.15);
    let s = auto_text_size(long, 194.0, 8.0, false, helvetica_width);
    assert!(s > 4.0 && s < 8.0 / 1.15 && helvetica_width(long, s) <= 194.0 + 1e-9, "{s}");
    // Never past 12 pt or under 4 pt.
    assert_eq!(auto_text_size("Hi", 500.0, 500.0, false, helvetica_width), 12.0);
    assert_eq!(auto_text_size(&long.repeat(20), 20.0, 8.0, false, helvetica_width), 4.0);
    // Multiline: the largest size whose wrapped lines fit the height.
    let m = auto_text_size(long, 114.0, 44.0, true, helvetica_width);
    assert!(wrap_with(long, m, 114.0, helvetica_width).len() as f64 * m * 1.15 <= 44.0, "{m}");
    assert!(wrap_with(long, m + 0.5, 114.0, helvetica_width).len() as f64 * (m + 0.5) * 1.15 > 44.0, "{m} is the largest that fits");
    // Hostile boxes and measurements don't panic or return nonsense.
    for (w, h) in [(f64::NAN, 10.0), (10.0, f64::INFINITY), (-5.0, -5.0), (0.0, 0.0)] {
        for multiline in [false, true] {
            let s = auto_text_size(long, w, h, multiline, helvetica_width);
            assert!((4.0..=12.0).contains(&s), "{w}×{h}: {s}");
        }
    }
    assert_eq!(auto_text_size(long, 50.0, 10.0, false, |_, _| f64::NAN), 10.0 / 1.15);
}

#[test]
fn document_scripts_read_each_name_tree_node_once() {
    // The root lists itself and the leaf twice each.
    let doc = document(&[
        "<< /Type /Catalog /Pages 2 0 R /Names << /JavaScript 3 0 R >> >>".into(),
        "<< /Type /Pages /Kids [] /Count 0 >>".into(),
        "<< /Kids [3 0 R 4 0 R 3 0 R 4 0 R] >>".into(),
        "<< /Names [(init) 5 0 R] >>".into(),
        "<< /S /JavaScript /JS (var ready = true;) >>".into(),
    ]);
    assert_eq!(document_scripts_named(&doc), [("init".to_string(), "var ready = true;".to_string())]);
}