//! NAC ACC-1594 Protocol Implementation
//! NAC ACC-1594协议实现 - 基于GNACS数字基因的核心收益与资产操作协议
//!
//! ACC-1594在继承ACC-1400的基础上，增加了：
//! 1. 资产生命周期操作（发行、赎回）
//! 2. 收益分配系统（分红、领取）
//! 3. GNACS收益扩展编码（80位）
//! 4. 宪法收据强制验证
//! 5. AI驱动的收益计算

pub mod error;
pub mod types;

pub use error::{Acc1594Error, Result};
pub use types::*;

use nac_acc_1400::Acc1400;
use nac_acc_1410::Acc1410;
use std::collections::HashMap;

/// ACC-1594核心收益与资产操作协议
#[derive(Debug)]
pub struct Acc1594 {
    /// 基础ACC-1400实例
    #[allow(dead_code)]
    base: Acc1400,
    
    /// ACC-1410实例（用于访问底层方法）
    base1410: Acc1410,
    
    /// 资产GNACS（含收益扩展）
    asset_gnacs: FullDividendGNACS,
    
    /// 是否可发行
    is_issuable: bool,
    
    /// 发行上限
    issuance_limit: Option<u64>,
    
    /// 发行记录
    issuance_records: Vec<IssuanceRecord>,
    
    /// 赎回记录
    redemption_records: Vec<RedemptionRecord>,
    
    /// 分红记录（按分区）
    dividend_records: HashMap<String, Vec<DividendRecord>>,
    
    /// 可领取分红（账户 -> 分区 -> 金额）
    claimable_dividends: HashMap<String, HashMap<String, u64>>,
    
    /// 账户持有开始时间（用于检查最低持有期）
    holding_start_time: HashMap<String, u64>,
    
    /// 授权角色（角色名 -> 地址列表）
    authorized_roles: HashMap<String, Vec<String>>,
}

impl Acc1594 {
    /// 创建新的ACC-1594实例
    pub fn new(asset_gnacs: FullDividendGNACS) -> Self {
        Self {
            base: Acc1400::new(),
            base1410: Acc1410::new(),
            asset_gnacs,
            is_issuable: true,
            issuance_limit: None,
            issuance_records: Vec::new(),
            redemption_records: Vec::new(),
            dividend_records: HashMap::new(),
            claimable_dividends: HashMap::new(),
            holding_start_time: HashMap::new(),
            authorized_roles: HashMap::new(),
        }
    }
    
    /// 设置发行上限
    pub fn set_issuance_limit(&mut self, limit: u64) {
        self.issuance_limit = Some(limit);
    }
    
    /// 设置是否可发行
    pub fn set_issuable(&mut self, issuable: bool) {
        self.is_issuable = issuable;
    }
    
    /// 授权角色
    pub fn authorize_role(&mut self, role: &str, address: &str) {
        self.authorized_roles
            .entry(role.to_string())
            .or_insert_with(Vec::new)
            .push(address.to_string());
    }
    
    /// 检查角色权限
    pub fn has_role(&self, role: &str, address: &str) -> bool {
        self.authorized_roles
            .get(role)
            .map(|addresses| addresses.contains(&address.to_string()))
            .unwrap_or(false)
    }
    
    // ==================== 资产生命周期操作 ====================
    
    /// 发行新资产（增加总供应量）
    pub fn issue(
        &mut self,
        operator: &str,
        to: &str,
        amount: u64,
        data: Vec<u8>,
        partition_id: &[u8; 32],
        receipt_hash: [u8; 32],
    ) -> Result<()> {
        // 检查权限
        if !self.has_role("ISSUER", operator) {
            return Err(Acc1594Error::Unauthorized {
                operator: operator.to_string(),
                required_role: "ISSUER".to_string(),
            });
        }
        
        // 检查是否可发行
        if !self.is_issuable {
            return Err(Acc1594Error::NotIssuable("Asset is not issuable".to_string()));
        }
        
        // 检查发行上限
        if let Some(limit) = self.issuance_limit {
            let current_supply = self.total_supply(partition_id)?;
            if current_supply + amount > limit {
                return Err(Acc1594Error::ExceedsIssuanceLimit {
                    current: current_supply + amount,
                    limit,
                });
            }
        }
        
        // 发行到分区
        self.base1410.issue_to_partition(partition_id, to, amount)?;
        
        // 记录持有开始时间
        if !self.holding_start_time.contains_key(to) {
            self.holding_start_time.insert(to.to_string(), Self::current_timestamp());
        }
        
        // 记录发行
        self.issuance_records.push(IssuanceRecord {
            operator: operator.to_string(),
            to: to.to_string(),
            amount,
            data,
            timestamp: Self::current_timestamp(),
            receipt_hash,
        });
        
        Ok(())
    }
    
