//! 钱包核心集成测试

use nac_wallet_core::*;
use nac_wallet_core::mnemonic::{Language, MnemonicLength};
use nac_wallet_core::multisig::{MultisigScheme, Signer};
use nac_wallet_core::security::{EncryptionConfig, AuditEvent, AuditEventType, Operation, PermissionLevel};

#[test]
fn test_mnemonic_to_address() {
    // 创建助记词
    let entropy = vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
                      0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0];
    let mnemonic = Mnemonic::from_entropy(&entropy, Language::English).expect("mainnet: handle error");
    
    // 创建派生路径
    let path = DerivationPath::bip44(60, 0, 0, 0);
    
    // 生成地址
    let address = AddressGenerator::from_mnemonic(&mnemonic, &path, "").expect("mainnet: handle error");
    
    assert!(address.starts_with("0x"));
    assert_eq!(address.len(), 42);
}

#[test]
fn test_batch_address_generation() {
    // 创建助记词
    let entropy = vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
                      0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0];
    let mnemonic = Mnemonic::from_entropy(&entropy, Language::English).expect("mainnet: handle error");
    
    // 批量生成地址
    let addresses = AddressGenerator::generate_addresses(&mnemonic, 60, 0, 10, "").expect("mainnet: handle error");
    
    assert_eq!(addresses.len(), 10);
    for (address, path) in addresses {
        assert!(address.starts_with("0x"));
        assert_eq!(path.components().len(), 5);
    }
}

