use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // FileOptions configures how files are stored in the archive
    let options = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(6);
    
    // compression_method: WHICH algorithm to use
    // compression_level: HOW INTENSELY to use it
    
    println!("Default options configured");
}

use zip::write::FileOptions;
use zip::CompressionMethod;
use std::io::Write;
use std::io::Cursor;
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let data = b"Hello, World! This is some test data that will be compressed. "
               b"Repeating data compresses well. Repeating data compresses well.";
    
    // Different compression methods available:
    
    // Stored - No compression, fastest
    let stored = FileOptions::default()
        .compression_method(CompressionMethod::Stored);
    
    // Deflated - Standard ZIP compression (zlib)
    let deflated = FileOptions::default()
        .compression_method(CompressionMethod::Deflated);
    
    // Bzip2 - Better compression, slower
    let bzip2 = FileOptions::default()
        .compression_method(CompressionMethod::Bzip2);
    
    // Zstd - Modern compression, good balance
    let zstd = FileOptions::default()
        .compression_method(CompressionMethod::Zstd);
    
    // Xz - LZMA2 compression, high ratio
    let xz = FileOptions::default()
        .compression_method(CompressionMethod::Xz);
    
    // Each method has different characteristics:
    // - Speed: Stored > Deflated > Zstd > Bzip2 > Xz
    // - Ratio: Stored < Deflated < Zstd < Bzip2 < Xz (varies by data)
    
    println!("Compression methods configured");
    Ok(())
}

use zip::write::FileOptions;
use zip::CompressionMethod;
use std::io::Cursor;
use std::io::Write;
 
fn create_archive_with_level(level: Option<i64>) -> Vec<u8> {
    let mut buffer = Cursor::new(Vec::new());
    let mut archive = zip::ZipWriter::new(&mut buffer);
    
    let data = b"Hello, World! This is some test data that will be compressed. "
               b"Repeating data compresses well. Repeating data compresses well.";
    
    let mut options = FileOptions::default()
        .compression_method(CompressionMethod::Deflated);
    
    if let Some(l) = level {
        options = options.compression_level(l);
    }
    
    archive.start_file("test.txt", options).unwrap();
    archive.write_all(data).unwrap();
    archive.finish().unwrap();
    
    buffer.into_inner()
}
 
fn main() {
    // Compression levels typically range from 1 to 9
    // Level 1: Fastest compression, larger output
    // Level 9: Slowest compression, smaller output
    
    // Level 1 - Fast
    let fast = create_archive_with_level(Some(1));
    println!("Level 1: {} bytes", fast.len());
    
    // Level 6 - Default/balanced
    let balanced = create_archive_with_level(Some(6));
    println!("Level 6: {} bytes", balanced.len());
    
    // Level 9 - Best compression
    let best = create_archive_with_level(Some(9));
    println!("Level 9: {} bytes", best.len());
    
    // None uses algorithm's default
    let default = create_archive_with_level(None);
    println!("Default: {} bytes", default.len());
}

use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // CRITICAL: Compression level meanings are ALGORITHM-SPECIFIC
    
    // Deflate levels: typically 1-9
    // Level 1: fastest, least compression
    // Level 9: slowest, most compression
    let deflate_fast = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(1);
    
    let deflate_best = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(9);
    
    // Zstd levels: typically 1-21
    // Level 1: fastest
    // Level 21: slowest, best compression
    let zstd_fast = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(1);
    
    let zstd_best = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(21);
    
    // Bzip2 levels: typically 1-9
    let bzip2_fast = FileOptions::default()
        .compression_method(CompressionMethod::Bzip2)
        .compression_level(1);
    
    let bzip2_best = FileOptions::default()
        .compression_method(CompressionMethod::Bzip2)
        .compression_level(9);
    
    // Stored: compression_level is IGNORED (no compression)
    let stored = FileOptions::default()
        .compression_method(CompressionMethod::Stored)
        .compression_level(9);  // This has NO effect
    
    println!("Algorithm-specific levels configured");
    
    // IMPORTANT: Level 6 for Deflate != Level 6 for Zstd
    // They use completely different internal settings
}

use zip::write::FileOptions;
use zip::CompressionMethod;
use std::io::Cursor;
use std::io::Write;
use std::time::Instant;
 
fn benchmark_compression(method: CompressionMethod, level: Option<i64>, data: &[u8]) -> (Vec<u8>, std::time::Duration) {
    let start = Instant::now();
    
    let mut buffer = Cursor::new(Vec::new());
    let mut archive = zip::ZipWriter::new(&mut buffer);
    
    let mut options = FileOptions::default()
        .compression_method(method);
    
    if let Some(l) = level {
        options = options.compression_level(l);
    }
    
    archive.start_file("data.bin", options).unwrap();
    archive.write_all(data).unwrap();
    archive.finish().unwrap();
    
    let duration = start.elapsed();
    (buffer.into_inner(), duration)
}
 
