/// 性能测试：TPS (Transactions Per Second)
/// 
/// 测试NAC公链的交易处理能力

use nac_integration_tests::common::*;
use std::time::Instant;

#[tokio::test]
async fn test_peak_tps() {
    init_test_env();
    
    let config = TestConfig::performance();
    
    // 创建大量交易
    let tx_count = 10000;
    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);
    }
    
    // 测量处理时间
    let start = Instant::now();
    
    // 模拟交易处理
    for tx in &transactions {
        assert_transaction_valid(tx);
    }
    
    let duration = start.elapsed();
    
    // 计算TPS
    let tps = perf::calculate_tps(tx_count, duration);
    
    log::info!("Peak TPS: {:.2}", tps);
    log::info!("Duration: {:?}", duration);
    log::info!("Total transactions: {}", tx_count);
    
    // 验证TPS目标
    assert_tps_meets_requirement(tps, 1000.0);
    
    log::info!("Peak TPS test passed");
}

#[tokio::test]
async fn test_sustained_tps() {
    init_test_env();
    
    // 持续负载测试
    let duration_secs = 10;
    let target_tps = 5000.0;
    
    let start = Instant::now();
    let mut total_tx = 0;
    
    while start.elapsed().as_secs() < duration_secs {
        // 每批处理1000个交易
        let batch_size = 1000;
        for i in 0..batch_size {
            let tx = create_test_transaction(
                (i % 50) as u8,
                ((i + 1) % 50) as u8,
                100,
            );
            assert_transaction_valid(&tx);
            total_tx += 1;
        }
    }
    
    let actual_duration = start.elapsed();
    let actual_tps = perf::calculate_tps(total_tx, actual_duration);
    
    log::info!("Sustained TPS: {:.2}", actual_tps);
    log::info!("Duration: {:?}", actual_duration);
    log::info!("Total transactions: {}", total_tx);
    
    assert_tps_meets_requirement(actual_tps, target_tps);
    
    log::info!("Sustained TPS test passed");
}

#[tokio::test]
async fn test_tps_with_smart_contracts() {
    init_test_env();
    
    // 测试包含智能合约调用的TPS
    let tx_count = 5000;
    let mut transactions = Vec::new();
    
    for i in 0..tx_count {
        let caller = Address::from_index((i % 50) as u8);
        let contract = Address::from_index(100);
        
        let tx = TestTransaction::new(caller, contract, 0, i as u64);
        transactions.push(tx);
    }
    
    let start = Instant::now();
    
    for tx in &transactions {
        assert_transaction_valid(tx);
    }
    
    let duration = start.elapsed();
    let tps = perf::calculate_tps(tx_count, duration);
    
    log::info!("TPS with smart contracts: {:.2}", tps);
    
    // 智能合约调用的TPS通常较低
    assert_tps_meets_requirement(tps, 500.0);
    
    log::info!("TPS with smart contracts test passed");
}

#[tokio::test]
async fn test_tps_degradation_under_load() {
    init_test_env();
    
    // 测试负载增加时的TPS变化
    let load_levels = vec![1000, 5000, 10000, 20000];
    let mut tps_results = Vec::new();
    
    for &tx_count in &load_levels {
        let mut transactions = Vec::new();
        for i in 0..tx_count {
            let tx = create_test_transaction(
                (i % 50) as u8,
                ((i + 1) % 50) as u8,
                100,
            );
            transactions.push(tx);
        }
        
        let start = Instant::now();
        for tx in &transactions {
            assert_transaction_valid(tx);
        }
        let duration = start.elapsed();
        
        let tps = perf::calculate_tps(tx_count, duration);
        tps_results.push((tx_count, tps));
        
        log::info!("Load: {} tx, TPS: {:.2}", tx_count, tps);
    }
    
    // 验证TPS不会严重退化
    for (load, tps) in &tps_results {
        assert!(tps > &500.0, "TPS too low at load {}: {}", load, tps);
    }
    
    log::info!("TPS degradation under load test passed");
}

#[tokio::test]
async fn test_block_production_rate() {
    init_test_env();
    
    // 测试区块生产速率
    let block_count = 100;
    let target_block_time_ms = 1000; // 1秒
    
    let start = Instant::now();
    
    let blocks = create_test_blockchain(block_count);
    
    let duration = start.elapsed();
    let avg_block_time_ms = duration.as_millis() / block_count as u128;
    
    log::info!("Average block time: {} ms", avg_block_time_ms);
    log::info!("Target block time: {} ms", target_block_time_ms);
    
    // 验证区块时间
    assert!(avg_block_time_ms < target_block_time_ms as u128 * 2);
    
    log::info!("Block production rate test passed");
}