//! acc_xtzh - NAC 原生协议实现
//! 从 acc_remaining_protocols.rs 提取
use crate::primitives::{Address, Hash, Timestamp};
    use serde::{Deserialize, Serialize};
    use std::collections::HashMap;

    #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
    pub enum ACCXTZHError {
        InsufficientBalance { holder: Address, available: u128, requested: u128 },
        InsufficientReserve { required: u128, available: u128 },
        InvalidConstitutionalReceipt,
        Unauthorized(Address),
        SDRPegViolation { current_rate: u128, min_rate: u128, max_rate: u128 },
        GoldReserveInsufficient { required_ratio: u8, actual_ratio: u8 },
    }
    impl std::fmt::Display for ACCXTZHError {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                Self::InsufficientBalance { holder, available, requested } => write!(f, "余额不足 {}: 可用 {}，请求 {}", holder.to_hex(), available, requested),
                Self::InsufficientReserve { required, available } => write!(f, "储备不足: 需要 {}，可用 {}", required, available),
                Self::InvalidConstitutionalReceipt => write!(f, "宪法收据无效"),
                Self::Unauthorized(a) => write!(f, "未授权: {}", a.to_hex()),
                Self::SDRPegViolation { current_rate, min_rate, max_rate } => write!(f, "SDR 锚定偏离: 当前 {}，允许范围 [{}, {}]", current_rate, min_rate, max_rate),
                Self::GoldReserveInsufficient { required_ratio, actual_ratio } => write!(f, "黄金储备不足: 要求 {}%，实际 {}%", required_ratio, actual_ratio),
            }
        }
    }

    #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
    pub enum ReserveAssetType { Gold, USD, EUR, GBP, JPY, CNY, NACNative }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct ReserveAsset {
        pub asset_type: ReserveAssetType,
        pub amount: u128,
        /// 权重（基点，10000=100%）
        pub weight_bps: u16,
        pub last_updated: Timestamp,
    }

    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub enum XTZHProtocolEvent {
        Minted { recipient: Address, amount: u128, constitutional_receipt: Hash, timestamp: Timestamp },
        Burned { holder: Address, amount: u128, constitutional_receipt: Hash, timestamp: Timestamp },
        Transferred { from: Address, to: Address, amount: u128, timestamp: Timestamp },
        ReserveRebalanced { old_gold_ratio: u8, new_gold_ratio: u8, timestamp: Timestamp },
        SDRRateUpdated { old_rate: u128, new_rate: u128, timestamp: Timestamp },
    }

    /// XTZH 稳定币协议
    /// UID: nac.acc.XTZHStablecoinProtocol.v1
    /// SDR 锚定 + 黄金储备保障
    #[derive(Debug, Clone, Serialize, Deserialize)]
    pub struct XTZHStablecoinProtocol {
        pub protocol_uid: String,
        pub lens_protocol_vector: String,
        pub total_supply: u128,
        /// 持仓（address -> 余额，精度18位）
        pub holdings: HashMap<Address, u128>,
        /// 储备资产
        pub reserve_assets: Vec<ReserveAsset>,
        /// SDR 锚定汇率（XTZH/SDR，精度18位，1 XTZH = 1 SDR）
        pub sdr_peg_rate: u128,
        /// SDR 汇率允许偏差（基点，默认200=2%）
        pub sdr_tolerance_bps: u16,
        /// 黄金储备最低比例（百分比，默认40）
        pub min_gold_reserve_ratio: u8,
        /// 当前黄金储备比例
        pub current_gold_reserve_ratio: u8,
        pub pending_events: Vec<XTZHProtocolEvent>,
        pub created_at: Timestamp,
        pub updated_at: Timestamp,
    }
    impl XTZHStablecoinProtocol {
        pub fn new(sdr_peg_rate: u128, min_gold_reserve_ratio: u8) -> Self {
            Self {
                protocol_uid: "nac.acc.XTZHStablecoinProtocol.v1".to_string(),
                lens_protocol_vector: "ACC-XTZH".to_string(),
                total_supply: 0,
                holdings: HashMap::new(),
                reserve_assets: Vec::new(),
                sdr_peg_rate,
                sdr_tolerance_bps: 200,
                min_gold_reserve_ratio,
                current_gold_reserve_ratio: 0,
                pending_events: Vec::new(),
                created_at: Timestamp::now(),
                updated_at: Timestamp::now(),
            }
        }
        pub fn mint(
            &mut self, recipient: Address, amount: u128,
            constitutional_receipt: Hash, timestamp: Timestamp,
        ) -> Result<(), ACCXTZHError> {
            if constitutional_receipt.is_zero() { return Err(ACCXTZHError::InvalidConstitutionalReceipt); }
            if self.current_gold_reserve_ratio < self.min_gold_reserve_ratio {
                return Err(ACCXTZHError::GoldReserveInsufficient {
                    required_ratio: self.min_gold_reserve_ratio,
                    actual_ratio: self.current_gold_reserve_ratio,
                });
            }
            *self.holdings.entry(recipient.clone()).or_insert(0) += amount;
            self.total_supply = self.total_supply.saturating_add(amount);
            self.pending_events.push(XTZHProtocolEvent::Minted { recipient, amount, constitutional_receipt, timestamp });
            self.updated_at = Timestamp::now();
            Ok(())
        }
        pub fn burn(
            &mut self, holder: Address, amount: u128,
            constitutional_receipt: Hash, timestamp: Timestamp,
        ) -> Result<(), ACCXTZHError> {
            if constitutional_receipt.is_zero() { return Err(ACCXTZHError::InvalidConstitutionalReceipt); }
            let balance = self.holdings.get(&holder).copied().unwrap_or(0);
            if balance < amount {
                return Err(ACCXTZHError::InsufficientBalance { holder: holder.clone(), available: balance, requested: amount });
            }
            *self.holdings.get_mut(&holder).unwrap() -= amount;
            self.total_supply = self.total_supply.saturating_sub(amount);
            self.pending_events.push(XTZHProtocolEvent::Burned { holder, amount, constitutional_receipt, timestamp });
            self.updated_at = Timestamp::now();
            Ok(())
        }
        pub fn transfer(
            &mut self, from: Address, to: Address, amount: u128, timestamp: Timestamp,
        ) -> Result<(), ACCXTZHError> {
            let balance = self.holdings.get(&from).copied().unwrap_or(0);
            if balance < amount {
                return Err(ACCXTZHError::InsufficientBalance { holder: from.clone(), available: balance, requested: amount });
            }
            *self.holdings.get_mut(&from).unwrap() -= amount;
            *self.holdings.entry(to.clone()).or_insert(0) += amount;
            self.pending_events.push(XTZHProtocolEvent::Transferred { from, to, amount, timestamp });
            Ok(())
        }
        pub fn update_sdr_rate(
            &mut self, new_rate: u128, constitutional_receipt: Hash, timestamp: Timestamp,
        ) -> Result<(), ACCXTZHError> {
            if constitutional_receipt.is_zero() { return Err(ACCXTZHError::InvalidConstitutionalReceipt); }
            let tolerance = self.sdr_peg_rate * self.sdr_tolerance_bps as u128 / 10000;
            let min_rate = self.sdr_peg_rate.saturating_sub(tolerance);
            let max_rate = self.sdr_peg_rate.saturating_add(tolerance);
            if new_rate < min_rate || new_rate > max_rate {
                return Err(ACCXTZHError::SDRPegViolation { current_rate: new_rate, min_rate, max_rate });
            }
            let old_rate = self.sdr_peg_rate;
            self.sdr_peg_rate = new_rate;
            self.pending_events.push(XTZHProtocolEvent::SDRRateUpdated { old_rate, new_rate, timestamp });
            Ok(())
        }
        pub fn update_reserve(
            &mut self, asset_type: ReserveAssetType, amount: u128, weight_bps: u16, timestamp: Timestamp,
        ) {
            if let Some(r) = self.reserve_assets.iter_mut().find(|r| r.asset_type == asset_type) {
                r.amount = amount;
                r.weight_bps = weight_bps;
                r.last_updated = timestamp;
            } else {
                self.reserve_assets.push(ReserveAsset { asset_type, amount, weight_bps, last_updated: timestamp });
            }
            self.recalculate_gold_ratio();
        }
        fn recalculate_gold_ratio(&mut self) {
            let total_weight: u16 = self.reserve_assets.iter().map(|r| r.weight_bps).sum();
            if total_weight == 0 { self.current_gold_reserve_ratio = 0; return; }
            let gold_weight: u16 = self.reserve_assets.iter()
                .filter(|r| r.asset_type == ReserveAssetType::Gold)
                .map(|r| r.weight_bps).sum();
            self.current_gold_reserve_ratio = (gold_weight as u32 * 100 / total_weight as u32) as u8;
        }
        pub fn balance_of(&self, address: &Address) -> u128 { self.holdings.get(address).copied().unwrap_or(0) }
        pub fn drain_pending_events(&mut self) -> Vec<XTZHProtocolEvent> { std::mem::take(&mut self.pending_events) }
    }