    /// 赎回资产（销毁）
    pub fn redeem(
        &mut self,
        account: &str,
        amount: u64,
        data: Vec<u8>,
        partition_id: &[u8; 32],
        receipt_hash: [u8; 32],
    ) -> Result<()> {
        // 检查赎回策略
        let policy = RedemptionPolicy::from(self.asset_gnacs.dividend_extension.redemption_policy);
        if policy == RedemptionPolicy::NonRedeemable {
            return Err(Acc1594Error::RedemptionNotAllowed(
                "Asset is non-redeemable".to_string(),
            ));
        }
        
        // 检查最低持有期
        self.check_min_holding_period(account)?;
        
        // 从分区销毁
        self.base1410.burn_from_partition(partition_id, account, amount)?;
        
        // 记录赎回
        self.redemption_records.push(RedemptionRecord {
            operator: account.to_string(),
            from: account.to_string(),
            amount,
            data,
            timestamp: Self::current_timestamp(),
            receipt_hash,
        });
        
        Ok(())
    }
    
    /// 操作员代表持有者赎回
    pub fn operator_redeem(
        &mut self,
        operator: &str,
        token_holder: &str,
        amount: u64,
        data: Vec<u8>,
        partition_id: &[u8; 32],
        receipt_hash: [u8; 32],
    ) -> Result<()> {
        // 检查操作员权限
        if !self.base1410.is_operator_for(token_holder, operator) {
            return Err(Acc1594Error::Unauthorized {
                operator: operator.to_string(),
                required_role: "OPERATOR".to_string(),
            });
        }
        
        // 检查赎回策略
        let policy = RedemptionPolicy::from(self.asset_gnacs.dividend_extension.redemption_policy);
        if policy == RedemptionPolicy::NonRedeemable {
            return Err(Acc1594Error::RedemptionNotAllowed(
                "Asset is non-redeemable".to_string(),
            ));
        }
        
        // 检查最低持有期
        self.check_min_holding_period(token_holder)?;
        
        // 从分区销毁
        self.base1410.burn_from_partition(partition_id, token_holder, amount)?;
        
        // 记录赎回
        self.redemption_records.push(RedemptionRecord {
            operator: operator.to_string(),
            from: token_holder.to_string(),
            amount,
            data,
            timestamp: Self::current_timestamp(),
            receipt_hash,
        });
        
        Ok(())
    }
    
    /// 检查资产是否可发行
    pub fn is_issuable(&self) -> bool {
        self.is_issuable
    }
    
    // ==================== 收益分配 ====================
    
    /// 分配收益（由宪法执行引擎自动触发，或授权角色手动触发）
    pub fn distribute_dividend(
        &mut self,
        operator: &str,
        partition_id: &[u8; 32],
        total_amount: u64,
        period: u64,
        receipt_hash: [u8; 32],
    ) -> Result<()> {
        // 检查权限
        if !self.has_role("DISTRIBUTOR", operator) {
            return Err(Acc1594Error::Unauthorized {
                operator: operator.to_string(),
                required_role: "DISTRIBUTOR".to_string(),
            });
        }
        
        // 获取分区总供应量
        let total_supply = self.total_supply(partition_id)?;
        if total_supply == 0 {
            return Ok(());
        }
        
        // 获取所有持有者并分配
        let partition_id_hex = hex::encode(partition_id);
        let holders = self.get_all_holders(partition_id)?;
        for account in holders {
            let balance = self.base1410.balance_of_by_partition(partition_id, &account)?;
            // 修复：先乘后除避免整数除法精度损失
            let dividend = (balance * total_amount) / total_supply;
            
            self.claimable_dividends
                .entry(account.clone())
                .or_insert_with(HashMap::new)
                .entry(partition_id_hex.clone())
                .and_modify(|e| *e += dividend)
                .or_insert(dividend);
        }
        
        // 记录分红
        let per_share_amount = if total_supply > 0 { total_amount / total_supply } else { 0 };
        let record = DividendRecord {
            period,
            total_amount,
            per_share_amount,
            timestamp: Self::current_timestamp(),
            receipt_hash,
        };
        
        self.dividend_records
            .entry(partition_id_hex)
            .or_insert_with(Vec::new)
            .push(record);
        
        Ok(())
    }
    
