///! ACC-20增强版完整使用示例
///!
///! 本示例展示如何使用ACC-20增强版和ACC-20C兼容层

module acc20_enhanced_example;

use acc::acc20_enhanced::{ACC20Enhanced, KYCLevel, AMLStatus, ComplianceStatus};
use acc::acc20c::{ACC20CWrapper};
use asset::gnacs::{GNACSCode, AssetCategory, Jurisdiction, ComplianceLevel, RiskLevel};
use sovereignty::types::{SovereigntyType};

/// 示例1：创建上海办公室股权资产
fn example1_create_shanghai_office_share() {
    // 1. 创建GNACS编码
    let gnacs = GNACSCode::new(
        AssetCategory::Equity,          // 股权类资产
        1,                               // 子类别：商业地产股权
        Jurisdiction::CN,                // 中国司法辖区
        ComplianceLevel::High,           // 高合规要求
        RiskLevel::Medium,               // 中等风险
    );
    
    // 2. 创建ACC-20增强版资产
    let mut asset = ACC20Enhanced::new(
        "Shanghai Office Share".to_string(),
        "SH-OFFICE".to_string(),
        18,                              // 18位小数
        gnacs,
        SovereigntyType::A0,             // 绝对所有权
    ).unwrap();
    
    // 3. 设置合规状态为已批准
    asset.compliance_status = ComplianceStatus::Approved;
    
    // 4. 铸造资产（总共100万股）
    let owner = Address::from("0x1234...");
    asset.mint(owner, 1_000_000 * 10^18, &context).unwrap();
    
    println!("✅ 创建上海办公室股权资产成功！");
    println!("   资产名称: {}", asset.name);
    println!("   资产符号: {}", asset.symbol);
    println!("   GNACS编码: {}", asset.gnacs_code.to_hex());
    println!("   主权类型: {:?}", asset.sovereignty_type);
    println!("   总供应量: {}", asset.total_supply);
}

/// 示例2：转账（包含合规检查）
fn example2_transfer_with_compliance() {
    let mut asset = create_test_asset();
    
    let alice = Address::from("0xalice...");
    let bob = Address::from("0xbob...");
    
    // 1. 设置KYC状态
    let mut context = TransactionContext::new();
    context.kyc_status.insert(alice, KYCLevel::Advanced);
    context.kyc_status.insert(bob, KYCLevel::Advanced);
    
    // 2. 设置AML状态
    context.aml_status.insert(alice, AMLStatus::Clear);
    context.aml_status.insert(bob, AMLStatus::Clear);
    
    // 3. 执行转账
    asset.transfer(
        &alice,
        &bob,
        10_000 * 10^18,  // 转账10,000股
        &context,
    ).unwrap();
    
    println!("✅ 转账成功！");
    println!("   从: {}", alice);
    println!("   到: {}", bob);
    println!("   数量: 10,000股");
}

/// 示例3：主权规则验证
fn example3_sovereignty_validation() {
    // 创建使用权资产（B1主权）
    let gnacs = GNACSCode::new(
        AssetCategory::RealEstate,
        2,  // 住宅地产
        Jurisdiction::US,
        ComplianceLevel::High,
        RiskLevel::Low,
    );
    
    let mut asset = ACC20Enhanced::new(
        "Manhattan Apartment Usage Right".to_string(),
        "MAN-APT-B1".to_string(),
        18,
        gnacs,
        SovereigntyType::B1,  // 使用权（有期限）
    ).unwrap();
    
    // 设置使用权期限（10年）
    asset.sovereignty_rules.set_expiry_date(
        block::timestamp() + 10 * 365 * 24 * 60 * 60
    );
    
    // 尝试转账（B1主权可以转让）
    let result = asset.transfer(&alice, &bob, 1000, &context);
    
    if result.is_ok() {
        println!("✅ 使用权转让成功！");
    } else {
        println!("❌ 使用权转让失败: {:?}", result.err());
    }
}

/// 示例4：ACC-20C包装（跨链到以太坊）
fn example4_wrap_to_ethereum() {
    // 1. 创建ACC-20增强版资产
    let mut asset = create_test_asset();
    
    // 2. 创建ACC-20C包装器
    let mut wrapper = ACC20CWrapper::new(
        asset.contract_address,                    // NAC链上的ACC-20合约
        EthAddress::from("0xeth_contract..."),     // 以太坊链上的ERC-721合约
        asset.contract_address,                     // 底层资产
    );
    
    // 3. 用户包装资产
    let user = Address::from("0xuser...");
    let amount = 1000 * 10^18;  // 包装1000股
    
    let token_id = wrapper.wrap(user, amount, &asset).unwrap();
    
    println!("✅ 资产包装成功！");
    println!("   TokenId: {}", token_id);
    println!("   包装数量: 1000股");
    println!("   现在可以在OpenSea等平台交易");
    
    // 4. 生成ERC-721元数据
    let metadata = wrapper.generate_metadata(token_id).unwrap();
    
    println!("\n📄 ERC-721元数据:");
    println!("   名称: {}", metadata.name);
    println!("   描述: {}", metadata.description);
    println!("   GNACS编码: {}", metadata.attributes.get("GNACS Code"));
    println!("   主权类型: {}", metadata.attributes.get("Sovereignty Type"));
}

/// 示例5：解包装（从以太坊回到NAC）
fn example5_unwrap_from_ethereum() {
    let mut wrapper = create_test_wrapper();
    let token_id = 1;
    
    // 用户从以太坊解包装回NAC
    let eth_owner = EthAddress::from("0xeth_user...");
    let nac_recipient = Address::from("0xnac_user...");
    
    let net_amount = wrapper.unwrap(
        token_id,
        eth_owner,
        nac_recipient,
        &asset,
    ).unwrap();
    
    println!("✅ 资产解包装成功！");
    println!("   TokenId: {}", token_id);
    println!("   接收数量: {} (扣除手续费后)", net_amount);
    println!("   资产已回到NAC链");
}

