printwell-sys 0.1.3

//! Unit tests for printwell-sys FFI types

use super::*;

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

    #[test]
    fn test_default_pdf_options() {
        let opts = PdfOptions::default();

        // A4 dimensions
        assert!((opts.page_width_mm - 210.0).abs() < 0.001);
        assert!((opts.page_height_mm - 297.0).abs() < 0.001);

        // Default margins
        assert!((opts.margin_top_mm - 10.0).abs() < 0.001);
        assert!((opts.margin_right_mm - 10.0).abs() < 0.001);
        assert!((opts.margin_bottom_mm - 10.0).abs() < 0.001);
        assert!((opts.margin_left_mm - 10.0).abs() < 0.001);

        // Default flags
        assert!(opts.print_background);
        assert!(!opts.landscape);
        assert!((opts.scale - 1.0).abs() < 0.001);
        assert!(!opts.prefer_css_page_size);

        // Empty strings
        assert!(opts.header_template.is_empty());
        assert!(opts.footer_template.is_empty());
        assert!(opts.page_ranges.is_empty());
    }

    #[test]
    fn test_pdf_options_custom() {
        let opts = PdfOptions {
            page_width_mm: 215.9, // Letter
            page_height_mm: 279.4,
            margin_top_mm: 25.4,
            margin_right_mm: 25.4,
            margin_bottom_mm: 25.4,
            margin_left_mm: 25.4,
            print_background: false,
            landscape: true,
            scale: 0.8,
            prefer_css_page_size: true,
            header_template: "<div>Header</div>".to_string(),
            footer_template: "<div>Page {{pageNumber}}</div>".to_string(),
            page_ranges: "1-5,8".to_string(),
            metadata: PdfMetadata::default(),
        };

        assert!((opts.page_width_mm - 215.9).abs() < 0.001);
        assert!(opts.landscape);
        assert!(!opts.print_background);
        assert_eq!(opts.page_ranges, "1-5,8");
    }

    #[test]
    fn test_pdf_metadata_default() {
        let metadata = PdfMetadata::default();

        assert!(metadata.title.is_empty());
        assert!(metadata.author.is_empty());
        assert!(metadata.subject.is_empty());
        assert!(metadata.keywords.is_empty());
        assert_eq!(metadata.creator, "printwell");
        assert_eq!(metadata.producer, "printwell");
    }

    #[test]
    fn test_pdf_metadata_custom() {
        let metadata = PdfMetadata {
            title: "My Document".to_string(),
            author: "John Doe".to_string(),
            subject: "Test Subject".to_string(),
            keywords: "test, pdf, document".to_string(),
            creator: "My App".to_string(),
            producer: "My Producer".to_string(),
        };

        assert_eq!(metadata.title, "My Document");
        assert_eq!(metadata.author, "John Doe");
        assert_eq!(metadata.creator, "My App");
    }

    #[test]
    fn test_pdf_options_clone() {
        let opts = PdfOptions::default();
        let cloned = opts.clone();

        assert_eq!(opts.page_width_mm, cloned.page_width_mm);
        assert_eq!(opts.page_height_mm, cloned.page_height_mm);
        assert_eq!(opts.print_background, cloned.print_background);
    }

    #[test]
    fn test_pdf_options_debug() {
        let opts = PdfOptions::default();
        let debug_str = format!("{opts:?}");

        assert!(debug_str.contains("PdfOptions"));
        assert!(debug_str.contains("page_width_mm"));
    }
}

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

    #[test]
    fn test_default_render_options() {
        let opts = RenderOptions::default();

        assert!(opts.base_url.is_empty());
        assert!(opts.javascript_enabled);
        assert_eq!(opts.script_timeout_ms, 30000);
        assert!(opts.user_stylesheets.is_empty());
        assert!(opts.user_scripts.is_empty());
        assert_eq!(opts.viewport_width, 1280);
        assert_eq!(opts.viewport_height, 720);
        assert!((opts.device_scale_factor - 1.0).abs() < 0.001);
    }

    #[test]
    fn test_render_options_with_stylesheets() {
        let opts = RenderOptions {
            user_stylesheets: vec![
                "body { margin: 0; }".to_string(),
                ".header { color: red; }".to_string(),
            ],
            ..Default::default()
        };

        assert_eq!(opts.user_stylesheets.len(), 2);
        assert!(opts.user_stylesheets[0].contains("margin"));
    }

    #[test]
    fn test_render_options_with_scripts() {
        let opts = RenderOptions {
            user_scripts: vec!["console.log('Hello');".to_string()],
            javascript_enabled: true,
            ..Default::default()
        };

        assert_eq!(opts.user_scripts.len(), 1);
        assert!(opts.javascript_enabled);
    }
}

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

    #[test]
    fn test_boundary_creation() {
        let boundary = Boundary {
            selector: "#header".to_string(),
            index: 0,
            page: 1,
            x: 10.0,
            y: 20.0,
            width: 100.0,
            height: 50.0,
        };

        assert_eq!(boundary.selector, "#header");
        assert_eq!(boundary.index, 0);
        assert_eq!(boundary.page, 1);
        assert!((boundary.x - 10.0).abs() < 0.001);
    }

    #[test]
    fn test_boundary_clone() {
        let boundary = Boundary {
            selector: ".test".to_string(),
            index: 5,
            page: 2,
            x: 50.0,
            y: 100.0,
            width: 200.0,
            height: 30.0,
        };

        let cloned = boundary.clone();
        assert_eq!(boundary.selector, cloned.selector);
        assert_eq!(boundary.page, cloned.page);
    }
}

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

    #[test]
    fn test_default_text_field() {
        let field = TextFieldDef::default();

        assert!(field.name.is_empty());
        assert_eq!(field.page, 1);
        assert!((field.x - 0.0).abs() < 0.001);
        assert!((field.width - 100.0).abs() < 0.001);
        assert!((field.height - 20.0).abs() < 0.001);
        assert!(!field.multiline);
        assert!(!field.password);
        assert!(!field.required);
        assert!(!field.read_only);
        assert!((field.font_size - 12.0).abs() < 0.001);
        assert_eq!(field.font_name, "Helvetica");
    }

    #[test]
    fn test_text_field_password() {
        let field = TextFieldDef {
            name: "password_field".to_string(),
            password: true,
            ..Default::default()
        };

        assert!(field.password);
        assert_eq!(field.name, "password_field");
    }

    #[test]
    fn test_text_field_multiline() {
        let field = TextFieldDef {
            name: "comments".to_string(),
            multiline: true,
            height: 100.0,
            ..Default::default()
        };

        assert!(field.multiline);
        assert!((field.height - 100.0).abs() < 0.001);
    }
}

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

    #[test]
    fn test_default_checkbox() {
        let checkbox = CheckboxDef::default();

        assert!(checkbox.name.is_empty());
        assert_eq!(checkbox.page, 1);
        assert!((checkbox.size - 12.0).abs() < 0.001);
        assert!(!checkbox.checked);
        assert_eq!(checkbox.export_value, "Yes");
    }

    #[test]
    fn test_checkbox_checked() {
        let checkbox = CheckboxDef {
            name: "agree_terms".to_string(),
            checked: true,
            export_value: "Agreed".to_string(),
            ..Default::default()
        };

        assert!(checkbox.checked);
        assert_eq!(checkbox.export_value, "Agreed");
    }
}

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

    #[test]
    fn test_default_dropdown() {
        let dropdown = DropdownDef::default();

        assert!(dropdown.name.is_empty());
        assert!(dropdown.options.is_empty());
        assert_eq!(dropdown.selected_index, -1);
        assert!(!dropdown.editable);
    }

    #[test]
    fn test_dropdown_with_options() {
        let dropdown = DropdownDef {
            name: "country".to_string(),
            options: vec![
                "USA".to_string(),
                "Canada".to_string(),
                "Mexico".to_string(),
            ],
            selected_index: 0,
            ..Default::default()
        };

        assert_eq!(dropdown.options.len(), 3);
        assert_eq!(dropdown.selected_index, 0);
    }

    #[test]
    fn test_dropdown_editable() {
        let dropdown = DropdownDef {
            editable: true,
            ..Default::default()
        };

        assert!(dropdown.editable);
    }
}

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

    #[test]
    fn test_default_signature_field() {
        let field = SignatureFieldDef::default();

        assert!(field.name.is_empty());
        assert_eq!(field.page, 1);
        assert!((field.width - 150.0).abs() < 0.001);
        assert!((field.height - 50.0).abs() < 0.001);
    }
}

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

    #[test]
    fn test_default_signing_options() {
        let opts = SigningOptions::default();

        assert!(opts.reason.is_empty());
        assert!(opts.location.is_empty());
        assert!(opts.contact_info.is_empty());
        assert_eq!(opts.signature_level, "B");
        assert!(opts.timestamp_url.is_empty());
    }

    #[test]
    fn test_signing_options_with_values() {
        let opts = SigningOptions {
            reason: "Contract approval".to_string(),
            location: "New York, NY".to_string(),
            contact_info: "john@example.com".to_string(),
            signature_level: "LTA".to_string(),
            timestamp_url: "https://timestamp.example.com".to_string(),
        };

        assert_eq!(opts.reason, "Contract approval");
        assert_eq!(opts.signature_level, "LTA");
    }
}

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

    #[test]
    fn test_default_visible_signature() {
        let sig = VisibleSignature::default();

        assert_eq!(sig.field_name, "Signature");
        assert_eq!(sig.page, 1);
        assert!((sig.width - 150.0).abs() < 0.001);
        assert!((sig.height - 50.0).abs() < 0.001);
        assert!(sig.show_name);
        assert!(sig.show_date);
        assert!(sig.show_reason);
        assert!(sig.background_image.is_empty());
    }

    #[test]
    fn test_visible_signature_with_image() {
        let image_data = vec![0x89, 0x50, 0x4E, 0x47]; // PNG header
        let sig = VisibleSignature {
            background_image: image_data,
            ..Default::default()
        };

        assert_eq!(sig.background_image.len(), 4);
        assert_eq!(sig.background_image[0], 0x89);
    }
}

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

    #[test]
    fn test_signature_info_valid() {
        let info = SignatureInfo {
            signer_name: "John Doe".to_string(),
            signing_time: "2024-01-15T10:30:00Z".to_string(),
            reason: "Approval".to_string(),
            location: "Office".to_string(),
            is_valid: true,
            covers_whole_document: true,
        };

        assert!(info.is_valid);
        assert!(info.covers_whole_document);
        assert_eq!(info.signer_name, "John Doe");
    }

    #[test]
    fn test_signature_info_invalid() {
        let info = SignatureInfo {
            signer_name: "Unknown".to_string(),
            signing_time: String::new(),
            reason: String::new(),
            location: String::new(),
            is_valid: false,
            covers_whole_document: false,
        };

        assert!(!info.is_valid);
        assert!(!info.covers_whole_document);
    }
}