//! CBPP集成测试
//! 
//! 测试各模块之间的集成和完整的共识流程

use nac_cbpp::*;
use nac_cbpp::fork::ForkChain;

#[test]
fn test_full_consensus_flow() {
    // 1. 创建验证者集合
    let mut validator_set = ValidatorSet::new();
    validator_set.add_validator(Validator::new("validator1".to_string(), 1000));
    validator_set.add_validator(Validator::new("validator2".to_string(), 1000));
    validator_set.add_validator(Validator::new("validator3".to_string(), 1000));

    // 2. 创建共识引擎
    let mut engine = ConsensusEngine::new();
    engine.set_validator_set(validator_set);

    // 3. 开始新高度
    engine.start_new_height(1);
    assert_eq!(engine.state(), ConsensusState::NewHeight);

    // 4. 进入提议阶段
    engine.enter_propose();
    assert_eq!(engine.state(), ConsensusState::Propose);

    // 5. 创建并验证区块
    let block = Block::new(1, "genesis".to_string(), "validator1".to_string());
    assert!(engine.handle_proposal(block));
    assert_eq!(engine.state(), ConsensusState::Prevote);
}

#[test]
fn test_block_validation_integration() {
    // 创建区块验证器
    let validator = BlockValidator::new();

    // 创建区块（使用长地址满足KYC要求）
    let mut block = Block::new(0, "0".repeat(96), "0x1234567890123456789012345678901234567890".to_string());
    block.header.state_root = "0".repeat(64);
    block.header.timestamp = chrono::Utc::now();
    
    // 计算Merkle根（空交易列表）
    block.header.merkle_root = "0".repeat(64);

    // 验证区块
    match validator.validate_block(&block, None) {
        Ok(_) => {},
        Err(e) => panic!("Validation failed: {:?}", e),
    }
}

#[test]
fn test_signature_integration() {
    // 创建密钥管理器
    let mut key_manager = KeyManager::new();
    
    // 生成密钥对
    let (private_key, public_key) = key_manager.generate_key_pair("validator1".to_string()).expect("mainnet: handle error");

    // 签名消息
    let message = b"Test block";
    let signature = private_key.sign(message);

    // 验证签名
    assert!(public_key.verify(message, &signature).is_ok());

    // 创建聚合签名
    let mut aggregate = AggregateSignature::new();
    assert!(aggregate.add_signature(&signature, &public_key).is_ok());
    assert_eq!(aggregate.signer_count(), 1);
}

#[test]
fn test_timeout_integration() {
    // 创建超时管理器
    let mut timeout_manager = TimeoutManager::with_default_config();

    // 启动超时
    timeout_manager.start_timeout(
        "proposal_1_0".to_string(),
        TimeoutType::Proposal,
        1,
        0,
    );

    assert_eq!(timeout_manager.active_timer_count(), 1);

    // 取消超时
    assert!(timeout_manager.cancel_timeout("proposal_1_0"));
    assert_eq!(timeout_manager.active_timer_count(), 0);
}

#[test]
fn test_fork_detection_integration() {
    // 创建分叉检测器
    let mut detector = ForkDetector::new(1);

    // 添加相同高度的不同区块
    let block1 = Block::new(1, "genesis".to_string(), "validator1".to_string());
    let block2 = Block::new(1, "genesis".to_string(), "validator2".to_string());

    // 第一个区块不应触发分叉
    assert!(detector.add_block(block1).expect("mainnet: handle error").is_none());

    // 第二个区块应触发分叉
    let fork = detector.add_block(block2).expect("mainnet: handle error");
    assert!(fork.is_some());

    // 检查分叉信息
    let fork_info = fork.expect("mainnet: handle error");
    assert_eq!(fork_info.fork_height, 1);
    assert_eq!(fork_info.chains.len(), 2);
}

#[test]
fn test_fork_choice_integration() {
    // 创建分叉选择器
    let selector = ForkChoiceSelector::new(ForkChoiceRule::LongestChain);

    // 创建分叉信息
    let mut fork_info = ForkInfo::new("test_fork".to_string(), 1);

    // 创建两条链
    let mut chain1 = ForkChain::new("chain1".to_string());
    chain1.add_block(Block::new(1, "genesis".to_string(), "v1".to_string()));

    let mut chain2 = ForkChain::new("chain2".to_string());
    chain2.add_block(Block::new(1, "genesis".to_string(), "v2".to_string()));
    chain2.add_block(Block::new(2, "block1".to_string(), "v2".to_string()));

    fork_info.add_chain(chain1);
    fork_info.add_chain(chain2);

    // 选择最佳链
    let best_chain = selector.select_best_chain(&fork_info).expect("mainnet: handle error");
    assert_eq!(best_chain.id, "chain2");
    assert_eq!(best_chain.length(), 2);
}

