//! ACC-721协议集成测试
//!
//! 测试ACC-721唯一资产证书协议的完整功能

use nac_sdk::client::NRPC3Client;
use nac_sdk::protocols::ACC721;
use nac_sdk::error::{NACError, Result};
use nac_udm::primitives::{Address, Hash, Timestamp};
use nac_udm::l1_protocol::acc::acc721::{AssetId, AssetValuation};

/// 测试ACC-721基本功能
#[tokio::test]
#[ignore] // 需要实际的NAC节点才能运行
async fn test_acc721_mint_and_transfer() -> Result<()> {
    // 创建客户端
    let client = NRPC3Client::new("https://rpc.newassetchain.io");
    let acc721 = ACC721::new(client);
    
    // 测试地址
    let certificate_address = Address::from_hex("0x12345678901234567890123456789012345678901234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let owner_address = Address::from_hex("0x22345678901234567890123456789012345678902234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let recipient_address = Address::from_hex("0x32345678901234567890123456789012345678903234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let custodian_address = Address::from_hex("0x42345678901234567890123456789012345678904234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let insurer_address = Address::from_hex("0x52345678901234567890123456789012345678905234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    
    // 测试数据
    let asset_id: AssetId = 1;
    let metadata_uri = "ipfs://QmTest123456789".to_string();
    let physical_fingerprint = Hash::sha3_384(b"physical_fingerprint_data");
    let legal_document_hash = Hash::sha3_384(b"legal_document_data");
    let insurance_coverage = 1_000_000_000_000_000_000u128; // 1 XTZH
    let insurance_expiry = Timestamp::from_secs(Timestamp::now().as_secs() + 365 * 24 * 3600); // 1年后
    
    // 1. 铸造资产
    let asset_dna = acc721.mint_asset(
        &certificate_address,
        &owner_address,
        asset_id,
        metadata_uri.clone(),
        physical_fingerprint,
        legal_document_hash,
        custodian_address,
        insurer_address,
        insurance_coverage,
        insurance_expiry,
    ).await?;
    
    println!("Asset DNA: {:?}", asset_dna);
    assert_eq!(asset_dna.physical_fingerprint, physical_fingerprint);
    assert_eq!(asset_dna.legal_document_hash, legal_document_hash);
    
    // 2. 查询资产持有者
    let holder = acc721.get_asset_holder(&certificate_address, asset_id).await?;
    assert_eq!(holder, owner_address);
    
    // 3. 查询资产元数据
    let metadata = acc721.get_asset_metadata(&certificate_address, asset_id).await?;
    assert_eq!(metadata, metadata_uri);
    
    // 4. 查询托管信息
    let custody_info = acc721.get_custody_info(&certificate_address, asset_id).await?;
    assert_eq!(custody_info.custodian, custodian_address);
    assert!(custody_info.is_active);
    
    // 5. 查询保险信息
    let insurance_info = acc721.get_insurance_info(&certificate_address, asset_id).await?;
    assert_eq!(insurance_info.insurer, insurer_address);
    assert_eq!(insurance_info.coverage_xtzh, insurance_coverage);
    
    // 6. 转移资产
    let receipt_hash = acc721.transfer_asset(
        &certificate_address,
        &owner_address,
        &recipient_address,
        asset_id,
    ).await?;
    
    println!("Constitutional Receipt: {}", receipt_hash.to_hex());
    
    // 7. 验证新持有者
    let new_holder = acc721.get_asset_holder(&certificate_address, asset_id).await?;
    assert_eq!(new_holder, recipient_address);
    
    Ok(())
}

/// 测试ACC-721资产估值功能
#[tokio::test]
#[ignore] // 需要实际的NAC节点才能运行
async fn test_acc721_valuation() -> Result<()> {
    let client = NRPC3Client::new("https://rpc.newassetchain.io");
    let acc721 = ACC721::new(client);
    
    let certificate_address = Address::from_hex("0x12345678901234567890123456789012345678901234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let asset_id: AssetId = 1;
    let valuation_provider = Address::from_hex("0x62345678901234567890123456789012345678906234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    
    // 创建估值
    let valuation = AssetValuation {
        value_xtzh: 5_000_000_000_000_000_000u128, // 5 XTZH
        valuation_provider,
        valued_at: Timestamp::now(),
        validity_period: 30 * 24 * 3600, // 30天
    };
    
    // 更新估值
    acc721.update_valuation(&certificate_address, asset_id, valuation.clone()).await?;
    
    // 查询估值
    let retrieved_valuation = acc721.get_asset_valuation(&certificate_address, asset_id).await?;
    assert_eq!(retrieved_valuation.value_xtzh, valuation.value_xtzh);
    assert_eq!(retrieved_valuation.valuation_provider, valuation.valuation_provider);
    
    Ok(())
}

/// 测试ACC-721资产碎片化功能
#[tokio::test]
#[ignore] // 需要实际的NAC节点才能运行
async fn test_acc721_fragmentization() -> Result<()> {
    let client = NRPC3Client::new("https://rpc.newassetchain.io");
    let acc721 = ACC721::new(client);
    
    let certificate_address = Address::from_hex("0x12345678901234567890123456789012345678901234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let owner_address = Address::from_hex("0x22345678901234567890123456789012345678902234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let asset_id: AssetId = 1;
    
    // 碎片化参数
    let fragment_count = 1000u64;
    let fragment_price = 5_000_000_000_000_000u128; // 0.005 XTZH per fragment
    
    // 执行碎片化
    let pool = acc721.fragmentize_asset(
        &certificate_address,
        &owner_address,
        asset_id,
        fragment_count,
        fragment_price,
    ).await?;
    
    println!("Fragmentation Pool: {:?}", pool);
    assert_eq!(pool.total_fragments, fragment_count);
    assert_eq!(pool.fragment_price_xtzh, fragment_price);
    assert!(pool.is_recomposable);
    
    Ok(())
}

/// 测试ACC-721授权和销毁功能
#[tokio::test]
#[ignore] // 需要实际的NAC节点才能运行
async fn test_acc721_approve_and_burn() -> Result<()> {
    let client = NRPC3Client::new("https://rpc.newassetchain.io");
    let acc721 = ACC721::new(client);
    
    let certificate_address = Address::from_hex("0x12345678901234567890123456789012345678901234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let owner_address = Address::from_hex("0x22345678901234567890123456789012345678902234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let approved_address = Address::from_hex("0x32345678901234567890123456789012345678903234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let asset_id: AssetId = 1;
    
    // 授权
    acc721.approve_asset(
        &certificate_address,
        &owner_address,
        &approved_address,
        asset_id,
    ).await?;
    
    println!("Asset approved successfully");
    
    // 销毁资产
    acc721.burn_asset(
        &certificate_address,
        &owner_address,
        asset_id,
    ).await?;
    
    println!("Asset burned successfully");
    
    Ok(())
}

/// 测试ACC-721资产DNA查询
#[tokio::test]
#[ignore] // 需要实际的NAC节点才能运行
async fn test_acc721_asset_dna() -> Result<()> {
    let client = NRPC3Client::new("https://rpc.newassetchain.io");
    let acc721 = ACC721::new(client);
    
    let certificate_address = Address::from_hex("0x12345678901234567890123456789012345678901234567890123456789012345678901234567890")
        .map_err(|e| NACError::InvalidAddress(e))?;
    let asset_id: AssetId = 1;
    
    // 查询资产DNA
    let asset_dna = acc721.get_asset_dna(&certificate_address, asset_id).await?;
    
    println!("Asset DNA Hash: {}", asset_dna.dna_hash.to_hex());
    println!("Physical Fingerprint: {}", asset_dna.physical_fingerprint.to_hex());
    println!("Legal Document Hash: {}", asset_dna.legal_document_hash.to_hex());
    println!("Generated At: {:?}", asset_dna.generated_at);
    
    // 验证DNA哈希的唯一性
    assert_ne!(asset_dna.dna_hash.as_bytes(), &[0u8; 48]);
    
    Ok(())
}

/// 单元测试：测试ACC-721接口创建
#[test]
fn test_acc721_interface_creation() {
    let client = NRPC3Client::new("https://rpc.newassetchain.io");
    let _acc721 = ACC721::new(client);
    // 接口创建成功
}

/// 单元测试：测试地址解析
#[test]
fn test_address_parsing() {
    let addr_str = "0x12345678901234567890123456789012345678901234567890123456789012345678901234567890";
    let addr = Address::from_hex(addr_str).unwrap();
    assert_eq!(addr.to_hex(), addr_str);
}

/// 单元测试：测试哈希计算
#[test]
fn test_hash_calculation() {
    let data = b"test_data";
    let hash = Hash::sha3_384(data);
    
    // SHA3-384应该产生48字节的哈希
    assert_eq!(hash.as_bytes().len(), 48);
    
    // 相同数据应该产生相同的哈希
    let hash2 = Hash::sha3_384(data);
    assert_eq!(hash, hash2);
    
    // 不同数据应该产生不同的哈希
    let hash3 = Hash::sha3_384(b"different_data");
    assert_ne!(hash, hash3);
}

/// 单元测试：测试时间戳
#[test]
fn test_timestamp() {
    let now = Timestamp::now();
    let future = Timestamp::from_secs(now.as_secs() + 3600);
    
    assert!(future.as_secs() > now.as_secs());
    
    // 测试过期检查
    let past = Timestamp::from_secs(now.as_secs() - 3600);
    assert!(past.is_expired(1800)); // 30分钟有效期，应该已过期
}