oxidize_pdf/operations/

split.rs

//! PDF splitting functionality
//!
//! This module provides functionality to split PDF documents into multiple files
//! based on page ranges or other criteria.
//!
//! This legacy API reconstructs a new [`crate::Document`]. Use
//! [`super::split_pdf_lossless`] when complete reachable source semantics must
//! be retained or rejected explicitly through a dry-run report.

use super::{OperationError, OperationResult, PageRange};
use crate::parser::page_tree::ParsedPage;
use crate::parser::{PdfDocument, PdfReader};
use crate::{Document, Page};
use std::fs::File;
use std::path::{Path, PathBuf};

/// Options for PDF splitting
#[derive(Debug, Clone)]
pub struct SplitOptions {
    /// How to split the document
    pub mode: SplitMode,
    /// Output file naming pattern
    pub output_pattern: String,
    /// Whether to preserve document metadata
    pub preserve_metadata: bool,
    /// Whether to optimize output files
    pub optimize: bool,
}

impl Default for SplitOptions {
    fn default() -> Self {
        Self {
            mode: SplitMode::SinglePages,
            output_pattern: "page_{}.pdf".to_string(),
            preserve_metadata: true,
            optimize: false,
        }
    }
}

/// Split mode specification
#[derive(Debug, Clone)]
pub enum SplitMode {
    /// Split into single pages
    SinglePages,
    /// Split by page ranges
    Ranges(Vec<PageRange>),
    /// Split into chunks of N pages
    ChunkSize(usize),
    /// Split at specific page numbers (creates files before each split point)
    SplitAt(Vec<usize>),
}

/// PDF splitter
pub struct PdfSplitter {
    document: PdfDocument<File>,
    options: SplitOptions,
}

impl PdfSplitter {
    /// Create a new PDF splitter
    pub fn new(document: PdfDocument<File>, options: SplitOptions) -> Self {
        Self { document, options }
    }

    /// Split the PDF according to the options
    pub fn split(&mut self) -> OperationResult<Vec<PathBuf>> {
        let total_pages =
            self.document
                .page_count()
                .map_err(|e| OperationError::ParseError(e.to_string()))? as usize;

        if total_pages == 0 {
            return Err(OperationError::NoPagesToProcess);
        }

        let ranges = match &self.options.mode {
            SplitMode::SinglePages => {
                // Create a range for each page
                (0..total_pages).map(PageRange::Single).collect()
            }
            SplitMode::Ranges(ranges) => ranges.clone(),
            SplitMode::ChunkSize(size) => {
                // Create ranges for chunks
                let mut ranges = Vec::new();
                let mut start = 0;
                while start < total_pages {
                    let end = (start + size - 1).min(total_pages - 1);
                    ranges.push(PageRange::Range(start, end));
                    start += size;
                }
                ranges
            }
            SplitMode::SplitAt(split_points) => {
                // Create ranges between split points
                let mut ranges = Vec::new();
                let mut start = 0;

                for &split_point in split_points {
                    if split_point > 0 && split_point < total_pages {
                        ranges.push(PageRange::Range(start, split_point - 1));
                        start = split_point;
                    }
                }

                // Add the last range
                if start < total_pages {
                    ranges.push(PageRange::Range(start, total_pages - 1));
                }

                ranges
            }
        };

        // Process each range
        let mut output_files = Vec::new();

        for (index, range) in ranges.iter().enumerate() {
            let output_path = self.format_output_path(index, range);
            self.extract_range(range, &output_path)?;
            output_files.push(output_path);
        }

        Ok(output_files)
    }