    /// 查询账户可领取的收益（分区级）
    pub fn claimable_dividend(&self, account: &str, partition_id: &[u8; 32]) -> u64 {
        let partition_id_hex = hex::encode(partition_id);
        self.claimable_dividends
            .get(account)
            .and_then(|partitions| partitions.get(&partition_id_hex))
            .copied()
            .unwrap_or(0)
    }
    
    /// 领取收益（自动转入账户XTZH余额）
    pub fn claim_dividend(
        &mut self,
        account: &str,
        partition_id: &[u8; 32],
        _receipt_hash: [u8; 32],
    ) -> Result<u64> {
        let partition_id_hex = hex::encode(partition_id);
        let amount = self.claimable_dividend(account, partition_id);
        
        if amount == 0 {
            return Err(Acc1594Error::NoClaimableDividend {
                account: account.to_string(),
                partition: partition_id_hex,
            });
        }
        
        // 清除可领取分红
        if let Some(partitions) = self.claimable_dividends.get_mut(account) {
            partitions.remove(&partition_id_hex);
        }
        
        Ok(amount)
    }
    
    /// 批量领取收益（多个分区）
    pub fn claim_multiple_dividends(
        &mut self,
        account: &str,
        partition_ids: &[[u8; 32]],
        receipt_hash: [u8; 32],
    ) -> Result<u64> {
        let mut total = 0;
        for partition_id in partition_ids {
            if let Ok(amount) = self.claim_dividend(account, partition_id, receipt_hash) {
                total += amount;
            }
        }
        Ok(total)
    }
    
    /// 获取历史分红记录
    pub fn get_dividend_history(
        &self,
        partition_id: &[u8; 32],
        from: u64,
        to: u64,
    ) -> Vec<DividendRecord> {
        let partition_id_hex = hex::encode(partition_id);
        self.dividend_records
            .get(&partition_id_hex)
            .map(|records| {
                records
                    .iter()
                    .filter(|r| r.period >= from && r.period <= to)
                    .cloned()
                    .collect()
            })
            .unwrap_or_default()
    }
    
    // ==================== 资产状态查询 ====================
    
    /// 获取资产GNACS（含收益扩展）
    pub fn asset_gnacs(&self) -> &FullDividendGNACS {
        &self.asset_gnacs
    }
    
    /// 获取资产总供应量
    pub fn total_supply(&self, partition_id: &[u8; 32]) -> Result<u64> {
        // 简化实现：返回分区信息中的总供应量
        let info = self.base1410.get_partition_info(partition_id)?;
        Ok(info.total_supply)
    }
    
    /// 获取账户余额（指定分区）
    pub fn balance_of(&self, account: &str, partition_id: &[u8; 32]) -> Result<u64> {
        Ok(self.base1410.balance_of_by_partition(partition_id, account)?)
    }
    
    /// 获取资产净值（由AI估值引擎提供）
    pub fn net_asset_value(&self) -> (u64, u64) {
        // 简化实现：返回模拟的净值和时间戳
        (1000000, Self::current_timestamp())
    }
    
    // ==================== 辅助方法 ====================
    
    /// 检查最低持有期
    fn check_min_holding_period(&self, account: &str) -> Result<()> {
        let min_period = self.asset_gnacs.dividend_extension.min_holding_period;
        if min_period == 0 {
            return Ok(());
        }
        
        if let Some(&start_time) = self.holding_start_time.get(account) {
            let current_time = Self::current_timestamp();
            let held_seconds = current_time - start_time;
            let held_months = (held_seconds / (30 * 24 * 3600)) as u8;
            
            if held_months < min_period {
                return Err(Acc1594Error::MinHoldingPeriodNotMet {
                    required_months: min_period,
                    held_months,
                });
            }
        }
        
        Ok(())
    }
    
    /// 获取分区的所有持有者
    fn get_all_holders(&self, partition_id: &[u8; 32]) -> Result<Vec<String>> {
        // 从持有开始时间记录中获取所有账户，筛选出在该分区有余额的账户
        let mut holders = Vec::new();
        for account in self.holding_start_time.keys() {
            if let Ok(balance) = self.base1410.balance_of_by_partition(partition_id, account) {
                if balance > 0 {
                    holders.push(account.clone());
                }
            }
        }
        Ok(holders)
    }
    