fn main() {
    // Create test data - mix of patterns
    let mut data = Vec::new();
    for i in 0..10000 {
        data.extend_from_slice(b"Pattern repetition helps compression. ");
    }
    data.extend_from_slice(&[0u8; 1000]); // Zeros compress very well
    
    println!("Original: {} bytes", data.len());
    println!();
    
    // Compare methods at default level
    let methods = [
        (CompressionMethod::Stored, "Stored"),
        (CompressionMethod::Deflated, "Deflated"),
        (CompressionMethod::Bzip2, "Bzip2"),
        (CompressionMethod::Zstd, "Zstd"),
    ];
    
    for (method, name) in methods {
        let (compressed, duration) = benchmark_compression(method, None, &data);
        println!(
            "{:10}: {:8} bytes, {:6.?}, ratio: {:.1}%",
            name,
            compressed.len(),
            duration,
            (compressed.len() as f64 / data.len() as f64) * 100.0
        );
    }
    
    println!();
    
    // Compare levels for Deflate
    println!("Deflate levels:");
    for level in [1, 6, 9] {
        let (compressed, duration) = benchmark_compression(
            CompressionMethod::Deflated,
            Some(level),
            &data
        );
        println!(
            "  Level {}: {:8} bytes, {:6.?}, ratio: {:.1}%",
            level,
            compressed.len(),
            duration,
            (compressed.len() as f64 / data.len() as f64) * 100.0
        );
    }
}

use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // Method choice has BIGGER impact than level choice
    
    // Example: Level 1 Zstd vs Level 9 Deflate
    // Zstd at level 1 might beat Deflate at level 9 for:
    // - Compression ratio
    // - Decompression speed
    // - Even compression speed!
    
    // This happens because modern algorithms (Zstd) are
    // fundamentally more efficient than older ones (Deflate)
    
    // When to choose METHOD carefully:
    
    // 1. Compatibility requirements
    let for_old_unzippers = FileOptions::default()
        .compression_method(CompressionMethod::Deflated);  // Universal support
    
    // 2. Maximum compatibility
    let for_ancient_unzippers = FileOptions::default()
        .compression_method(CompressionMethod::Stored);  // No compression needed
    
    // 3. Maximum compression
    let for_best_ratio = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)  // Or Xz
        .compression_level(21);  // Zstd's max
    
    // 4. Fastest compression
    let for_speed = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(1);
    
    // 5. Balanced modern
    let for_balanced = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(3);  // Zstd level 3 is fast and effective
    
    println!("Method-focused configurations");
}

use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // Level matters more when:
    // 1. Method is fixed (compatibility requirement)
    // 2. You need to tune for specific hardware/workload
    // 3. Interactive vs batch processing
    
    // Interactive: prefer fast compression
    let interactive = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(1);  // Fast response
    
    // Background/batch: prefer good compression
    let batch = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(9);  // Best ratio, slower
    
    // Storage-constrained: maximize compression
    let storage_constrained = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(21);  // Maximum compression
    
    // CPU-constrained: minimize compression work
    let cpu_constrained = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(1);  // Minimal CPU
    
    // Network bandwidth constrained: compress more
    let network_optimized = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(19);  // High compression
    
    println!("Level-focused configurations");
}

use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // Each compression method has its own level semantics
    
    // Stored (no compression)
    // - Range: N/A (level ignored)
    // - Always copies data as-is
    // - Use for already-compressed files (images, videos)
    
    // Deflate (standard ZIP compression)
    // - Range: 1-9
    // - Default: 6
    // - 1: Fastest, least compression
    // - 9: Slowest, best compression
    // - Widely compatible
    
    // Bzip2
    // - Range: 1-9
    // - Default: 6
    // - Better compression than Deflate
    // - Slower compression and decompression
    
    // Zstd
    // - Range: 1-21 (varies by implementation)
    // - Default: typically 3
    // - Low levels: very fast, good ratio
    // - High levels: slower, excellent ratio
    // - Decompression speed is fast at all levels
    
    // Xz (LZMA2)
    // - Range: varies
    // - Excellent compression ratio
    // - Slow compression and decompression
    
    // Example: Safe defaults for each method
    let deflate_default = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(6);  // Default, safe choice
    
    let zstd_default = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(3);  // Zstd's sweet spot
    
    let bzip2_default = FileOptions::default()
        .compression_method(CompressionMethod::Bzip2)
        .compression_level(6);  // Balanced
    
    println!("Method-specific level ranges configured");
}

use zip::write::FileOptions;
use zip::CompressionMethod;
use std::path::Path;
 
