s-zip 0.11.3

//! Example demonstrating optimized s-zip usage with performance improvements
//!
//! This example showcases the new optimization features in s-zip v0.9:
//! 1. Adaptive buffer sizing with size hints (15-25% faster)
//! 2. Concurrent S3 uploads (3-5x faster cloud operations)
//!
//! Run with:
//! ```bash
//! cargo run --example optimized_usage --features=async,cloud-s3
//! ```

use s_zip::{AsyncStreamingZipWriter, Result};
use tempfile::NamedTempFile;

#[tokio::main]
async fn main() -> Result<()> {
    println!("🚀 s-zip Optimization Examples\n");

    // Example 1: Adaptive Buffer Sizing with Size Hints
    example_adaptive_buffers().await?;

    // Example 2: Basic usage without hints (still optimized with defaults)
    example_no_hints().await?;

    #[cfg(feature = "cloud-s3")]
    {
        println!("\n💡 For S3 concurrent uploads example, see examples/cloud_s3.rs");
        println!("   Use .max_concurrent_uploads(8) for 3-5x faster uploads!");
    }

    Ok(())
}

/// Example 1: Adaptive Buffer Sizing - Optimal Performance
///
/// When you know the approximate file sizes, providing hints optimizes memory allocation
/// and flush thresholds for 15-25% performance improvement on large files.
async fn example_adaptive_buffers() -> Result<()> {
    println!("📊 Example 1: Adaptive Buffer Sizing with Size Hints");
    println!("   ✅ Optimizes memory allocation based on file sizes");
    println!("   ✅ 15-25% faster for large files (>1MB)\n");

    let temp = NamedTempFile::new()?;
    let mut writer = AsyncStreamingZipWriter::new(temp.path()).await?;

    // Scenario 1: Small file - optimized for low memory
    let small_data = b"This is a small file";
    writer
        .start_entry_with_hint("small.txt", Some(small_data.len() as u64))
        .await?;
    writer.write_data(small_data).await?;
    println!("   ✓ Small file (20 bytes): 8KB buffer, 256KB threshold");

    // Scenario 2: Medium file - balanced settings
    let medium_data = vec![b'M'; 500_000]; // 500KB
    writer
        .start_entry_with_hint("medium.bin", Some(medium_data.len() as u64))
        .await?;
    writer.write_data(&medium_data).await?;
    println!("   ✓ Medium file (500KB): 128KB buffer, 2MB threshold");

    // Scenario 3: Large file - aggressive buffering
    let large_data = vec![b'L'; 5_000_000]; // 5MB
    writer
        .start_entry_with_hint("large.bin", Some(large_data.len() as u64))
        .await?;
    writer.write_data(&large_data).await?;
    println!("   ✓ Large file (5MB): 256KB buffer, 4MB threshold");

    // Scenario 4: Very large file - maximum optimization
    let huge_data = vec![b'H'; 50_000_000]; // 50MB
    writer
        .start_entry_with_hint("huge.bin", Some(huge_data.len() as u64))
        .await?;
    writer.write_data(&huge_data).await?;
    println!("   ✓ Very large file (50MB): 512KB buffer, 8MB threshold");

    writer.finish().await?;

    println!("\n   📈 Performance Impact:");
    println!("      • Small files: Minimal overhead, optimal memory usage");
    println!("      • Large files: +15-25% throughput improvement");
    println!("      • Memory usage: Still constant 2-5MB regardless of size!\n");

    Ok(())
}

/// Example 2: No Size Hints - Still Optimized
///
/// Even without hints, s-zip uses smart defaults for good performance.
async fn example_no_hints() -> Result<()> {
    println!("📄 Example 2: Usage without Size Hints (Backward Compatible)");
    println!("   ✅ Uses smart defaults (512KB buffer, 8MB threshold)");
    println!("   ✅ Zero breaking changes - existing code still works!\n");

    let temp = NamedTempFile::new()?;
    let mut writer = AsyncStreamingZipWriter::new(temp.path()).await?;

    // Standard usage - no hints provided
    writer.start_entry("file1.txt").await?;
    writer.write_data(b"Hello, World!").await?;

    writer.start_entry("file2.txt").await?;
    writer.write_data(b"More data here...").await?;

    writer.finish().await?;

    println!("   ✓ Created ZIP with 2 files");
    println!("   ℹ️  Add .start_entry_with_hint() for optimal performance\n");

    Ok(())
}

