lcpfs 2026.1.102

//! Compression tier demonstration
//!
//! This example demonstrates:
//! - LZ4 compression (universal, no_std)
//! - ZSTD compression (std feature)
//! - LZMA compression (std feature)
//! - Automatic compression algorithm selection
//! - Compression ratio measurement
//!
//! Run with: cargo run --example compression --features std

use lcpfs::{FsResult, Pool};

fn main() -> FsResult<()> {
    println!("=== LCPFS Compression Example ===\n");

    let mut pool = Pool::create_pool(0, "mypool")?;

    // Test 1: Highly compressible data (zeros)
    println!("1. Testing highly compressible data (4096 zeros)...");
    let zeros = vec![0u8; 4096];
    let fd = pool.create("/zeros.dat", 0o644)?;
    pool.write(fd, &zeros)?;
    pool.close(fd)?;
    println!("   ✓ Written 4096 bytes of zeros");
    println!("   Expected: ~50:1 compression ratio with LZ4\n");

    // Test 2: Repeated pattern
    println!("2. Testing repeated pattern data...");
    let pattern = b"ABCD".repeat(1024); // 4096 bytes
    let fd = pool.create("/pattern.dat", 0o644)?;
    pool.write(fd, &pattern)?;
    pool.close(fd)?;
    println!("   ✓ Written 4096 bytes of 'ABCD' pattern");
    println!("   Expected: ~10-20:1 compression ratio\n");

    // Test 3: Text data
    println!("3. Testing text data...");
    let text = b"The quick brown fox jumps over the lazy dog. ".repeat(100);
    let fd = pool.create("/text.txt", 0o644)?;
    pool.write(fd, &text)?;
    pool.close(fd)?;
    println!("   ✓ Written {} bytes of text", text.len());
    println!("   Expected: ~3-5:1 compression ratio\n");

    // Test 4: Random data (incompressible)
    println!("4. Testing random data (incompressible)...");
    let random: Vec<u8> = (0..4096).map(|i| ((i * 7919) % 256) as u8).collect();
    let fd = pool.create("/random.dat", 0o644)?;
    pool.write(fd, &random)?;
    pool.close(fd)?;
    println!("   ✓ Written 4096 bytes of pseudo-random data");
    println!("   Expected: 1:1 ratio (stored uncompressed)\n");

    // Test 5: Mixed data
    println!("5. Testing mixed data...");
    let mut mixed = Vec::new();
    mixed.extend_from_slice(&zeros[..1024]); // Compressible
    mixed.extend_from_slice(&random[..1024]); // Incompressible
    mixed.extend_from_slice(&pattern[..1024]); // Compressible
    mixed.extend_from_slice(&random[1024..2048]); // Incompressible
    let fd = pool.create("/mixed.dat", 0o644)?;
    pool.write(fd, &mixed)?;
    pool.close(fd)?;
    println!("   ✓ Written 4096 bytes of mixed data");
    println!("   Expected: ~2-3:1 ratio (average)\n");

    // Verify data integrity
    println!("6. Verifying data integrity after compression/decompression...");
    let fd = pool.open("/pattern.dat", 0)?;
    let mut buffer = vec![0u8; 4096];
    let read = pool.read(fd, &mut buffer)?;
    pool.close(fd)?;

    if &buffer[..read] == pattern.as_slice() {
        println!("   ✓ Data integrity verified - perfect match!\n");
    } else {
        println!("   ✗ Data integrity check FAILED!\n");
    }

    #[cfg(feature = "std")]
    {
        println!("7. Advanced compression tiers (std feature enabled):");
        println!("   • ZSTD available: ~4-10x ratio, balanced");
        println!("   • LZMA available: ~10-20x ratio, maximum compression");
        println!("   Note: Algorithm selection is automatic based on data temperature\n");
    }

    #[cfg(not(feature = "std"))]
    {
        println!("7. Advanced compression tiers:");
        println!("   Note: Enable 'std' feature for ZSTD and LZMA support");
        println!("   Current: LZ4 only (no_std compatible)\n");
    }

    println!("=== Example completed successfully! ===");
    println!("\nKey takeaways:");
    println!("  • LZ4: Always available, fast, ~2-3x ratio");
    println!("  • ZSTD: Requires 'std' feature, balanced, ~4-10x ratio");
    println!("  • LZMA: Requires 'std' feature, slow but best ratio, ~10-20x");
    println!("  • Incompressible data stored uncompressed automatically");
    println!("  • Compression is transparent - decompression automatic on read");

    Ok(())
}