use crate::ref_chain::resolve_ref_chain;
use crate::{Dictionary, Object, Pdf, Result};
use std::io::{Read, Seek};
pub const DEFAULT_MAX_NAME_TREE_DESTS_DEPTH: usize = 100;
pub(crate) fn collect_name_tree_dests_raw<R: Read + Seek>(
pdf: &mut Pdf<R>,
max_depth: usize,
) -> Result<Vec<(Vec<u8>, Object)>> {
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(vec![]),
};
let Some(catalog) = pdf.resolve_borrowed(catalog_ref)?.as_dict() else {
return Ok(vec![]);
};
let names_dict = match catalog.get("Names").cloned() {
Some(Object::Reference(r)) => match resolve_ref_chain(pdf, &Object::Reference(r))?.0 {
Object::Dictionary(d) => d,
_ => return Ok(vec![]),
},
Some(Object::Dictionary(d)) => d,
_ => return Ok(vec![]),
};
let dests_value = match names_dict.get("Dests").cloned() {
Some(v) => v,
None => return Ok(vec![]),
};
crate::name_number_tree::read_name_tree(pdf, dests_value, |_, v| Ok(Some(v)), max_depth)
}
pub fn insert_name_tree_dest<R: Read + Seek>(
pdf: &mut Pdf<R>,
key: &[u8],
value: Object,
) -> Result<()> {
let mut entries = collect_name_tree_dests_raw(pdf, DEFAULT_MAX_NAME_TREE_DESTS_DEPTH)?;
if let Some(existing) = entries.iter_mut().find(|(k, _)| k.as_slice() == key) {
existing.1 = value;
} else {
entries.push((key.to_vec(), value));
entries.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
}
rebuild_name_tree_dests(pdf, entries)
}
pub fn delete_name_tree_dest<R: Read + Seek>(pdf: &mut Pdf<R>, key: &[u8]) -> Result<bool> {
let mut entries = collect_name_tree_dests_raw(pdf, DEFAULT_MAX_NAME_TREE_DESTS_DEPTH)?;
let before = entries.len();
entries.retain(|(k, _)| k != key);
if entries.len() == before {
return Ok(false); }
rebuild_name_tree_dests(pdf, entries)?;
Ok(true)
}
fn rebuild_name_tree_dests<R: Read + Seek>(
pdf: &mut Pdf<R>,
entries: Vec<(Vec<u8>, Object)>,
) -> Result<()> {
let catalog_ref = match pdf.root_ref() {
Some(r) => r,
None => return Ok(()),
};
let Some(mut catalog) = pdf.resolve_borrowed(catalog_ref)?.as_dict().cloned() else {
return Ok(());
};
let mut next_num: u32 = pdf
.object_refs()
.iter()
.map(|r| r.number)
.max()
.unwrap_or(0);
let mut alloc = move || -> crate::ObjectRef {
next_num += 1;
crate::ObjectRef::new(next_num, 0)
};
if entries.is_empty() {
let names_dict_opt = match catalog.get("Names") {
Some(value @ Object::Reference(r)) => {
let (terminal, terminal_ref) = resolve_ref_chain(pdf, value)?;
terminal
.into_dict()
.map(|d| (Some(terminal_ref.unwrap_or(*r)), d))
}
Some(Object::Dictionary(d)) => Some((None, d.clone())),
_ => None, };
if let Some((names_ref_opt, mut names_dict)) = names_dict_opt {
names_dict.remove("Dests");
if names_dict.iter().next().is_none() {
catalog.remove("Names");
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
if let Some(r) = names_ref_opt {
pdf.delete_object(r);
}
} else {
match names_ref_opt {
Some(r) => {
pdf.set_object(r, Object::Dictionary(names_dict));
catalog.insert("Names", Object::Reference(r));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
}
None => {
catalog.insert("Names", Object::Dictionary(names_dict));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
}
}
}
} return Ok(());
}
let (tree_root_ref, nodes) = crate::name_number_tree::build_name_tree(&entries, &mut alloc);
for (node_ref, node) in nodes {
pdf.set_object(node_ref, node);
}
let (names_ref, mut names_dict) = match catalog.get("Names") {
Some(value @ Object::Reference(r)) => {
let (terminal, terminal_ref) = resolve_ref_chain(pdf, value)?;
match terminal.into_dict() {
Some(d) => (terminal_ref.unwrap_or(*r), d),
None => {
let r2 = alloc();
(r2, Dictionary::new())
}
}
}
Some(Object::Dictionary(d)) => {
let r = alloc();
(r, d.clone())
}
_ => {
let r = alloc();
(r, Dictionary::new())
}
};
names_dict.insert("Dests", Object::Reference(tree_root_ref));
pdf.set_object(names_ref, Object::Dictionary(names_dict));
catalog.insert("Names", Object::Reference(names_ref));
pdf.set_object(catalog_ref, Object::Dictionary(catalog));
Ok(())
}