//! NAC SDK 集成测试
//!
//! 本测试文件包含NAC SDK所有层的集成测试

use nac_sdk::adapters::{NACAdapter, config::NACConfig};
use nac_sdk::primitives::{AssetCategory, Jurisdiction, ComplianceLevel};

/// 测试NAC适配器的创建
#[tokio::test]
async fn test_nac_adapter_creation() {
    let config = NACConfig::default();
    let result = NACAdapter::new(&config).await;
    
    // 注意: 这个测试需要实际的服务端点才能通过
    // 在没有服务端点的情况下，我们只验证配置是否正确
    assert!(config.l1.nvm_url.starts_with("http"));
}

/// 测试L0原生层 - 密钥对生成
#[test]
fn test_l0_keypair_generation() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let (private_key, public_key) = adapter.generate_keypair();
    
    assert_eq!(private_key.len(), 32);
    assert_eq!(public_key.len(), 32);
}

/// 测试L0原生层 - 地址生成
#[test]
fn test_l0_address_generation() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let (private_key, public_key) = adapter.generate_keypair();
    
    // 从公钥生成地址
    let address1 = adapter.address_from_public_key(&public_key).unwrap();
    assert_eq!(address1.len(), 32);
    
    // 从私钥生成地址
    let address2 = adapter.address_from_private_key(&private_key).unwrap();
    assert_eq!(address2.len(), 32);
    
    // 两个地址应该相同
    assert_eq!(address1, address2);
}

/// 测试L0原生层 - 地址验证
#[test]
fn test_l0_address_validation() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let (_, public_key) = adapter.generate_keypair();
    let address = adapter.address_from_public_key(&public_key).unwrap();
    
    // 有效地址
    assert!(adapter.validate_address(&address).unwrap());
    
    // 无效地址 - 长度不对
    let invalid_address = vec![0u8; 16];
    assert!(!adapter.validate_address(&invalid_address).unwrap());
}

/// 测试L0原生层 - SHA3-384哈希
#[test]
fn test_l0_hash_sha3_384() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let data = b"Hello, NAC!";
    let hash = adapter.hash_sha3_384(data);
    
    assert_eq!(hash.len(), 48);
    
    // 相同的数据应该产生相同的哈希
    let hash2 = adapter.hash_sha3_384(data);
    assert_eq!(hash, hash2);
    
    // 不同的数据应该产生不同的哈希
    let hash3 = adapter.hash_sha3_384(b"Different data");
    assert_ne!(hash, hash3);
}

/// 测试L0原生层 - Merkle树根计算
#[test]
fn test_l0_merkle_root() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    
    // 创建一些哈希
    let hash1 = adapter.hash_sha3_384(b"data1");
    let hash2 = adapter.hash_sha3_384(b"data2");
    let hash3 = adapter.hash_sha3_384(b"data3");
    let hash4 = adapter.hash_sha3_384(b"data4");
    
    let hashes = vec![hash1, hash2, hash3, hash4];
    let root = adapter.merkle_root(&hashes).unwrap();
    
    assert_eq!(root.len(), 48);
}

/// 测试L0原生层 - 签名和验证
#[test]
fn test_l0_sign_and_verify() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let (private_key, public_key) = adapter.generate_keypair();
    
    let message = b"This is a test message";
    
    // 签名
    let signature = adapter.sign(&private_key, message).unwrap();
    assert_eq!(signature.len(), 64);
    
    // 验证 - 应该成功
    assert!(adapter.verify(&public_key, message, &signature).unwrap());
    
    // 验证错误的消息 - 应该失败
    let wrong_message = b"This is a different message";
    assert!(!adapter.verify(&public_key, wrong_message, &signature).unwrap());
    
    // 验证错误的公钥 - 应该失败
    let (_, wrong_public_key) = adapter.generate_keypair();
    assert!(!adapter.verify(&wrong_public_key, message, &signature).unwrap());
}

/// 测试L0原生层 - 编码和解码地址
#[test]
fn test_l0_encode_decode_address() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let (_, public_key) = adapter.generate_keypair();
    let address = adapter.address_from_public_key(&public_key).unwrap();
    
    // 编码
    let encoded = adapter.encode_address(&address).unwrap();
    
    // 解码
    let decoded = adapter.decode_address(&encoded).unwrap();
    
    // 应该相同
    assert_eq!(address, decoded);
}

/// 测试L0原生层 - 编码和解码哈希
#[test]
fn test_l0_encode_decode_hash() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    let data = b"test data";
    let hash = adapter.hash_sha3_384(data);
    
    // 编码
    let encoded = adapter.encode_hash(&hash).unwrap();
    
    // 解码
    let decoded = adapter.decode_hash(&encoded).unwrap();
    
    // 应该相同
    assert_eq!(hash, decoded);
}

/// 测试L1协议层 - GNACS编码和解码
#[test]
fn test_l1_gnacs_encode_decode() {
    use nac_sdk::adapters::l1_protocol::L1ProtocolAdapter;
    use nac_sdk::adapters::config::L1Config;
    
    let config = L1Config::default();
    let adapter = L1ProtocolAdapter::new(&config);
    
    // 编码
    let gnacs_code = adapter.encode_gnacs(
        AssetCategory::RealEstate,
        Jurisdiction::US,
        ComplianceLevel::High
    ).unwrap();
    
    assert!(!gnacs_code.is_empty());
    
    // 解码
    let (category, jurisdiction, compliance) = adapter.decode_gnacs(&gnacs_code).unwrap();
    
    // 验证
    assert_eq!(category, AssetCategory::RealEstate);
    assert_eq!(jurisdiction, Jurisdiction::US);
    assert_eq!(compliance, ComplianceLevel::High);
}

