lcpfs 2026.1.102

//! Snapshot operations and workflows
//!
//! This example demonstrates:
//! - Creating snapshots
//! - Rolling back to snapshots
//! - Full send/receive replication
//! - Incremental send/receive
//!
//! Run with: cargo run --example snapshots

use lcpfs::{FsResult, Pool};

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

    // Create initial pool and data
    println!("1. Setting up initial pool...");
    let mut pool = Pool::create_pool(0, "mypool")?;

    let fd = pool.create("/data.txt", 0o644)?;
    pool.write(fd, b"Version 1: Initial data")?;
    pool.close(fd)?;
    println!("   ✓ Created initial file\n");

    // Create first snapshot
    println!("2. Creating snapshot 'baseline'...");
    pool.snapshot("baseline")?;
    println!("   ✓ Snapshot created\n");

    // Make changes
    println!("3. Modifying data...");
    let fd = pool.open("/data.txt", 0)?;
    pool.write(fd, b"Version 2: Modified data")?;
    pool.close(fd)?;
    println!("   ✓ Data modified\n");

    // Create second snapshot
    println!("4. Creating snapshot 'v2'...");
    pool.snapshot("v2")?;
    println!("   ✓ Snapshot created\n");

    // List snapshots (returns Vec, not Result)
    println!("5. Listing snapshots...");
    let snapshots = pool.list_snapshots();
    println!("   Snapshots:");
    for (name, txg, creation_time) in &snapshots {
        println!("     - {} (txg={}, created={})", name, txg, creation_time);
    }
    println!();

    // Rollback to baseline
    println!("6. Rolling back to 'baseline'...");
    pool.rollback("baseline")?;
    println!("   ✓ Rolled back\n");

    // Verify rollback
    println!("7. Verifying rollback...");
    let fd = pool.open("/data.txt", 0)?;
    let mut buffer = vec![0u8; 1024];
    let read = pool.read(fd, &mut buffer)?;
    pool.close(fd)?;
    println!(
        "   Content after rollback: {:?}",
        String::from_utf8_lossy(&buffer[..read])
    );
    println!("   ✓ Rollback successful\n");

    // Demonstrate send/receive
    println!("8. Creating new snapshot for replication...");
    pool.snapshot("v3")?;

    println!("9. Sending full snapshot stream...");
    let stream = pool.send()?;
    println!(
        "   ✓ Generated {} bytes of replication data\n",
        stream.len()
    );

    // Demonstrate incremental send
    println!("10. Making more changes...");
    let fd = pool.create("/new_file.txt", 0o644)?;
    pool.write(fd, b"New file added")?;
    pool.close(fd)?;
    pool.snapshot("v4")?;

    println!("11. Sending incremental snapshot (v3 → v4)...");
    let incremental = pool.send_snapshot_incremental("v3", Some("v4"))?;
    println!(
        "    ✓ Incremental stream: {} bytes (much smaller!)\n",
        incremental.len()
    );

    // Cleanup
    println!("12. Cleaning up - destroying snapshot 'v2'...");
    pool.destroy_snapshot("v2")?;
    println!("    ✓ Snapshot destroyed\n");

    println!("=== Example completed successfully! ===");
    println!("\nKey takeaways:");
    println!("  • Snapshots are instant (O(1) metadata operation)");
    println!("  • Rollback restores filesystem to snapshot state");
    println!("  • Full send: entire snapshot serialized");
    println!("  • Incremental send: only changes between snapshots");

    Ok(())
}