/// 示例6：冻结资产（合规场景）
fn example6_freeze_asset() {
    let mut asset = create_test_asset();
    
    let suspicious_account = Address::from("0xsuspicious...");
    
    // 合规官冻结可疑账户
    asset.freeze_account(suspicious_account).unwrap();
    
    println!("✅ 账户已冻结！");
    println!("   账户: {}", suspicious_account);
    println!("   原因: AML风险检测");
    
    // 尝试从冻结账户转账（会失败）
    let result = asset.transfer(
        &suspicious_account,
        &other_account,
        1000,
        &context,
    );
    
    assert!(result.is_err());
    println!("❌ 冻结账户无法转账（预期行为）");
}

/// 示例7：估值更新
fn example7_valuation_update() {
    let mut asset = create_test_asset();
    
    let valuator = Address::from("0xvaluator...");
    let new_valuation = 5_000_000 * 10^18;  // 500万XTZH
    let report_hash = Hash::from("0xreport...");
    
    // 估值师更新资产估值
    asset.update_valuation(
        new_valuation,
        valuator,
        report_hash,
    ).unwrap();
    
    println!("✅ 估值更新成功！");
    println!("   新估值: 500万XTZH");
    println!("   估值师: {}", valuator);
    println!("   报告哈希: {}", report_hash);
}

/// 示例8：审计追踪查询
fn example8_audit_trail() {
    let asset = create_test_asset();
    
    // 查询最近10条审计记录
    let recent_audits = asset.audit_trail.iter().rev().take(10);
    
    println!("📋 最近10条审计记录:");
    for (i, record) in recent_audits.enumerate() {
        println!("\n{}. 操作类型: {:?}", i + 1, record.operation);
        println!("   操作者: {}", record.operator);
        if let Some(target) = record.target {
            println!("   目标: {}", target);
        }
        if let Some(amount) = record.amount {
            println!("   数量: {}", amount);
        }
        println!("   时间: {}", record.timestamp);
        println!("   交易哈希: {}", record.tx_hash);
    }
}

/// 示例9：碎片化资产
fn example9_fragmentation() {
    let mut asset = create_test_asset();
    
    // 启用碎片化
    asset.is_fragmentable = true;
    asset.fragmentation_config = Some(FragmentationConfig {
        min_fragment_size: 1 * 10^18,  // 最小1股
        total_fragments: 1000,          // 分成1000份
        fragment_pool_address: Address::from("0xpool..."),
        allow_recomposition: true,      // 允许重组
    });
    
    println!("✅ 碎片化配置成功！");
    println!("   最小碎片: 1股");
    println!("   总碎片数: 1000份");
    println!("   允许重组: 是");
}

/// 示例10：跨链支持
fn example10_cross_chain() {
    let mut asset = create_test_asset();
    
    // 启用跨链
    asset.cross_chain_enabled = true;
    
    // 添加支持的链
    asset.supported_chains.push(ChainId(1));   // 以太坊主网
    asset.supported_chains.push(ChainId(56));  // BSC
    asset.supported_chains.push(ChainId(137)); // Polygon
    
    // 设置跨链合约地址
    asset.cross_chain_contracts.insert(
        ChainId(1),
        Address::from("0xeth_contract...")
    );
    asset.cross_chain_contracts.insert(
        ChainId(56),
        Address::from("0xbsc_contract...")
    );
    
    println!("✅ 跨链配置成功！");
    println!("   支持的链: 以太坊、BSC、Polygon");
    println!("   资产可在多链流通");
}

// ========== 辅助函数 ==========

fn create_test_asset() -> ACC20Enhanced {
    let gnacs = GNACSCode::new(
        AssetCategory::Equity,
        1,
        Jurisdiction::CN,
        ComplianceLevel::High,
        RiskLevel::Medium,
    );
    
    let mut asset = ACC20Enhanced::new(
        "Test Asset".to_string(),
        "TEST".to_string(),
        18,
        gnacs,
        SovereigntyType::A0,
    ).unwrap();
    
    asset.compliance_status = ComplianceStatus::Approved;
    
    return asset;
}

fn create_test_wrapper() -> ACC20CWrapper {
    let asset = create_test_asset();
    
    return ACC20CWrapper::new(
        asset.contract_address,
        EthAddress::from("0xeth..."),
        asset.contract_address,
    );
}

// ========== 主函数 ==========

fn main() {
    println!("🚀 ACC-20增强版完整示例\n");
    
    println!("=== 示例1: 创建上海办公室股权资产 ===");
    example1_create_shanghai_office_share();
    
    println!("\n=== 示例2: 转账（包含合规检查） ===");
    example2_transfer_with_compliance();
    
    println!("\n=== 示例3: 主权规则验证 ===");
    example3_sovereignty_validation();
    
    println!("\n=== 示例4: ACC-20C包装（跨链到以太坊） ===");
    example4_wrap_to_ethereum();
    
    println!("\n=== 示例5: 解包装（从以太坊回到NAC） ===");
    example5_unwrap_from_ethereum();
    
    println!("\n=== 示例6: 冻结资产（合规场景） ===");
    example6_freeze_asset();
    
    println!("\n=== 示例7: 估值更新 ===");
    example7_valuation_update();
    
    println!("\n=== 示例8: 审计追踪查询 ===");
    example8_audit_trail();
    
    println!("\n=== 示例9: 碎片化资产 ===");
    example9_fragmentation();
    
    println!("\n=== 示例10: 跨链支持 ===");
    example10_cross_chain();
    
    println!("\n✅ 所有示例执行完成！");
}