/// 测试配置的序列化和反序列化
#[test]
fn test_config_serialization() {
    let config = NACConfig::default();
    
    // 序列化
    let json = serde_json::to_string(&config).unwrap();
    assert!(!json.is_empty());
    
    // 反序列化
    let deserialized: NACConfig = serde_json::from_str(&json).unwrap();
    
    // 验证
    assert_eq!(config.l1.nvm_url, deserialized.l1.nvm_url);
    assert_eq!(config.l2.governance_url, deserialized.l2.governance_url);
    assert_eq!(config.l3.ipfs_url, deserialized.l3.ipfs_url);
    assert_eq!(config.l4.compliance_url, deserialized.l4.compliance_url);
    assert_eq!(config.l5.wallet_url, deserialized.l5.wallet_url);
}

/// 测试完整的工作流程
#[test]
fn test_complete_workflow() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    use nac_sdk::adapters::l1_protocol::L1ProtocolAdapter;
    use nac_sdk::adapters::config::L1Config;
    
    // 1. 创建L0适配器
    let l0 = L0NativeAdapter::new();
    
    // 2. 生成密钥对
    let (private_key, public_key) = l0.generate_keypair();
    let address = l0.address_from_public_key(&public_key).unwrap();
    
    // 3. 准备资产数据
    let asset_data = b"Property at 123 Main St";
    
    // 4. 计算哈希
    let asset_hash = l0.hash_sha3_384(asset_data);
    
    // 5. 签名
    let signature = l0.sign(&private_key, asset_data).unwrap();
    
    // 6. 验证签名
    assert!(l0.verify(&public_key, asset_data, &signature).unwrap());
    
    // 7. GNACS编码
    let l1_config = L1Config::default();
    let l1 = L1ProtocolAdapter::new(&l1_config);
    let gnacs_code = l1.encode_gnacs(
        AssetCategory::RealEstate,
        Jurisdiction::US,
        ComplianceLevel::High
    ).unwrap();
    
    // 8. 验证所有数据
    assert_eq!(address.len(), 32);
    assert_eq!(asset_hash.len(), 48);
    assert_eq!(signature.len(), 64);
    assert!(!gnacs_code.is_empty());
}

/// 测试错误处理
#[test]
fn test_error_handling() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    
    let adapter = L0NativeAdapter::new();
    
    // 测试无效的私钥
    let invalid_private_key = vec![0u8; 16]; // 长度不对
    let message = b"test";
    let result = adapter.sign(&invalid_private_key, message);
    assert!(result.is_err());
    
    // 测试无效的地址
    let invalid_address = vec![0u8; 16]; // 长度不对
    let result = adapter.validate_address(&invalid_address);
    assert!(result.is_ok());
    assert!(!result.unwrap());
}

/// 测试并发安全性
#[tokio::test]
async fn test_concurrent_operations() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    use std::sync::Arc;
    
    let adapter = Arc::new(L0NativeAdapter::new());
    let mut handles = vec![];
    
    // 并发生成100个密钥对
    for _ in 0..100 {
        let adapter_clone = Arc::clone(&adapter);
        let handle = tokio::spawn(async move {
            let (private_key, public_key) = adapter_clone.generate_keypair();
            let address = adapter_clone.address_from_public_key(&public_key).unwrap();
            (private_key, public_key, address)
        });
        handles.push(handle);
    }
    
    // 等待所有任务完成
    let mut addresses = vec![];
    for handle in handles {
        let (_, _, address) = handle.await.unwrap();
        addresses.push(address);
    }
    
    // 验证所有地址都是唯一的
    addresses.sort();
    addresses.dedup();
    assert_eq!(addresses.len(), 100);
}

/// 测试性能 - 密钥对生成
#[test]
fn test_performance_keypair_generation() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    use std::time::Instant;
    
    let adapter = L0NativeAdapter::new();
    let start = Instant::now();
    
    // 生成1000个密钥对
    for _ in 0..1000 {
        let _ = adapter.generate_keypair();
    }
    
    let duration = start.elapsed();
    println!("生成1000个密钥对耗时: {:?}", duration);
    
    // 平均每个密钥对应该在10ms以内
    assert!(duration.as_millis() < 10000);
}

/// 测试性能 - 哈希计算
#[test]
fn test_performance_hashing() {
    use nac_sdk::adapters::l0_native::L0NativeAdapter;
    use std::time::Instant;
    
    let adapter = L0NativeAdapter::new();
    let data = vec![0u8; 1024]; // 1KB数据
    let start = Instant::now();
    
    // 计算10000次哈希
    for _ in 0..10000 {
        let _ = adapter.hash_sha3_384(&data);
    }
    
    let duration = start.elapsed();
    println!("计算10000次哈希耗时: {:?}", duration);
    
    // 平均每次哈希应该在1ms以内
    assert!(duration.as_millis() < 10000);
}