#[test]
fn test_complete_consensus_with_validation() {
    // 创建完整的共识环境
    let mut validator_set = ValidatorSet::new();
    validator_set.add_validator(Validator::new("v1".to_string(), 1000));
    validator_set.add_validator(Validator::new("v2".to_string(), 1000));
    validator_set.add_validator(Validator::new("v3".to_string(), 1000));

    let mut engine = ConsensusEngine::new();
    engine.set_validator_set(validator_set);

    let block_validator = BlockValidator::new();
    let mut key_manager = KeyManager::new();

    // 生成验证者密钥
    for i in 1..=3 {
        key_manager.generate_key_pair(format!("v{}", i)).expect("mainnet: handle error");
    }

    // 开始共识
    engine.start_new_height(1);
    engine.enter_propose();

    // 创建并验证区块（使用长地址满足KYC要求）
    let mut block = Block::new(0, "0".repeat(96), "0x1234567890123456789012345678901234567890".to_string());
    block.header.state_root = "0".repeat(64);
    block.header.timestamp = chrono::Utc::now();
    block.header.merkle_root = "0".repeat(64);

    // 验证区块
    assert!(block_validator.validate_block(&block, None).is_ok());

    // 处理提议
    assert!(engine.handle_proposal(block));
}

#[test]
fn test_timeout_with_recovery() {
    use std::thread;
    use std::time::Duration;

    // 创建超时管理器（短超时用于测试）
    let mut config = TimeoutConfig::default_config();
    config.proposal_timeout = 1; // 1秒
    let mut timeout_manager = TimeoutManager::new(config).expect("mainnet: handle error");

    // 启动超时
    timeout_manager.start_timeout(
        "test_timeout".to_string(),
        TimeoutType::Proposal,
        1,
        0,
    );

    // 等待超时
    thread::sleep(Duration::from_secs(2));

    // 检查超时事件
    let events = timeout_manager.check_timeouts();
    assert_eq!(events.len(), 1);
    assert_eq!(events[0].timeout_type, TimeoutType::Proposal);
}

#[test]
fn test_compliance_checking() {
    let mut validator = BlockValidator::new();
    
    // 添加黑名单地址
    validator.compliance_checker_mut().add_to_blacklist("0x_malicious".to_string());

    // 创建区块
    let block = Block::new(1, "genesis".to_string(), "0x_malicious".to_string());

    // 应该失败（提议者在黑名单中）
    assert!(validator.validate_block(&block, None).is_err());
}

#[test]
fn test_aggregate_signature_verification() {
    let mut key_manager = KeyManager::new();
    
    // 生成多个密钥对
    let (pk1, pub1) = key_manager.generate_key_pair("v1".to_string()).expect("mainnet: handle error");
    let (pk2, pub2) = key_manager.generate_key_pair("v2".to_string()).expect("mainnet: handle error");
    let (pk3, pub3) = key_manager.generate_key_pair("v3".to_string()).expect("mainnet: handle error");

    // 签名相同消息
    let message = b"Block proposal";
    let sig1 = pk1.sign(message);
    let sig2 = pk2.sign(message);
    let sig3 = pk3.sign(message);

    // 创建聚合签名
    let mut aggregate = AggregateSignature::new();
    assert!(aggregate.add_signature(&sig1, &pub1).is_ok());
    assert!(aggregate.add_signature(&sig2, &pub2).is_ok());
    assert!(aggregate.add_signature(&sig3, &pub3).is_ok());

    assert_eq!(aggregate.signer_count(), 3);
    assert!(aggregate.verify(message).is_ok());
}

#[test]
fn test_fork_prevention() {
    let mut prevention = ForkPrevention::new(3, 1000);
    
    // 添加恶意验证者到黑名单
    prevention.add_to_blacklist("malicious_validator".to_string());

    // 创建由恶意验证者提议的区块
    let block = Block::new(1, "genesis".to_string(), "malicious_validator".to_string());

    // 应该被阻止
    assert!(prevention.check_block(&block).is_err());

    // 正常验证者应该通过
    let good_block = Block::new(1, "genesis".to_string(), "good_validator".to_string());
    assert!(prevention.check_block(&good_block).is_ok());
}

#[test]
fn test_multi_round_consensus() {
    let mut validator_set = ValidatorSet::new();
    validator_set.add_validator(Validator::new("v1".to_string(), 1000));
    validator_set.add_validator(Validator::new("v2".to_string(), 1000));

    let mut engine = ConsensusEngine::new();
    engine.set_validator_set(validator_set);

    // 第一轮
    engine.start_new_height(1);
    engine.enter_propose();
    let block1 = Block::new(1, "genesis".to_string(), "v1".to_string());
    assert!(engine.handle_proposal(block1));

    // 第二轮
    engine.start_new_height(2);
    engine.enter_propose();
    let block2 = Block::new(2, "block1".to_string(), "v2".to_string());
    assert!(engine.handle_proposal(block2));
}