    /// Extract a page range to a new PDF file
    fn extract_range(&mut self, range: &PageRange, output_path: &Path) -> OperationResult<()> {
        let total_pages =
            self.document
                .page_count()
                .map_err(|e| OperationError::ParseError(e.to_string()))? as usize;

        let indices = range.get_indices(total_pages)?;
        if indices.is_empty() {
            return Err(OperationError::NoPagesToProcess);
        }

        // Create new document
        let mut doc = Document::new();

        // Copy metadata if requested
        if self.options.preserve_metadata {
            if let Ok(metadata) = self.document.metadata() {
                if let Some(title) = metadata.title {
                    doc.set_title(&title);
                }
                if let Some(author) = metadata.author {
                    doc.set_author(&author);
                }
                if let Some(subject) = metadata.subject {
                    doc.set_subject(&subject);
                }
                if let Some(keywords) = metadata.keywords {
                    doc.set_keywords(&keywords);
                }
            }
        }

        // Extract and add pages
        for &page_idx in &indices {
            let parsed_page = self
                .document
                .get_page(page_idx as u32)
                .map_err(|e| OperationError::ParseError(e.to_string()))?;

            let page = self.convert_page(&parsed_page)?;
            doc.add_page(page);
        }

        // Save the document
        doc.save(output_path)?;

        Ok(())
    }

    /// Convert a parsed page to a new page, preserving its content verbatim.
    ///
    /// Copies the original content streams and resources (fonts, images,
    /// XObjects) unchanged via [`Page::from_parsed_with_content`], the same path
    /// `merge` uses. The former implementation re-emitted the page through the
    /// high-level API — mapping every font to one of the standard 14, decoding
    /// bytes with `from_utf8`, and dropping every operator it did not recognize
    /// — so it lost images and mangled any non-ASCII or CID-encoded text
    /// (#453). `/Rotate` is carried over by `from_parsed_with_content`.
    fn convert_page(&mut self, parsed_page: &ParsedPage) -> OperationResult<Page> {
        Page::from_parsed_with_content(parsed_page, &self.document)
            .map_err(|e| OperationError::ParseError(e.to_string()))
    }

    /// Format the output path based on the pattern
    fn format_output_path(&self, index: usize, range: &PageRange) -> PathBuf {
        let filename = match range {
            PageRange::Single(page) => self
                .options
                .output_pattern
                .replace("{}", &(page + 1).to_string())
                .replace("{n}", &(index + 1).to_string())
                .replace("{page}", &(page + 1).to_string()),
            PageRange::Range(start, end) => self
                .options
                .output_pattern
                .replace("{}", &format!("{}-{}", start + 1, end + 1))
                .replace("{n}", &(index + 1).to_string())
                .replace("{start}", &(start + 1).to_string())
                .replace("{end}", &(end + 1).to_string()),
            _ => self
                .options
                .output_pattern
                .replace("{}", &(index + 1).to_string())
                .replace("{n}", &(index + 1).to_string()),
        };

        PathBuf::from(filename)
    }
}

/// Split a PDF file by page ranges
pub fn split_pdf<P: AsRef<Path>>(
    input_path: P,
    options: SplitOptions,
) -> OperationResult<Vec<PathBuf>> {
    let document = PdfReader::open_document(input_path)
        .map_err(|e| OperationError::ParseError(e.to_string()))?;

    let mut splitter = PdfSplitter::new(document, options);
    splitter.split()
}

