storage-bindings 0.2.1

//! Two-node networking integration test for the Storage Rust bindings
//!
//! This test demonstrates how to create and connect two Storage nodes:
//! - Create two separate nodes
//! - Configure them to discover each other
//! - Connect the nodes
//! - Transfer data between nodes

use std::fs::File;
use std::io::Write;
use storage_bindings::{
    connect, download_stream, upload_file, DownloadStreamOptions, LogLevel, StorageConfig,
    StorageNode, UploadOptions,
};
use tempfile::tempdir;

#[tokio::test(flavor = "multi_thread")]
async fn test_two_node_network() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logging
    let _ = env_logger::try_init();

    println!("Storage Rust Bindings - Two-Node Network Test");
    println!("============================================");

    // Create temporary directories for our test
    let temp_dir = tempdir()?;
    let node1_dir = temp_dir.path().join("node1");
    let node2_dir = temp_dir.path().join("node2");

    // Create the directories
    std::fs::create_dir_all(&node1_dir)?;
    std::fs::create_dir_all(&node2_dir)?;

    // Create a test file to upload
    let file_path = temp_dir.path().join("test_file.txt");
    let download_path = temp_dir.path().join("downloaded_file.txt");

    println!("Creating test file...");
    let mut file = File::create(&file_path)?;
    file.write_all(b"Hello from node1! This file will be transferred to node2.")?;
    file.sync_all()?;
    println!("Test file created at: {}", file_path.display());

    // Configure node1 to listen on a specific port
    println!("\n=== Creating Node 1 ===");
    let node1_config = StorageConfig::new()
        .log_level(LogLevel::Info)
        .data_dir(&node1_dir)
        .storage_quota(100 * 1024 * 1024) // 100 MB
        .max_peers(50)
        .discovery_port(8092)
        .listen_addrs(vec![
            "/ip4/127.0.0.1/tcp/0".to_string(),
            "/ip4/0.0.0.0/tcp/0".to_string(),
        ]);

    let node1 = StorageNode::new(node1_config).await?;
    node1.start().await?;

    let node1_peer_id = node1.peer_id().await?;
    let node1_repo = node1.repo().await?;
    let debug1 = storage_bindings::debug(&node1).await?;

    println!("Node 1 started:");
    println!("  Peer ID: {}", node1_peer_id);
    println!("  Repository: {}", node1_repo);
    println!("  SPR: {}", debug1.spr);

    // Configure node2 with different ports and bootstrap to node1
    println!("\n=== Creating Node 2 ===");
    let mut node2_config = StorageConfig::new()
        .log_level(LogLevel::Info)
        .data_dir(&node2_dir)
        .storage_quota(100 * 1024 * 1024) // 100 MB
        .max_peers(50)
        .discovery_port(8093)
        .add_bootstrap_node(&debug1.spr);

    // Manually set listen addresses since builder method doesn't exist
    node2_config.listen_addrs = vec![
        "/ip4/127.0.0.1/tcp/0".to_string(), // Let the OS choose a port
        "/ip4/0.0.0.0/tcp/0".to_string(),
    ];

    let node2 = StorageNode::new(node2_config).await?;
    node2.start().await?;

    let node2_peer_id = node2.peer_id().await?;
    let node2_repo = node2.repo().await?;

    println!("Node 2 started:");
    println!("  Peer ID: {}", node2_peer_id);
    println!("  Repository: {}", node2_repo);

    // Get debug information for both nodes
    println!("\n=== Node Debug Information ===");
    let debug2 = storage_bindings::debug(&node2).await?;

    println!("Node 1 debug info:");
    println!("  Peer ID: {}", debug1.peer_id());
    println!("  Address count: {}", debug1.address_count());
    println!("  Discovery node count: {}", debug1.discovery_node_count());

    println!("Node 2 debug info:");
    println!("  Peer ID: {}", debug2.peer_id());
    println!("  Address count: {}", debug2.address_count());
    println!("  Discovery node count: {}", debug2.discovery_node_count());

    // Try to connect node2 to node1
    println!("\n=== Attempting P2P Connection ===");

    // Get node1's actual listening addresses from debug info
    println!("Getting node1's actual listening addresses...");
    let node1_addresses = debug1.addrs.clone();

    println!("Attempting to connect node2 to node1...");
    println!("  Node1 Peer ID: {}", node1_peer_id);
    println!("  Trying addresses:");
    for (i, addr) in node1_addresses.iter().enumerate() {
        println!("    {}: {}", i + 1, addr);
    }

    let mut connection_successful = false;
    for addr in &node1_addresses {
        match connect(&node2, &node1_peer_id, std::slice::from_ref(addr)).await {
            Ok(()) => {
                println!("✓ Successfully connected node2 to node1 at {}", addr);
                connection_successful = true;
                break;
            }
            Err(e) => {
                println!("✗ Failed to connect to node1 at {}: {}", addr, e);
            }
        }
    }

    if !connection_successful {
        println!("⚠ Could not establish direct P2P connection, but continuing with test...");
    }

    // Upload a file from node1
    println!("\n=== Uploading File from Node 1 ===");
    let upload_options = UploadOptions::new()
        .filepath(&file_path)
        .on_progress(|progress| {
            println!(
                "  Upload progress: {} bytes ({}%)",
                progress.bytes_uploaded,
                (progress.percentage * 100.0) as u32
            );
        });

    let upload_result = upload_file(&node1, upload_options).await?;
    println!("File uploaded successfully from node1!");
    println!("  CID: {}", upload_result.cid);
    println!("  Size: {} bytes", upload_result.size);

    // Check if the content exists on node1
    println!("\n=== Checking Content on Node 1 ===");
    let exists_on_node1 = storage_bindings::exists(&node1, &upload_result.cid).await?;
    assert!(exists_on_node1, "Content should exist on node1");
    println!("Content exists on node1: {}", exists_on_node1);

    // Try to fetch the content on node2 (this should trigger P2P transfer if connected)
    println!("\n=== Fetching Content on Node 2 ===");

    // Use tokio::time::timeout to prevent hanging
    let fetch_timeout = tokio::time::Duration::from_secs(30);
    let fetch_result = tokio::time::timeout(
        fetch_timeout,
        storage_bindings::fetch(&node2, &upload_result.cid),
    )
    .await;

    let _fetch_successful = false;
    match fetch_result {
        Ok(Ok(manifest)) => {
            println!("✓ Successfully fetched content on node2:");
            println!("  CID: {}", manifest.cid);
            println!("  Size: {} bytes", manifest.dataset_size);
            println!("  Block size: {} bytes", manifest.block_size);
            let _fetch_successful = true;
        }
        Ok(Err(e)) => {
            println!("✗ Failed to fetch content on node2: {}", e);
            println!("  This might be expected if nodes are not connected");
        }
        Err(_) => {
            println!("✗ Fetch operation timed out after 30 seconds");
            println!("  This indicates the nodes are not properly connected or the content is not available");
        }
    }

    // Check if content exists on node2 after fetch attempt
    let exists_on_node2 = storage_bindings::exists(&node2, &upload_result.cid).await?;
    println!("Content exists on node2: {}", exists_on_node2);

    // Download the file from node2 (if it has the content)
    if exists_on_node2 {
        println!("\n=== Downloading File from Node 2 ===");
        let download_options = DownloadStreamOptions::new(&upload_result.cid)
            .filepath(&download_path)
            .on_progress(|progress| {
                println!(
                    "  Download progress: {} bytes ({}%)",
                    progress.bytes_downloaded,
                    (progress.percentage * 100.0) as u32
                );
            });

        let download_result = download_stream(&node2, &upload_result.cid, download_options).await?;
        println!("File downloaded successfully from node2!");
        println!("  Size: {} bytes", download_result.size);

        // Verify the downloaded content
        println!("\n=== Verifying Downloaded Content ===");
        let original_content = std::fs::read_to_string(&file_path)?;
        let downloaded_content = std::fs::read_to_string(&download_path)?;

        assert_eq!(
            original_content, downloaded_content,
            "Downloaded content should match original"
        );
        println!("✓ Content verification successful! P2P transfer worked!");
    } else {
        println!("\n=== Download Test Skipped ===");
        println!("Content not available on node2 - P2P transfer test skipped");
        println!("This is expected if nodes cannot establish direct connection");
    }

    // Get final debug information
    println!("\n=== Final Node Status ===");
    let final_debug1 = storage_bindings::debug(&node1).await?;
    let final_debug2 = storage_bindings::debug(&node2).await?;

    println!("Node 1 final status:");
    println!("  Peer ID: {}", final_debug1.peer_id());
    println!("  Address count: {}", final_debug1.address_count());
    println!(
        "  Discovery node count: {}",
        final_debug1.discovery_node_count()
    );
    println!("  Health status: {}", final_debug1.health_status());

    println!("Node 2 final status:");
    println!("  Peer ID: {}", final_debug2.peer_id());
    println!("  Address count: {}", final_debug2.address_count());
    println!(
        "  Discovery node count: {}",
        final_debug2.discovery_node_count()
    );
    println!("  Health status: {}", final_debug2.health_status());

    // Get storage information
    println!("\n=== Storage Information ===");
    let space1 = storage_bindings::space(&node1).await?;
    let space2 = storage_bindings::space(&node2).await?;

    println!("Node 1 storage:");
    println!("  Used: {} bytes", space1.quota_used_bytes);
    println!(
        "  Available: {} bytes",
        space1.quota_max_bytes - space1.quota_used_bytes
    );
    println!("  Total blocks: {}", space1.total_blocks);

    println!("Node 2 storage:");
    println!("  Used: {} bytes", space2.quota_used_bytes);
    println!(
        "  Available: {} bytes",
        space2.quota_max_bytes - space2.quota_used_bytes
    );
    println!("  Total blocks: {}", space2.total_blocks);

    // List manifests on both nodes
    println!("\n=== Manifests ===");
    let manifests1 = storage_bindings::manifests(&node1).await?;
    let manifests2 = storage_bindings::manifests(&node2).await?;

    println!("Node 1 manifests: {}", manifests1.len());
    for manifest in &manifests1 {
        println!(
            "  CID: {}, Size: {} bytes",
            manifest.cid, manifest.dataset_size
        );
    }

    println!("Node 2 manifests: {}", manifests2.len());
    for manifest in &manifests2 {
        println!(
            "  CID: {}, Size: {} bytes",
            manifest.cid, manifest.dataset_size
        );
    }

    // Stop and destroy both nodes
    println!("\n=== Cleanup ===");
    println!("Stopping node1...");
    node1.stop().await?;
    node1.destroy().await?;
    println!("Node1 stopped and destroyed.");

    println!("Stopping node2...");
    node2.stop().await?;
    node2.destroy().await?;
    println!("Node2 stopped and destroyed.");

    println!("\nTwo-node network test completed!");
    println!("Note: P2P connectivity depends on network configuration and available ports.");
    Ok(())
}