/// Example 3: S3 Concurrent Uploads (requires cloud-s3 feature)
///
/// Note: This example is simplified. For a complete S3 example, see examples/cloud_s3.rs
#[cfg(feature = "cloud-s3")]
#[allow(dead_code)]
async fn example_s3_concurrent() -> Result<()> {
    println!("☁️  Example 3: S3 Concurrent Multipart Upload");
    println!("   ✅ Upload 4-8 parts in parallel (configurable)");
    println!("   ✅ 3-5x faster than sequential uploads");
    println!("   ✅ Automatic retry with exponential backoff\n");

    // Note: Requires AWS credentials configured
    println!("   Configuration example:");
    println!("   ```rust");
    println!("   let writer = S3ZipWriter::builder()");
    println!("       .bucket(\"my-bucket\")");
    println!("       .key(\"large-archive.zip\")");
    println!("       .max_concurrent_uploads(8)  // 8 parallel uploads!");
    println!("       .part_size(10 * 1024 * 1024) // 10MB parts");
    println!("       .build()");
    println!("       .await?;");
    println!("   ```\n");

    println!("   📈 Performance Impact:");
    println!("      • Default (4 concurrent): ~3x faster");
    println!("      • Aggressive (8 concurrent): ~5x faster");
    println!("      • Automatic retry on transient failures");
    println!("      • Exponential backoff (100ms → 200ms → 400ms)\n");

    Ok(())
}

/// Example 4: Real-world Performance Comparison
#[allow(dead_code)]
async fn example_performance_comparison() -> Result<()> {
    use std::time::Instant;

    println!("⚡ Performance Comparison\n");

    // Generate test data (10MB)
    let data = vec![b'X'; 10_000_000];

    // WITHOUT size hint
    let temp1 = NamedTempFile::new()?;
    let start = Instant::now();
    let mut writer1 = AsyncStreamingZipWriter::new(temp1.path()).await?;
    writer1.start_entry("data.bin").await?;
    writer1.write_data(&data).await?;
    writer1.finish().await?;
    let time_no_hint = start.elapsed();

    // WITH size hint
    let temp2 = NamedTempFile::new()?;
    let start = Instant::now();
    let mut writer2 = AsyncStreamingZipWriter::new(temp2.path()).await?;
    writer2
        .start_entry_with_hint("data.bin", Some(data.len() as u64))
        .await?;
    writer2.write_data(&data).await?;
    writer2.finish().await?;
    let time_with_hint = start.elapsed();

    println!("   Results (10MB file):");
    println!("   • Without hint: {:?}", time_no_hint);
    println!("   • With hint:    {:?}", time_with_hint);
    println!(
        "   • Improvement:  {:.1}%\n",
        ((time_no_hint.as_secs_f64() - time_with_hint.as_secs_f64()) / time_no_hint.as_secs_f64()
            * 100.0)
    );

    Ok(())
}

/// Example 5: Memory Usage Demonstration
#[allow(dead_code)]
fn example_memory_usage() {
    println!("💾 Memory Usage (Constant Regardless of File Size)\n");

    println!("   Configuration          | Initial Cap | Flush Threshold | Total RAM");
    println!("   -----------------------|-------------|-----------------|----------");
    println!("   Tiny (<10KB)          | 8KB         | 256KB           | ~2MB");
    println!("   Small (<100KB)        | 32KB        | 512KB           | ~3MB");
    println!("   Medium (<1MB)         | 128KB       | 2MB             | ~4MB");
    println!("   Large (1-10MB)        | 256KB       | 4MB             | ~5MB");
    println!("   Very Large (>10MB)    | 512KB       | 8MB             | ~6MB");
    println!("\n   ✅ Memory usage remains constant - perfect for containers!");
    println!("   ✅ Larger files just flush more frequently\n");
}