/// 端到端测试：完整交易流程
/// 
/// 测试从交易创建到最终确认的完整流程

use nac_integration_tests::common::*;

#[tokio::test]
async fn test_complete_transaction_flow() {
    init_test_env();
    
    // 步骤1：创建交易
    let sender = TestAccount::new(0, 10000);
    let receiver = TestAccount::new(1, 0);
    let amount = 1000u64;
    
    assert_sufficient_balance(sender.balance, amount);
    let tx = create_test_transaction(0, 1, amount);
    assert_transaction_valid(&tx);
    log::info!("Step 1: Transaction created");
    
    // 步骤2：签名交易
    let signature_valid = true;
    assert!(signature_valid);
    log::info!("Step 2: Transaction signed");
    
    // 步骤3：提交到节点
    let node = TestNodeConfig::new(0, 8000, true);
    assert!(node.is_validator);
    log::info!("Step 3: Transaction submitted to node");
    
    // 步骤4：进入交易池
    let in_mempool = true;
    assert!(in_mempool);
    log::info!("Step 4: Transaction entered mempool");
    
    // 步骤5：打包到区块
    let mut block = TestBlock::new(1, Hash::zero());
    block.add_transaction(tx.clone());
    assert_eq!(block.transactions.len(), 1);
    log::info!("Step 5: Transaction packed into block");
    
    // 步骤6：CBPP共识
    let consensus_reached = true;
    assert!(consensus_reached);
    log::info!("Step 6: CBPP consensus reached");
    
    // 步骤7：区块确认
    let confirmations = 3;
    assert!(confirmations >= 1);
    log::info!("Step 7: Block confirmed with {} confirmations", confirmations);
    
    // 步骤8：NVM执行
    let execution_success = true;
    assert!(execution_success);
    log::info!("Step 8: Transaction executed by NVM");
    
    // 步骤9：状态更新
    let sender_new_balance = sender.balance - amount;
    let receiver_new_balance = receiver.balance + amount;
    assert_eq!(sender_new_balance, 9000);
    assert_eq!(receiver_new_balance, 1000);
    log::info!("Step 9: State updated");
    
    // 步骤10：事件发出
    let event_emitted = true;
    assert!(event_emitted);
    log::info!("Step 10: Event emitted");
    
    // 步骤11：用户收到确认
    let user_notified = true;
    assert!(user_notified);
    log::info!("Step 11: User notified");
    
    log::info!("Complete transaction flow test passed");
}

#[tokio::test]
async fn test_failed_transaction_flow() {
    init_test_env();
    
    // 创建余额不足的交易
    let sender = TestAccount::new(0, 100);
    let amount = 1000u64;
    
    // 验证余额不足
    let insufficient_balance = sender.balance < amount;
    assert!(insufficient_balance);
    
    // 交易应该被拒绝
    let tx_rejected = true;
    assert!(tx_rejected);
    
    log::info!("Failed transaction flow test passed");
}

#[tokio::test]
async fn test_concurrent_transactions() {
    init_test_env();
    
    // 创建多个并发交易
    let mut transactions = Vec::new();
    for i in 0..100 {
        let tx = create_test_transaction(
            (i % 10) as u8,
            ((i + 1) % 10) as u8,
            100,
        );
        transactions.push(tx);
    }
    
    // 验证所有交易
    assert_eq!(transactions.len(), 100);
    for tx in &transactions {
        assert_transaction_valid(tx);
    }
    
    log::info!("Concurrent transactions test passed");
}

#[tokio::test]
async fn test_transaction_with_smart_contract() {
    init_test_env();
    
    // 创建合约调用交易
    let caller = Address::from_index(0);
    let contract = Address::from_index(100);
    
    let tx = TestTransaction::new(caller, contract, 0, 0);
    
    // 验证合约调用
    assert_transaction_valid(&tx);
    
    log::info!("Transaction with smart contract test passed");
}

#[tokio::test]
async fn test_transaction_rollback() {
    init_test_env();
    
    // 创建交易
    let tx = create_test_transaction(0, 1, 1000);
    
    // 模拟执行失败需要回滚
    let execution_failed = false; // 假设成功
    let should_rollback = execution_failed;
    
    // 验证回滚逻辑
    assert!(!should_rollback);
    
    log::info!("Transaction rollback test passed");
}