fn get_compression_options(path: &Path, content_type: ContentType) -> FileOptions {
    // Strategy: choose method and level based on content and context
    
    match content_type {
        // Already compressed: don't re-compress
        ContentType::Image | ContentType::Video | ContentType::Audio => {
            FileOptions::default()
                .compression_method(CompressionMethod::Stored)
            // Level doesn't matter for Stored
        }
        
        // Text files: compress well, need balance
        ContentType::Text => {
            FileOptions::default()
                .compression_method(CompressionMethod::Zstd)
                .compression_level(10)  // Good compression for text
        }
        
        // Source code: lots of repetition
        ContentType::SourceCode => {
            FileOptions::default()
                .compression_method(CompressionMethod::Zstd)
                .compression_level(15)  // Higher for repetitive content
        }
        
        // Binary data: varies widely
        ContentType::Binary => {
            FileOptions::default()
                .compression_method(CompressionMethod::Deflated)
                .compression_level(6)  // Safe default
        }
        
        // Large files: worth spending CPU on compression
        ContentType::LargeFile => {
            FileOptions::default()
                .compression_method(CompressionMethod::Zstd)
                .compression_level(19)  // High compression
        }
        
        // Small files: compression overhead may not be worth it
        ContentType::SmallFile => {
            FileOptions::default()
                .compression_method(CompressionMethod::Deflated)
                .compression_level(1)  // Fast, overhead acceptable
        }
        
        // Maximum compatibility required
        ContentType::CompatibilityCritical => {
            FileOptions::default()
                .compression_method(CompressionMethod::Deflated)
                .compression_level(6)  // Universal support
        }
    }
}
 
enum ContentType {
    Image,
    Video,
    Audio,
    Text,
    SourceCode,
    Binary,
    LargeFile,
    SmallFile,
    CompatibilityCritical,
}
 
fn main() {
    let options = get_compression_options(
        std::path::Path::new("document.txt"),
        ContentType::Text
    );
    println!("Configured for text files");
}

use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // IMPORTANT: Compression level affects COMPRESSION speed
    // But DECOMPRESSION speed varies differently!
    
    // Deflate: Decompression speed relatively constant across levels
    // - Level 1 compressed data: similar decompression time to level 9
    // - Small difference due to slightly more data to read at level 1
    
    // Zstd: Decompression speed fairly consistent across levels
    // - Decompression is fast at any compression level
    // - This is a key Zstd advantage
    
    // Bzip2: Decompression speed varies with level
    // - Higher levels can be slower to decompress
    // - More noticeable than with Deflate
    
    // When optimizing for read-heavy archives:
    let read_heavy = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(19);  // High compression OK, decompress is fast
    
    // When optimizing for write-heavy:
    let write_heavy = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(1);  // Fast compression, still good ratio
    
    // When optimizing for both:
    let balanced = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(3);  // Fast compress, fast decompress
    
    println!("Decompression considerations configured");
}

use zip::write::FileOptions;
use zip::CompressionMethod;
use zip::ZipWriter;
use std::io::Cursor;
use std::io::Write;
 
fn create_archive_with_options() -> Result<Vec<u8>, Box<dyn std::error::Error>> {
    let mut buffer = Cursor::new(Vec::new());
    let mut archive = ZipWriter::new(&mut buffer);
    
    // Different files might need different compression
    let text_options = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(10);
    
    let binary_options = FileOptions::default()
        .compression_method(CompressionMethod::Deflated)
        .compression_level(6);
    
    let no_compress_options = FileOptions::default()
        .compression_method(CompressionMethod::Stored);
    
    // Add text file - compress well
    archive.start_file("readme.txt", text_options)?;
    archive.write_all(b"This is a readme file with lots of text content...")?;
    
    // Add binary file - moderate compression
    archive.start_file("data.bin", binary_options)?;
    archive.write_all(&[0u8; 1000])?;
    
    // Add image - already compressed, store only
    archive.start_file("image.jpg", no_compress_options)?;
    archive.write_all(b"fake image data that is already compressed")?;
    
    archive.finish()?;
    
    Ok(buffer.into_inner())
}
 
fn main() -> Result<(), Box<dyn std::error::Error>> {
    let archive = create_archive_with_options()?;
    println!("Archive created: {} bytes", archive.len());
    
    // You can use different compression per file in the same archive
    // This is a key advantage of ZIP format
    
    Ok(())
}

use zip::write::FileOptions;
use zip::CompressionMethod;
 
fn main() {
    // If you don't specify compression_method:
    let default_method = FileOptions::default();
    // Uses CompressionMethod::Deflated (typically)
    
    // If you don't specify compression_level:
    let default_level = FileOptions::default()
        .compression_method(CompressionMethod::Deflated);
    // Uses the method's default level (typically 6 for Deflate)
    
    // Specifying just method uses its default level:
    let method_only = FileOptions::default()
        .compression_method(CompressionMethod::Zstd);
    // Uses Zstd's default level
    
    // Specifying just level with default method:
    let level_only = FileOptions::default()
        .compression_level(9);
    // Uses default method (Deflated) at level 9
    
    // Explicit is better than implicit:
    let explicit = FileOptions::default()
        .compression_method(CompressionMethod::Zstd)
        .compression_level(3);
    // Clear intent, predictable behavior
    
    println!("Default behaviors documented");
}