#[test]
fn test_multisig_workflow() {
    // 创建签名者
    let signers = vec![
        Signer::new("0x1111".to_string(), vec![1; 32]),
        Signer::new("0x2222".to_string(), vec![2; 32]),
        Signer::new("0x3333".to_string(), vec![3; 32]),
    ];
    
    // 创建2-of-3多签配置
    let config = MultisigConfig::m_of_n(signers.clone(), 2).expect("mainnet: handle error");
    let address = MultisigAddress::from_config(config, 1000);
    
    // 创建签名收集器
    let mut collector = SignatureCollector::new();
    collector.register_address(address.clone());
    
    // 创建交易
    let tx_id = collector.create_transaction(
        address.address().to_string(),
        vec![1, 2, 3, 4, 5],
        1000
    ).expect("mainnet: handle error");
    
    // 添加第一个签名
    let sig1 = multisig::Signature::new(signers[0].address.clone(), vec![10, 20, 30], 1100);
    collector.add_signature(&tx_id, sig1, 1100).expect("mainnet: handle error");
    
    // 此时不能广播（只有1个签名）
    assert!(!collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
    
    // 添加第二个签名
    let sig2 = multisig::Signature::new(signers[1].address.clone(), vec![40, 50, 60], 1200);
    collector.add_signature(&tx_id, sig2, 1200).expect("mainnet: handle error");
    
    // 现在可以广播（有2个签名）
    assert!(collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
    
    // 广播交易
    collector.broadcast_transaction(&tx_id).expect("mainnet: handle error");
    
    let tx = collector.get_transaction(&tx_id).expect("mainnet: handle error");
    assert_eq!(tx.status, multisig::TransactionStatus::Broadcasted);
}

#[test]
fn test_weighted_multisig() {
    // 创建加权签名者
    let signers = vec![
        Signer::new("0x1111".to_string(), vec![1; 32]).with_weight(3),
        Signer::new("0x2222".to_string(), vec![2; 32]).with_weight(2),
        Signer::new("0x3333".to_string(), vec![3; 32]).with_weight(1),
    ];
    
    // 创建加权多签配置（阈值为4）
    let config = MultisigConfig::weighted(signers.clone(), 4).expect("mainnet: handle error");
    let address = MultisigAddress::from_config(config, 1000);
    
    let mut collector = SignatureCollector::new();
    collector.register_address(address.clone());
    
    let tx_id = collector.create_transaction(
        address.address().to_string(),
        vec![1, 2, 3],
        1000
    ).expect("mainnet: handle error");
    
    // 添加权重为3的签名（不够）
    let sig1 = multisig::Signature::new(signers[0].address.clone(), vec![1], 1100);
    collector.add_signature(&tx_id, sig1, 1100).expect("mainnet: handle error");
    assert!(!collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
    
    // 添加权重为2的签名（总权重5，超过阈值4）
    let sig2 = multisig::Signature::new(signers[1].address.clone(), vec![2], 1200);
    collector.add_signature(&tx_id, sig2, 1200).expect("mainnet: handle error");
    assert!(collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
}

#[test]
fn test_hardware_wallet_integration() {
    // 创建设备管理器
    let mut manager = DeviceManager::new();
    
    // 扫描设备
    let devices = manager.scan_devices().expect("mainnet: handle error");
    assert!(devices.len() >= 2);
    
    // 连接Ledger设备
    manager.connect_ledger("ledger_001".to_string()).expect("mainnet: handle error");
    assert!(manager.is_connected("ledger_001"));
    
    // 连接Trezor设备
    manager.connect_trezor("trezor_001".to_string()).expect("mainnet: handle error");
    assert!(manager.is_connected("trezor_001"));
    
    // 断开设备
    manager.disconnect("ledger_001").expect("mainnet: handle error");
    assert!(!manager.is_connected("ledger_001"));
}

#[test]
fn test_secure_storage_workflow() {
    // 创建安全存储
    let mut storage = SecureStorage::default();
    
    // 存储多个密钥
    let password = "strong_password";
    storage.store_key("key1".to_string(), b"secret_data_1", password).expect("mainnet: handle error");
    storage.store_key("key2".to_string(), b"secret_data_2", password).expect("mainnet: handle error");
    storage.store_key("key3".to_string(), b"secret_data_3", password).expect("mainnet: handle error");
    
    // 列出所有密钥
    let keys = storage.list_keys();
    assert_eq!(keys.len(), 3);
    
    // 获取密钥
    let data1 = storage.get_key("key1", password).expect("mainnet: handle error");
    assert_eq!(data1, b"secret_data_1");
    
    // 删除密钥
    storage.delete_key("key2").expect("mainnet: handle error");
    assert_eq!(storage.list_keys().len(), 2);
}

#[test]
fn test_permission_control() {
    // 创建权限控制器
    let mut controller = PermissionController::new();
    
    // 添加用户
    controller.add_user("user1".to_string(), PermissionLevel::ReadOnly);
    controller.add_user("user2".to_string(), PermissionLevel::ReadWrite);
    controller.add_user("admin".to_string(), PermissionLevel::Admin);
    
    // 检查权限
    assert!(controller.check_permission("user1", Operation::Read).is_ok());
    assert!(controller.check_permission("user1", Operation::Write).is_err());
    
    assert!(controller.check_permission("user2", Operation::Read).is_ok());
    assert!(controller.check_permission("user2", Operation::Write).is_ok());
    assert!(controller.check_permission("user2", Operation::Delete).is_err());
    
    assert!(controller.check_permission("admin", Operation::Read).is_ok());
    assert!(controller.check_permission("admin", Operation::Write).is_ok());
    assert!(controller.check_permission("admin", Operation::Delete).is_ok());
    assert!(controller.check_permission("admin", Operation::Export).is_ok());
}

#[test]
fn test_security_audit() {
    // 创建审计器
    let mut auditor = SecurityAuditor::new(1000);
    
    // 记录事件
    auditor.log_event(AuditEvent::new(
        AuditEventType::KeyCreated,
        "user1".to_string(),
        "key1".to_string(),
        None,
        true,
        1000,
        "Created new key".to_string()
    ));
    
    auditor.log_event(AuditEvent::new(
        AuditEventType::KeyAccessed,
        "user1".to_string(),
        "key1".to_string(),
        Some(Operation::Read),
        true,
        2000,
        "Accessed key".to_string()
    ));
    
    auditor.log_event(AuditEvent::new(
        AuditEventType::AuthenticationFailed,
        "user1".to_string(),
        "key1".to_string(),
        None,
        false,
        3000,
        "Wrong password".to_string()
    ));
    
    // 查询事件
    let user1_events = auditor.query_events(Some("user1"), None);
    assert_eq!(user1_events.len(), 3);
    
    let failed_events = auditor.get_failed_events();
    assert_eq!(failed_events.len(), 1);
    
    // 获取统计
    let stats = auditor.get_user_stats("user1");
    assert_eq!(stats.total_events, 3);
    assert_eq!(stats.successful_events, 2);
    assert_eq!(stats.failed_events, 1);
}

#[test]
fn test_complete_wallet_workflow() {
    // 1. 创建助记词
    let entropy = vec![0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0,
                      0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0];
    let mnemonic = Mnemonic::from_entropy(&entropy, Language::English).expect("mainnet: handle error");
    
    // 2. 派生密钥
    let seed = mnemonic.to_seed("");
    let master_key = ExtendedKey::from_seed(&seed).expect("mainnet: handle error");
    let path = DerivationPath::bip44(60, 0, 0, 0);
    let derived_key = master_key.derive_path(&path).expect("mainnet: handle error");
    
    // 3. 加密存储密钥
    let mut storage = SecureStorage::default();
    let password = "my_secure_password";
    storage.store_key("master_key".to_string(), derived_key.private_key(), password).expect("mainnet: handle error");
    
    // 4. 设置权限
    let mut controller = PermissionController::new();
    controller.add_user("owner".to_string(), PermissionLevel::Admin);
    
    // 5. 审计日志
    let mut auditor = SecurityAuditor::new(1000);
    auditor.log_event(AuditEvent::new(
        AuditEventType::KeyCreated,
        "owner".to_string(),
        "master_key".to_string(),
        None,
        true,
        1000,
        "Wallet initialized".to_string()
    ));
    
    // 6. 验证工作流
    assert!(storage.has_key("master_key"));
    assert!(controller.check_permission("owner", Operation::Export).is_ok());
    assert_eq!(auditor.get_all_events().len(), 1);
}

#[test]
fn test_multisig_with_security() {
    // 创建多签钱包
    let signers = vec![
        Signer::new("0x1111".to_string(), vec![1; 32]),
        Signer::new("0x2222".to_string(), vec![2; 32]),
    ];
    let config = MultisigConfig::m_of_n(signers.clone(), 2).expect("mainnet: handle error");
    let address = MultisigAddress::from_config(config, 1000);
    
    // 设置权限
    let mut controller = PermissionController::new();
    controller.add_user("0x1111".to_string(), PermissionLevel::ReadWrite);
    controller.add_user("0x2222".to_string(), PermissionLevel::ReadWrite);
    
    // 审计
    let mut auditor = SecurityAuditor::new(1000);
    
    // 创建交易
    let mut collector = SignatureCollector::new();
    collector.register_address(address.clone());
    let tx_id = collector.create_transaction(
        address.address().to_string(),
        vec![1, 2, 3],
        1000
    ).expect("mainnet: handle error");
    
    // 第一个签名者签名
    if controller.check_permission("0x1111", Operation::Sign).is_ok() {
        let sig1 = multisig::Signature::new(signers[0].address.clone(), vec![1], 1100);
        collector.add_signature(&tx_id, sig1, 1100).expect("mainnet: handle error");
        
        auditor.log_event(AuditEvent::new(
            AuditEventType::SignOperation,
            "0x1111".to_string(),
            tx_id.clone(),
            Some(Operation::Sign),
            true,
            1100,
            "Signed multisig transaction".to_string()
        ));
    }
    
    // 第二个签名者签名
    if controller.check_permission("0x2222", Operation::Sign).is_ok() {
        let sig2 = multisig::Signature::new(signers[1].address.clone(), vec![2], 1200);
        collector.add_signature(&tx_id, sig2, 1200).expect("mainnet: handle error");
        
        auditor.log_event(AuditEvent::new(
            AuditEventType::SignOperation,
            "0x2222".to_string(),
            tx_id.clone(),
            Some(Operation::Sign),
            true,
            1200,
            "Signed multisig transaction".to_string()
        ));
    }
    
    // 验证
    assert!(collector.can_broadcast(&tx_id).expect("mainnet: handle error"));
    assert_eq!(auditor.get_all_events().len(), 2);
}

#[test]
fn test_hardware_wallet_with_security() {
    // 创建设备管理器
    let mut manager = DeviceManager::new();
    
    // 权限控制
    let mut controller = PermissionController::new();
    controller.add_user("user1".to_string(), PermissionLevel::Admin);
    
    // 审计
    let mut auditor = SecurityAuditor::new(1000);
    
    // 连接硬件钱包（需要管理员权限）
    if controller.check_permission("user1", Operation::Write).is_ok() {
        manager.connect_ledger("ledger_001".to_string()).expect("mainnet: handle error");
        
        auditor.log_event(AuditEvent::new(
            AuditEventType::KeyAccessed,
            "user1".to_string(),
            "ledger_001".to_string(),
            Some(Operation::Write),
            true,
            1000,
            "Connected hardware wallet".to_string()
        ));
    }
    
    assert!(manager.is_connected("ledger_001"));
    assert_eq!(auditor.get_all_events().len(), 1);
}