/// Split a PDF file into single pages
pub fn split_into_pages<P: AsRef<Path>>(
    input_path: P,
    output_pattern: &str,
) -> OperationResult<Vec<PathBuf>> {
    let options = SplitOptions {
        mode: SplitMode::SinglePages,
        output_pattern: output_pattern.to_string(),
        ..Default::default()
    };

    split_pdf(input_path, options)
}

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

    #[test]
    fn test_split_options_default() {
        let options = SplitOptions::default();
        assert!(matches!(options.mode, SplitMode::SinglePages));
        assert_eq!(options.output_pattern, "page_{}.pdf");
        assert!(options.preserve_metadata);
        assert!(!options.optimize);
    }

    #[test]
    fn test_format_output_path() {
        let _options = SplitOptions {
            output_pattern: "output_page_{}.pdf".to_string(),
            ..Default::default()
        };

        let _reader = PdfReader::open("test.pdf");
        // Note: This test would need a valid PDF file to work properly
        // For now, we're just testing the logic
    }

    // ============= Additional Split Tests =============

    #[test]
    fn test_split_mode_variants() {
        // Test SinglePages variant
        let single_pages = SplitMode::SinglePages;
        assert!(matches!(single_pages, SplitMode::SinglePages));

        // Test Ranges variant
        let ranges = SplitMode::Ranges(vec![
            super::PageRange::Single(0),
            super::PageRange::Range(5, 10),
        ]);
        assert!(matches!(ranges, SplitMode::Ranges(_)));

        // Test ChunkSize variant
        let chunk = SplitMode::ChunkSize(5);
        if let SplitMode::ChunkSize(size) = chunk {
            assert_eq!(size, 5);
        } else {
            panic!("Expected ChunkSize");
        }

        // Test SplitAt variant
        let split_at = SplitMode::SplitAt(vec![5, 10, 15]);
        assert!(matches!(split_at, SplitMode::SplitAt(_)));
    }

    #[test]
    fn test_split_options_with_modes() {
        let options = SplitOptions {
            mode: SplitMode::ChunkSize(10),
            output_pattern: "chunk_{}.pdf".to_string(),
            preserve_metadata: true,
            optimize: true,
        };

        assert!(matches!(options.mode, SplitMode::ChunkSize(10)));
        assert_eq!(options.output_pattern, "chunk_{}.pdf");
        assert!(options.preserve_metadata);
        assert!(options.optimize);
    }

    #[test]
    fn test_split_options_page_range() {
        let ranges = vec![
            super::PageRange::All,
            super::PageRange::Single(5),
            super::PageRange::Range(10, 20),
            super::PageRange::List(vec![1, 3, 5, 7, 9]),
        ];

        let options = SplitOptions {
            mode: SplitMode::Ranges(ranges),
            ..Default::default()
        };

        if let SplitMode::Ranges(r) = options.mode {
            assert_eq!(r.len(), 4);
        } else {
            panic!("Expected Ranges mode");
        }
    }

    #[test]
    fn test_split_options_split_at() {
        let split_points = vec![3, 6, 9, 12]; // Split at these page numbers

        let options = SplitOptions {
            mode: SplitMode::SplitAt(split_points.clone()),
            output_pattern: "part_{}.pdf".to_string(),
            ..Default::default()
        };

        if let SplitMode::SplitAt(points) = options.mode {
            assert_eq!(points.len(), 4);
            assert_eq!(points, split_points);
        } else {
            panic!("Expected SplitAt mode");
        }
    }

    #[test]
    fn test_output_pattern_formatting() {
        // Test various output patterns
        let patterns = vec![
            "output_{}.pdf",
            "page_{}.pdf",
            "document_part_{}.pdf",
            "{}_split.pdf",
        ];

        for pattern in patterns {
            let options = SplitOptions {
                output_pattern: pattern.to_string(),
                ..Default::default()
            };
            assert!(options.output_pattern.contains("{")); // Just check for placeholder
        }
    }

    #[test]
    fn test_split_options_preserve_metadata() {
        // Test preserve_metadata flag
        let with_metadata = SplitOptions {
            preserve_metadata: true,
            ..Default::default()
        };
        assert!(with_metadata.preserve_metadata);

        let without_metadata = SplitOptions {
            preserve_metadata: false,
            ..Default::default()
        };
        assert!(!without_metadata.preserve_metadata);
    }

    #[test]
    fn test_split_single_pages_mode() {
        let options = SplitOptions {
            mode: SplitMode::SinglePages,
            output_pattern: "page_{:04}.pdf".to_string(),
            ..Default::default()
        };

        assert!(matches!(options.mode, SplitMode::SinglePages));
        assert!(options.output_pattern.contains("{"));
    }

    #[test]
    fn test_split_chunk_size_validation() {
        // Test various chunk sizes
        let chunk_sizes = vec![1, 5, 10, 50, 100];

        for size in chunk_sizes {
            let options = SplitOptions {
                mode: SplitMode::ChunkSize(size),
                ..Default::default()
            };

            if let SplitMode::ChunkSize(s) = options.mode {
                assert_eq!(s, size);
                assert!(s > 0); // Chunk size should be positive
            }
        }
    }

    #[test]
    fn test_split_options_optimization() {
        let optimized = SplitOptions {
            optimize: true,
            ..Default::default()
        };
        assert!(optimized.optimize);

        let not_optimized = SplitOptions {
            optimize: false,
            ..Default::default()
        };
        assert!(!not_optimized.optimize);
    }

    #[test]
    fn test_split_options_with_custom_pattern() {
        let options = SplitOptions {
            output_pattern: "document_part_{}.pdf".to_string(),
            ..Default::default()
        };
        assert_eq!(options.output_pattern, "document_part_{}.pdf");
    }

    #[test]
    fn test_split_mode_ranges() {
        let ranges = vec![
            PageRange::Single(0),
            PageRange::Range(1, 3),
            PageRange::Single(5),
        ];
        let mode = SplitMode::Ranges(ranges);

        match mode {
            SplitMode::Ranges(r) => {
                assert_eq!(r.len(), 3);
                assert!(matches!(r[0], PageRange::Single(0)));
                assert!(matches!(r[1], PageRange::Range(1, 3)));
                assert!(matches!(r[2], PageRange::Single(5)));
            }
            _ => panic!("Wrong mode"),
        }
    }

    #[test]
    fn test_split_mode_split_at() {
        let split_points = vec![5, 10, 15];
        let mode = SplitMode::SplitAt(split_points.clone());

        match mode {
            SplitMode::SplitAt(points) => assert_eq!(points, split_points),
            _ => panic!("Wrong mode"),
        }
    }

    #[test]
    fn test_page_range_parse() {
        // Test all pages
        let range = PageRange::parse("all").unwrap();
        assert!(matches!(range, PageRange::All));

        // Test single page
        let range = PageRange::parse("5").unwrap();
        assert!(matches!(range, PageRange::Single(4))); // 0-indexed

        // Test range
        let range = PageRange::parse("3-7").unwrap();
        assert!(matches!(range, PageRange::Range(2, 6))); // 0-indexed

        // Test list
        let range = PageRange::parse("1,3,5").unwrap();
        match range {
            PageRange::List(pages) => assert_eq!(pages, vec![0, 2, 4]),
            _ => panic!("Expected List"),
        }
    }

    #[test]
    fn test_page_range_invalid_parse() {
        assert!(PageRange::parse("").is_err());
        assert!(PageRange::parse("abc").is_err());
        assert!(PageRange::parse("5-3").is_err()); // Invalid range
        assert!(PageRange::parse("0").is_err()); // Page numbers start at 1
    }

    #[test]
    fn test_split_options_all_fields() {
        let options = SplitOptions {
            mode: SplitMode::ChunkSize(5),
            output_pattern: "chunk_{}.pdf".to_string(),
            preserve_metadata: false,
            optimize: true,
        };

        match options.mode {
            SplitMode::ChunkSize(size) => assert_eq!(size, 5),
            _ => panic!("Wrong mode"),
        }
        assert_eq!(options.output_pattern, "chunk_{}.pdf");
        assert!(!options.preserve_metadata);
        assert!(options.optimize);
    }

    #[test]
    fn test_split_mode_chunk_size_edge_cases() {
        // Chunk size of 1 should be like single pages
        let mode = SplitMode::ChunkSize(1);
        match mode {
            SplitMode::ChunkSize(size) => assert_eq!(size, 1),
            _ => panic!("Wrong mode"),
        }

        // Large chunk size
        let mode = SplitMode::ChunkSize(1000);
        match mode {
            SplitMode::ChunkSize(size) => assert_eq!(size, 1000),
            _ => panic!("Wrong mode"),
        }
    }

    #[test]
    fn test_split_mode_empty_ranges() {
        let ranges = Vec::new();
        let mode = SplitMode::Ranges(ranges);

        match mode {
            SplitMode::Ranges(r) => assert!(r.is_empty()),
            _ => panic!("Wrong mode"),
        }
    }

    #[test]
    fn test_split_mode_empty_split_points() {
        let split_points = Vec::new();
        let mode = SplitMode::SplitAt(split_points);

        match mode {
            SplitMode::SplitAt(points) => assert!(points.is_empty()),
            _ => panic!("Wrong mode"),
        }
    }
}

#[cfg(test)]
#[path = "split_tests.rs"]
mod split_tests;