// NAC跨链桥接智能合约
// 使用Charter语言编写（NAC原生智能合约语言）
// 版本: 1.0.0

contract NACBridge {
    // ========== 状态变量 ==========
    
    // 合约所有者（32字节地址）
    owner: Address;
    
    // 桥接是否暂停
    is_paused: bool;
    
    // 最小验证器签名数
    min_validator_signatures: u64;
    
    // 验证器映射（地址 -> 验证器信息）
    validators: mapping(Address => ValidatorInfo);
    
    // 活跃验证器列表
    active_validators: Address[];
    
    // 锁定资产映射（锁定ID -> 锁定信息）
    locks: mapping(Hash => LockInfo);
    
    // 解锁资产映射（解锁ID -> 解锁信息）
    unlocks: mapping(Hash => UnlockInfo);
    
    // 已处理的消息ID（防止重放攻击）
    processed_messages: mapping(Hash => bool);
    
    // 支持的链ID映射
    supported_chains: mapping(u64 => bool);
    
    // ========== 数据结构 ==========
    
    struct ValidatorInfo {
        address: Address,           // 验证器地址（32字节）
        stake_amount: u128,         // 质押金额
        reputation: u64,            // 声誉值
        is_active: bool,            // 是否活跃
    }
    
    struct LockInfo {
        lock_id: Hash,              // 锁定ID（48字节SHA3-384）
        asset_id: Hash,             // 资产ID（48字节）
        amount: u128,               // 锁定数量
        locker: Address,            // 锁定者地址（32字节）
        target_chain: u64,          // 目标链ID
        receiver: Address,          // 接收者地址（32字节）
        timestamp: u64,             // 锁定时间戳
        status: LockStatus,         // 锁定状态
    }
    
    struct UnlockInfo {
        unlock_id: Hash,            // 解锁ID（48字节）
        lock_id: Hash,              // 对应的锁定ID
        asset_id: Hash,             // 资产ID
        amount: u128,               // 解锁数量
        receiver: Address,          // 接收者地址
        timestamp: u64,             // 解锁时间戳
        status: UnlockStatus,       // 解锁状态
    }
    
    enum LockStatus {
        Pending,    // 待处理
        Confirmed,  // 已确认
        Minted,     // 已铸造
        Failed,     // 失败
    }
    
    enum UnlockStatus {
        Pending,    // 待处理
        Verified,   // 已验证
        Unlocked,   // 已解锁
        Failed,     // 失败
    }
    
    // ========== 事件 ==========
    
    event AssetLocked(
        lock_id: Hash,
        asset_id: Hash,
        amount: u128,
        locker: Address,
        target_chain: u64,
        receiver: Address,
        timestamp: u64
    );
    
    event AssetUnlocked(
        unlock_id: Hash,
        lock_id: Hash,
        asset_id: Hash,
        amount: u128,
        receiver: Address,
        timestamp: u64
    );
    
    event ValidatorRegistered(
        validator: Address,
        stake_amount: u128,
        timestamp: u64
    );
    
    event ValidatorUnregistered(
        validator: Address,
        timestamp: u64
    );
    
    event BridgePaused(timestamp: u64);
    event BridgeResumed(timestamp: u64);
    
    // ========== 修饰符 ==========
    
    modifier only_owner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }
    
    modifier when_not_paused() {
        require(!is_paused, "Bridge is paused");
        _;
    }
    
    modifier when_paused() {
        require(is_paused, "Bridge is not paused");
        _;
    }
    
    modifier only_validator() {
        require(validators[msg.sender].is_active, "Not an active validator");
        _;
    }
    
    // ========== 构造函数 ==========
    
    constructor(min_signatures: u64) {
        owner = msg.sender;
        is_paused = false;
        min_validator_signatures = min_signatures;
        
        // 添加NAC和以太坊为支持的链
        supported_chains[1] = true;  // NAC
        supported_chains[2] = true;  // Ethereum
    }
    
    // ========== 验证器管理函数 ==========
    
    /// 注册验证器
    function register_validator(stake_amount: u128) public payable {
        require(stake_amount >= 10000 * 10**18, "Insufficient stake amount");
        require(!validators[msg.sender].is_active, "Validator already registered");
        require(msg.value == stake_amount, "Stake amount mismatch");
        
        let validator = ValidatorInfo {
            address: msg.sender,
            stake_amount: stake_amount,
            reputation: 100,
            is_active: true,
        };
        
        validators[msg.sender] = validator;
        active_validators.push(msg.sender);
        
        emit ValidatorRegistered(msg.sender, stake_amount, block.timestamp);
    }
    
    /// 注销验证器
    function unregister_validator() public only_validator {
        let validator = validators[msg.sender];
        require(validator.is_active, "Validator not active");
        
        // 退还质押金额
        msg.sender.transfer(validator.stake_amount);
        
        // 从活跃列表中移除
        for (let i = 0; i < active_validators.length; i++) {
            if (active_validators[i] == msg.sender) {
                active_validators.remove(i);
                break;
            }
        }
        
        validators[msg.sender].is_active = false;
        
        emit ValidatorUnregistered(msg.sender, block.timestamp);
    }
    
    /// 获取活跃验证器数量
    function get_active_validator_count() public view returns (u64) {
        return active_validators.length;
    }
    
    // ========== 资产锁定函数 ==========
    
    /// 锁定资产
    function lock_asset(
        asset_id: Hash,
        amount: u128,
        target_chain: u64,
        receiver: Address
    ) public payable when_not_paused returns (Hash) {
        require(supported_chains[target_chain], "Target chain not supported");
        require(amount > 0, "Amount must be greater than 0");
        require(msg.value == amount, "Amount mismatch");
        
        // 生成锁定ID（使用SHA3-384）
        let lock_id = sha3_384(asset_id, msg.sender, block.timestamp);
        require(!locks[lock_id].lock_id, "Lock ID already exists");
        
        // 创建锁定信息
        let lock_info = LockInfo {
            lock_id: lock_id,
            asset_id: asset_id,
            amount: amount,
            locker: msg.sender,
            target_chain: target_chain,
            receiver: receiver,
            timestamp: block.timestamp,
            status: LockStatus::Pending,
        };
        
        locks[lock_id] = lock_info;
        
        emit AssetLocked(
            lock_id,
            asset_id,
            amount,
            msg.sender,
            target_chain,
            receiver,
            block.timestamp
        );
        
        return lock_id;
    }
    
    /// 更新锁定状态（仅验证器可调用）
    function update_lock_status(
        lock_id: Hash,
        new_status: LockStatus
    ) public only_validator {
        require(locks[lock_id].lock_id, "Lock not found");
        locks[lock_id].status = new_status;
    }
    
    /// 获取锁定信息
    function get_lock_info(lock_id: Hash) public view returns (LockInfo) {
        require(locks[lock_id].lock_id, "Lock not found");
        return locks[lock_id];
    }
    
    // ========== 资产解锁函数 ==========
    
    /// 解锁资产（需要验证器签名）
    function unlock_asset(
        lock_id: Hash,
        burn_tx_hash: Hash,
        signatures: Signature[]
    ) public when_not_paused returns (Hash) {
        require(locks[lock_id].lock_id, "Lock not found");
        require(locks[lock_id].status == LockStatus::Minted, "Lock not minted");
        require(signatures.length >= min_validator_signatures, "Insufficient signatures");
        
        // 验证签名
        let message_hash = sha3_384(lock_id, burn_tx_hash, block.timestamp);
        require(!processed_messages[message_hash], "Message already processed");
        
        let valid_signatures = 0;
        for (let i = 0; i < signatures.length; i++) {
            let signer = recover_signer(message_hash, signatures[i]);
            if (validators[signer].is_active) {
                valid_signatures += 1;
            }
        }
        
        require(valid_signatures >= min_validator_signatures, "Invalid signatures");
        
        // 生成解锁ID
        let unlock_id = sha3_384(lock_id, burn_tx_hash, block.timestamp);
        
        // 创建解锁信息
        let unlock_info = UnlockInfo {
            unlock_id: unlock_id,
            lock_id: lock_id,
            asset_id: locks[lock_id].asset_id,
            amount: locks[lock_id].amount,
            receiver: locks[lock_id].receiver,
            timestamp: block.timestamp,
            status: UnlockStatus::Pending,
        };
        
        unlocks[unlock_id] = unlock_info;
        processed_messages[message_hash] = true;
        
        // 转账给接收者
        locks[lock_id].receiver.transfer(locks[lock_id].amount);
        
        // 更新解锁状态
        unlocks[unlock_id].status = UnlockStatus::Unlocked;
        
        emit AssetUnlocked(
            unlock_id,
            lock_id,
            locks[lock_id].asset_id,
            locks[lock_id].amount,
            locks[lock_id].receiver,
            block.timestamp
        );
        
        return unlock_id;
    }
    
    /// 获取解锁信息
    function get_unlock_info(unlock_id: Hash) public view returns (UnlockInfo) {
        require(unlocks[unlock_id].unlock_id, "Unlock not found");
        return unlocks[unlock_id];
    }
    
    // ========== 管理函数 ==========
    
    /// 暂停桥接
    function pause() public only_owner when_not_paused {
        is_paused = true;
        emit BridgePaused(block.timestamp);
    }
    
    /// 恢复桥接
    function resume() public only_owner when_paused {
        is_paused = false;
        emit BridgeResumed(block.timestamp);
    }
    
    /// 添加支持的链
    function add_supported_chain(chain_id: u64) public only_owner {
        supported_chains[chain_id] = true;
    }
    
    /// 移除支持的链
    function remove_supported_chain(chain_id: u64) public only_owner {
        supported_chains[chain_id] = false;
    }
    
    /// 更新最小验证器签名数
    function update_min_signatures(new_min: u64) public only_owner {
        require(new_min > 0, "Min signatures must be greater than 0");
        min_validator_signatures = new_min;
    }
    
    /// 获取桥接状态
    function get_bridge_status() public view returns (bool, u64, u64) {
        return (is_paused, min_validator_signatures, active_validators.length);
    }
}