/// 性能测试：压力测试
/// 
/// 测试系统的极限承载能力

use nac_integration_tests::common::*;

#[tokio::test]
async fn test_maximum_load() {
    init_test_env();
    
    let config = TestConfig::stress();
    
    // 极限负载：100,000个交易
    let tx_count = 100000;
    log::info!("Starting maximum load test with {} transactions", tx_count);
    
    let mut transactions = Vec::new();
    for i in 0..tx_count {
        let tx = create_test_transaction(
            (i % 100) as u8,
            ((i + 1) % 100) as u8,
            100,
        );
        transactions.push(tx);
    }
    
    log::info!("Created {} transactions", transactions.len());
    
    // 验证所有交易
    let mut valid_count = 0;
    for tx in &transactions {
        if tx.amount > 0 {
            valid_count += 1;
        }
    }
    
    log::info!("Valid transactions: {}", valid_count);
    assert_eq!(valid_count, tx_count);
    
    log::info!("Maximum load test passed");
}

#[tokio::test]
async fn test_memory_pressure() {
    init_test_env();
    
    // 创建大量数据对象
    let account_count = 10000;
    let accounts = create_test_accounts(account_count, 1000);
    
    log::info!("Created {} accounts", accounts.len());
    assert_eq!(accounts.len(), account_count);
    
    // 创建大量区块
    let block_count = 1000;
    let blocks = create_test_blockchain(block_count);
    
    log::info!("Created {} blocks", blocks.len());
    assert_eq!(blocks.len(), block_count);
    
    // 验证数据完整性
    assert_blockchain_valid(&blocks);
    
    log::info!("Memory pressure test passed");
}

#[tokio::test]
async fn test_rapid_block_production() {
    init_test_env();
    
    // 快速出块测试
    let block_count = 1000;
    let start = std::time::Instant::now();
    
    let blocks = create_test_blockchain(block_count);
    
    let duration = start.elapsed();
    let blocks_per_sec = block_count as f64 / duration.as_secs_f64();
    
    log::info!("Produced {} blocks in {:?}", block_count, duration);
    log::info!("Blocks per second: {:.2}", blocks_per_sec);
    
    assert_blockchain_valid(&blocks);
    
    log::info!("Rapid block production test passed");
}

#[tokio::test]
async fn test_large_transaction_batch() {
    init_test_env();
    
    // 大批量交易测试
    let batch_size = 50000;
    let mut transactions = Vec::new();
    
    log::info!("Creating batch of {} transactions", batch_size);
    
    for i in 0..batch_size {
        let tx = create_test_transaction(
            (i % 100) as u8,
            ((i + 1) % 100) as u8,
            100,
        );
        transactions.push(tx);
    }
    
    log::info!("Batch created, validating...");
    
    let mut valid_count = 0;
    for tx in &transactions {
        if tx.amount > 0 {
            valid_count += 1;
        }
    }
    
    assert_eq!(valid_count, batch_size);
    
    log::info!("Large transaction batch test passed");
}

#[tokio::test]
async fn test_sustained_high_load() {
    init_test_env();
    
    // 持续高负载测试
    let duration_secs = 30;
    let target_tps = 10000;
    
    log::info!("Starting sustained high load test for {} seconds", duration_secs);
    
    let start = std::time::Instant::now();
    let mut total_tx = 0;
    
    while start.elapsed().as_secs() < duration_secs {
        // 每批处理10000个交易
        for i in 0..10000 {
            let tx = create_test_transaction(
                (i % 100) as u8,
                ((i + 1) % 100) as u8,
                100,
            );
            if tx.amount > 0 {
                total_tx += 1;
            }
        }
        
        // 短暂休息，避免CPU 100%
        tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
    }
    
    let actual_duration = start.elapsed();
    let actual_tps = perf::calculate_tps(total_tx, actual_duration);
    
    log::info!("Sustained high load test completed");
    log::info!("Total transactions: {}", total_tx);
    log::info!("Duration: {:?}", actual_duration);
    log::info!("Average TPS: {:.2}", actual_tps);
    
    assert!(actual_tps > 1000.0);
    
    log::info!("Sustained high load test passed");
}

#[tokio::test]
async fn test_spike_load() {
    init_test_env();
    
    // 突发负载测试
    log::info!("Starting spike load test");
    
    // 正常负载
    let normal_load = 1000;
    for i in 0..normal_load {
        let tx = create_test_transaction(
            (i % 50) as u8,
            ((i + 1) % 50) as u8,
            100,
        );
        assert!(tx.amount > 0);
    }
    
    log::info!("Normal load: {} transactions", normal_load);
    
    // 突发负载
    let spike_load = 50000;
    let start = std::time::Instant::now();
    
    for i in 0..spike_load {
        let tx = create_test_transaction(
            (i % 100) as u8,
            ((i + 1) % 100) as u8,
            100,
        );
        assert!(tx.amount > 0);
    }
    
    let spike_duration = start.elapsed();
    let spike_tps = perf::calculate_tps(spike_load, spike_duration);
    
    log::info!("Spike load: {} transactions in {:?}", spike_load, spike_duration);
    log::info!("Spike TPS: {:.2}", spike_tps);
    
    // 恢复正常负载
    for i in 0..normal_load {
        let tx = create_test_transaction(
            (i % 50) as u8,
            ((i + 1) % 50) as u8,
            100,
        );
        assert!(tx.amount > 0);
    }
    
    log::info!("Spike load test passed");
}

#[tokio::test]
async fn test_resource_exhaustion() {
    init_test_env();
    
    // 资源耗尽测试
    log::info!("Starting resource exhaustion test");
    
    // 创建大量账户
    let account_count = 50000;
    let accounts = create_test_accounts(account_count, 1000);
    assert_eq!(accounts.len(), account_count);
    
    // 创建大量交易
    let tx_count = 50000;
    let mut transactions = Vec::new();
    for i in 0..tx_count {
        let tx = create_test_transaction(
            (i % 1000) as u8,
            ((i + 1) % 1000) as u8,
            100,
        );
        transactions.push(tx);
    }
    
    assert_eq!(transactions.len(), tx_count);
    
    log::info!("Resource exhaustion test passed");
}