trimdown 0.1.6

use std::path::PathBuf;
use trimdown::{compress_video, compress_pdf, compress_powerpoint, compress_word, concat_videos};
use trimdown::{Cli, PdfQuality, PdfMethod};
use tempfile::TempDir;

/// Test video compression with different quality settings
#[tokio::test]
async fn test_example_video_compression_high_quality() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("video_hq.mp4");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/videos/sample.mp4")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 18,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_video(
        &PathBuf::from("tests/fixtures/videos/sample.mp4"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "High quality video compression should succeed");
    assert!(output.exists(), "Output file should exist");
    
    let metadata = std::fs::metadata(&output).unwrap();
    assert!(metadata.len() > 0, "Output file should not be empty");
}

#[tokio::test]
async fn test_example_video_compression_balanced() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("video_balanced.mp4");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/videos/sample.mp4")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_video(
        &PathBuf::from("tests/fixtures/videos/sample.mp4"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "Balanced video compression should succeed");
    assert!(output.exists(), "Output file should exist");
}

#[tokio::test]
async fn test_example_video_compression_720p() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("video_720p.mp4");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/videos/sample.mp4")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 28,
        video_max_width: 720,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_video(
        &PathBuf::from("tests/fixtures/videos/sample.mp4"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "720p video compression should succeed");
    assert!(output.exists(), "Output file should exist");
}

/// Test video concatenation with fast mode
#[tokio::test]
async fn test_example_video_concat_fast() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("concat_fast.mp4");

    let cli = Cli {
        command: None,
        input: None,
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let input1 = PathBuf::from("tests/fixtures/videos/sample.mp4");
    let input2 = PathBuf::from("tests/fixtures/videos/sample2.mp4");
    let inputs = vec![input1.as_path(), input2.as_path()];

    let result = concat_videos(&inputs, &output, &cli, false).await;

    assert!(result.is_ok(), "Fast video concatenation should succeed");
    assert!(output.exists(), "Concatenated output should exist");
    
    let metadata = std::fs::metadata(&output).unwrap();
    assert!(metadata.len() > 0, "Concatenated file should not be empty");
}

/// Test video concatenation with re-encode mode
#[tokio::test]
async fn test_example_video_concat_reencode() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("concat_reencode.mp4");

    let cli = Cli {
        command: None,
        input: None,
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let input1 = PathBuf::from("tests/fixtures/videos/sample.mp4");
    let input2 = PathBuf::from("tests/fixtures/videos/sample2.mp4");
    let inputs = vec![input1.as_path(), input2.as_path()];

    let result = concat_videos(&inputs, &output, &cli, true).await;

    assert!(result.is_ok(), "Re-encode video concatenation should succeed");
    assert!(output.exists(), "Concatenated output should exist");
}

/// Test PDF compression with different quality levels
#[tokio::test]
async fn test_example_pdf_compression_screen() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("pdf_screen.pdf");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/pdfs/sample.pdf")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Screen,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_pdf(
        &PathBuf::from("tests/fixtures/pdfs/sample.pdf"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "Screen quality PDF compression should succeed");
    assert!(output.exists(), "Output PDF should exist");
}

#[tokio::test]
async fn test_example_pdf_compression_ebook() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("pdf_ebook.pdf");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/pdfs/sample.pdf")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_pdf(
        &PathBuf::from("tests/fixtures/pdfs/sample.pdf"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "Ebook quality PDF compression should succeed");
    assert!(output.exists(), "Output PDF should exist");
}

/// Test PowerPoint compression
#[tokio::test]
async fn test_example_powerpoint_compression() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("presentation.pptx");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/office/sample.pptx")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_powerpoint(
        &PathBuf::from("tests/fixtures/office/sample.pptx"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "PowerPoint compression should succeed");
    assert!(output.exists(), "Output PPTX should exist");
}

/// Test Word document compression
#[tokio::test]
async fn test_example_word_compression() {
    let temp_dir = TempDir::new().unwrap();
    let output = temp_dir.path().join("document.docx");

    let cli = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/office/sample.docx")),
        output: Some(output.clone()),
        folder: false,
        quality: 85,
        max_width: 1920,
        video_crf: 23,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result = compress_word(
        &PathBuf::from("tests/fixtures/office/sample.docx"),
        &output,
        &cli
    ).await;

    assert!(result.is_ok(), "Word compression should succeed");
    assert!(output.exists(), "Output DOCX should exist");
}

/// Test compression quality comparison
#[tokio::test]
async fn test_example_quality_comparison() {
    let temp_dir = TempDir::new().unwrap();
    
    // High quality
    let output_hq = temp_dir.path().join("video_hq.mp4");
    let cli_hq = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/videos/sample.mp4")),
        output: Some(output_hq.clone()),
        folder: false,
        quality: 95,
        max_width: 1920,
        video_crf: 18,
        video_max_width: 1920,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    // Low quality
    let output_lq = temp_dir.path().join("video_lq.mp4");
    let cli_lq = Cli {
        command: None,
        input: Some(PathBuf::from("tests/fixtures/videos/sample.mp4")),
        output: Some(output_lq.clone()),
        folder: false,
        quality: 70,
        max_width: 1920,
        video_crf: 28,
        video_max_width: 720,
        pdf_quality: PdfQuality::Ebook,
        pdf_method: PdfMethod::Auto,
        force: true,
        verbose: false,
        dry_run: false,
        preset: None,
        parallel: false,
    preserve_metadata: false,
    streaming: false,
    memory_limit: None,
    };

    let result_hq = compress_video(
        &PathBuf::from("tests/fixtures/videos/sample.mp4"),
        &output_hq,
        &cli_hq
    ).await;

    let result_lq = compress_video(
        &PathBuf::from("tests/fixtures/videos/sample.mp4"),
        &output_lq,
        &cli_lq
    ).await;

    assert!(result_hq.is_ok(), "High quality compression should succeed");
    assert!(result_lq.is_ok(), "Low quality compression should succeed");
    
    // Both files should exist
    assert!(output_hq.exists());
    assert!(output_lq.exists());
    
    // High quality should generally be larger (though not guaranteed with small test files)
    let size_hq = std::fs::metadata(&output_hq).unwrap().len();
    let size_lq = std::fs::metadata(&output_lq).unwrap().len();
    
    assert!(size_hq > 0, "High quality file should not be empty");
    assert!(size_lq > 0, "Low quality file should not be empty");
}