    /// 获取当前时间戳
    fn current_timestamp() -> u64 {
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_secs()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use nac_acc_1410::{ExtendedGNACS, GNACSExtension, PartitionType};

    fn create_test_acc1594() -> (Acc1594, [u8; 32]) {
        let dividend_gnacs = FullDividendGNACS {
            base_gnacs: vec![0x94, 0x01, 0x00, 0x04, 0x02, 0x01],
            dividend_extension: DividendGNACSExtension {
                dividend_policy: 1, // 固定比例
                dividend_period: 4, // 年度
                dividend_rate: 5,   // 5%
                redemption_policy: 1, // 按面值赎回
                min_holding_period: 0, // 无最低持有期
            },
        };
        
        let mut acc1594 = Acc1594::new(dividend_gnacs);
        
        // 授权角色
        acc1594.authorize_role("ISSUER", "issuer1");
        acc1594.authorize_role("DISTRIBUTOR", "distributor1");
        
        // 创建分区
        let extended_gnacs = ExtendedGNACS {
            base_gnacs: vec![0x94, 0x01, 0x00, 0x04, 0x02, 0x01],
            extension: GNACSExtension {
                partition_type: 0x01,
                vesting_years: 0,
                voting_multiplier: 1,
                dividend_priority: 1,
            },
        };
        
        let partition_id = acc1594
            .base1410
            .create_partition(
                "Test Partition".to_string(),
                extended_gnacs,
                PartitionType::CommonStock,
            )
            .unwrap();
        
        (acc1594, partition_id)
    }

    #[test]
    fn test_issue() {
        let (mut acc1594, partition_id) = create_test_acc1594();
        
        let result = acc1594.issue(
            "issuer1",
            "investor1",
            1000,
            vec![],
            &partition_id,
            [0u8; 32],
        );
        
        assert!(result.is_ok());
        assert_eq!(acc1594.balance_of("investor1", &partition_id).unwrap(), 1000);
    }

    #[test]
    fn test_redeem() {
        let (mut acc1594, partition_id) = create_test_acc1594();
        
        acc1594
            .issue("issuer1", "investor1", 1000, vec![], &partition_id, [0u8; 32])
            .unwrap();
        
        let result = acc1594.redeem("investor1", 300, vec![], &partition_id, [0u8; 32]);
        
        assert!(result.is_ok());
        assert_eq!(acc1594.balance_of("investor1", &partition_id).unwrap(), 700);
    }

    #[test]
    fn test_distribute_dividend() {
        let (mut acc1594, partition_id) = create_test_acc1594();
        
        // 发行给两个投资者
        acc1594
            .issue("issuer1", "investor1", 600, vec![], &partition_id, [0u8; 32])
            .unwrap();
        acc1594
            .issue("issuer1", "investor2", 400, vec![], &partition_id, [0u8; 32])
            .unwrap();
        
        // 分配分红
        let result = acc1594.distribute_dividend(
            "distributor1",
            &partition_id,
            1000,
            202601,
            [0u8; 32],
        );
        
        assert!(result.is_ok());
        
        // 检查可领取分红
        assert_eq!(acc1594.claimable_dividend("investor1", &partition_id), 600);
        assert_eq!(acc1594.claimable_dividend("investor2", &partition_id), 400);
    }

    #[test]
    fn test_claim_dividend() {
        let (mut acc1594, partition_id) = create_test_acc1594();
        
        acc1594
            .issue("issuer1", "investor1", 1000, vec![], &partition_id, [0u8; 32])
            .unwrap();
        
        acc1594
            .distribute_dividend("distributor1", &partition_id, 500, 202601, [0u8; 32])
            .unwrap();
        
        let claimed = acc1594
            .claim_dividend("investor1", &partition_id, [0u8; 32])
            .unwrap();
        
        assert_eq!(claimed, 500);
        assert_eq!(acc1594.claimable_dividend("investor1", &partition_id), 0);
    }

    #[test]
    fn test_issuance_limit() {
        let (mut acc1594, partition_id) = create_test_acc1594();
        
        acc1594.set_issuance_limit(1000);
        
        // 第一次发行应该成功
        assert!(acc1594
            .issue("issuer1", "investor1", 500, vec![], &partition_id, [0u8; 32])
            .is_ok());
        
        // 第二次发行超过限额应该失败
        let result = acc1594.issue("issuer1", "investor2", 600, vec![], &partition_id, [0u8; 32]);
        assert!(result.is_err());
    }
}