//! 区块验证系统
//! 
//! 实现完整的区块验证功能，包括宪法验证、交易验证、合规检查和状态转换

use crate::block::{Block, BlockHeader};
use serde::{Deserialize, Serialize};
use std::collections::{HashMap, HashSet};
use chrono::Utc;

/// 验证错误类型
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ValidationError {
    /// 宪法验证失败
    ConstitutionalViolation(String),
    /// 交易验证失败
    InvalidTransaction(String),
    /// 合规检查失败
    ComplianceFailure(String),
    /// 状态转换失败
    StateTransitionError(String),
    /// 签名验证失败
    InvalidSignature(String),
    /// 时间戳无效
    InvalidTimestamp(String),
    /// 区块高度无效
    InvalidHeight(String),
    /// Merkle根不匹配
    MerkleRootMismatch,
    /// 区块大小超限
    BlockSizeExceeded,
    /// Gas限制超限
    GasLimitExceeded,
}

/// 宪法规则
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ConstitutionalRule {
    /// 规则ID
    pub id: String,
    /// 规则名称
    pub name: String,
    /// 规则描述
    pub description: String,
    /// 规则类型
    pub rule_type: RuleType,
    /// 是否启用
    pub enabled: bool,
    /// 优先级
    pub priority: u32,
}

/// 规则类型
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum RuleType {
    /// 区块结构规则
    BlockStructure,
    /// 交易规则
    Transaction,
    /// 验证者规则
    Validator,
    /// 共识规则
    Consensus,
    /// 资产规则
    Asset,
    /// 合规规则
    Compliance,
}

/// 交易验证规则
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TransactionRule {
    /// 最小交易费
    pub min_fee: u64,
    /// 最大交易大小
    pub max_size: usize,
    /// 最大Gas限制
    pub max_gas: u64,
    /// 需要签名数量
    pub required_signatures: usize,
}

/// 合规检查器
#[derive(Debug, Clone)]
pub struct ComplianceChecker {
    /// KYC要求
    kyc_required: bool,
    /// AML检查
    aml_enabled: bool,
    /// 黑名单
    blacklist: HashSet<String>,
    /// 白名单
    whitelist: HashSet<String>,
    /// 地域限制
    pub geo_restrictions: HashMap<String, bool>,
}

impl ComplianceChecker {
    pub fn new() -> Self {
        ComplianceChecker {
            kyc_required: true,
            aml_enabled: true,
            blacklist: HashSet::new(),
            whitelist: HashSet::new(),
            geo_restrictions: HashMap::new(),
        }
    }

    /// 检查地址是否合规
    pub fn check_address(&self, address: &str) -> Result<(), ValidationError> {
        // 检查黑名单
        if self.blacklist.contains(address) {
            return Err(ValidationError::ComplianceFailure(
                format!("Address {} is blacklisted", address)
            ));
        }

        // 检查白名单（如果启用）
        if !self.whitelist.is_empty() && !self.whitelist.contains(address) {
            return Err(ValidationError::ComplianceFailure(
                format!("Address {} is not whitelisted", address)
            ));
        }

        Ok(())
    }

    /// 检查KYC状态
    pub fn check_kyc(&self, address: &str) -> Result<(), ValidationError> {
        if !self.kyc_required {
            return Ok(());
        }

        // 简化实现：假设所有地址都需要KYC验证
        // 实际应该查询KYC数据库
        if address.len() < 42 {
            return Err(ValidationError::ComplianceFailure(
                format!("Address {} has not completed KYC", address)
            ));
        }

        Ok(())
    }

    /// 执行AML检查
    pub fn check_aml(&self, address: &str, amount: u64) -> Result<(), ValidationError> {
        if !self.aml_enabled {
            return Ok(());
        }

        // 简化实现：检查大额交易
        if amount > 1_000_000_000 {
            // 需要额外的AML审查
            return Err(ValidationError::ComplianceFailure(
                format!("Large transaction from {} requires AML review", address)
            ));
        }

        Ok(())
    }

    /// 添加到黑名单
    pub fn add_to_blacklist(&mut self, address: String) {
        self.blacklist.insert(address);
    }

    /// 添加到白名单
    pub fn add_to_whitelist(&mut self, address: String) {
        self.whitelist.insert(address);
    }
}

impl Default for ComplianceChecker {
    fn default() -> Self {
        Self::new()
    }
}

/// 状态转换器
#[derive(Debug, Clone)]
pub struct StateTransition {
    /// 前状态根
    pub prev_state_root: String,
    /// 后状态根
    pub next_state_root: String,
    /// 状态变更
    pub changes: Vec<StateChange>,
}

/// 状态变更
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StateChange {
    /// 账户地址
    pub address: String,
    /// 变更类型
    pub change_type: ChangeType,
    /// 旧值
    pub old_value: Option<String>,
    /// 新值
    pub new_value: String,
}

/// 变更类型
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum ChangeType {
    /// 余额变更
    Balance,
    /// Nonce变更
    Nonce,
    /// 存储变更
    Storage,
    /// 代码变更
    Code,
}

/// 区块验证器
#[derive(Debug)]
pub struct BlockValidator {
    /// 宪法规则
    constitutional_rules: Vec<ConstitutionalRule>,
    /// 交易规则
    transaction_rules: TransactionRule,
    /// 合规检查器
    compliance_checker: ComplianceChecker,
    /// 最大区块大小
    max_block_size: usize,
    /// 最大区块Gas
    max_block_gas: u64,
}

impl BlockValidator {
    pub fn new() -> Self {
        BlockValidator {
            constitutional_rules: Self::default_constitutional_rules(),
            transaction_rules: TransactionRule {
                min_fee: 1000,
                max_size: 1024 * 1024, // 1MB
                max_gas: 10_000_000,
                required_signatures: 1,
            },
            compliance_checker: ComplianceChecker::new(),
            max_block_size: 10 * 1024 * 1024, // 10MB
            max_block_gas: 100_000_000,
        }
    }

    /// 默认宪法规则
    fn default_constitutional_rules() -> Vec<ConstitutionalRule> {
        vec![
            ConstitutionalRule {
                id: "rule_001".to_string(),
                name: "Block Size Limit".to_string(),
                description: "Maximum block size is 10MB".to_string(),
                rule_type: RuleType::BlockStructure,
                enabled: true,
                priority: 1,
            },
            ConstitutionalRule {
                id: "rule_002".to_string(),
                name: "Transaction Fee".to_string(),
                description: "Minimum transaction fee is 1000 units".to_string(),
                rule_type: RuleType::Transaction,
                enabled: true,
                priority: 2,
            },
            ConstitutionalRule {
                id: "rule_003".to_string(),
                name: "Validator Signature".to_string(),
                description: "Block must be signed by a valid validator".to_string(),
                rule_type: RuleType::Validator,
                enabled: true,
                priority: 3,
            },
            ConstitutionalRule {
                id: "rule_004".to_string(),
                name: "KYC Requirement".to_string(),
                description: "All participants must complete KYC".to_string(),
                rule_type: RuleType::Compliance,
                enabled: true,
                priority: 4,
            },
        ]
    }

    /// 完整的区块验证
    pub fn validate_block(&self, block: &Block, prev_block: Option<&Block>) -> Result<(), ValidationError> {
        // 1. 验证区块头
        self.validate_header(&block.header, prev_block)?;

        // 2. 宪法验证
        self.validate_constitutional(block)?;

        // 3. 交易验证
        self.validate_transactions(block)?;

        // 4. 合规检查
        self.validate_compliance(block)?;

        // 5. 状态转换验证
        self.validate_state_transition(block)?;

        Ok(())
    }

    /// 验证区块头
    fn validate_header(&self, header: &BlockHeader, prev_block: Option<&Block>) -> Result<(), ValidationError> {
        // 验证时间戳
        let now = Utc::now();
        let future_limit = now + chrono::Duration::seconds(300);
        
        if header.timestamp > future_limit {
            return Err(ValidationError::InvalidTimestamp(
                "Block timestamp is too far in the future".to_string()
            ));
        }

        // 验证高度
        if let Some(prev) = prev_block {
            if header.height != prev.header.height + 1 {
                return Err(ValidationError::InvalidHeight(
                    format!("Expected height {}, got {}", prev.header.height + 1, header.height)
                ));
            }

            // 验证父哈希
            if header.prev_hash != prev.hash() {
                return Err(ValidationError::StateTransitionError(
                    "Previous hash does not match".to_string()
                ));
            }

            // 验证时间戳递增
            if header.timestamp <= prev.header.timestamp {
                return Err(ValidationError::InvalidTimestamp(
                    "Block timestamp must be greater than previous block".to_string()
                ));
            }
        } else if header.height != 0 {
            return Err(ValidationError::InvalidHeight(
                "Genesis block must have height 0".to_string()
            ));
        }

        Ok(())
    }

    /// 宪法验证
    fn validate_constitutional(&self, block: &Block) -> Result<(), ValidationError> {
        for rule in &self.constitutional_rules {
            if !rule.enabled {
                continue;
            }

            match rule.rule_type {
                RuleType::BlockStructure => {
                    // 验证区块大小
                    let block_size = self.estimate_block_size(block);
                    if block_size > self.max_block_size {
                        return Err(ValidationError::ConstitutionalViolation(
                            format!("Block size {} exceeds limit {}", block_size, self.max_block_size)
                        ));
                    }
                }
                RuleType::Transaction => {
                    // 交易规则在validate_transactions中验证
                }
                RuleType::Validator => {
                    // 验证签名
                    if block.header.validator.is_empty() {
                        return Err(ValidationError::ConstitutionalViolation(
                            "Block must have a proposer".to_string()
                        ));
                    }
                }
                RuleType::Consensus => {
                    // 共识规则验证
                }
                RuleType::Asset => {
                    // 资产规则验证
                }
                RuleType::Compliance => {
                    // 合规规则在validate_compliance中验证
                }
            }
        }

        Ok(())
    }

    /// 交易验证
    fn validate_transactions(&self, block: &Block) -> Result<(), ValidationError> {
        let mut total_gas = 0u64;

        for tx in &block.body.transactions {
            // 验证交易大小
            let tx_size = serde_json::to_string(tx).expect("FIX-006: unexpected None/Err").len();
            if tx_size > self.transaction_rules.max_size {
                return Err(ValidationError::InvalidTransaction(
                    format!("Transaction size {} exceeds limit {}", tx_size, self.transaction_rules.max_size)
                ));
            }

            // 验证Gas限制
            // 简化实现：假设每个交易消耗固定Gas
            let tx_gas = 21000u64;
            if tx_gas > self.transaction_rules.max_gas {
                return Err(ValidationError::InvalidTransaction(
                    format!("Transaction gas {} exceeds limit {}", tx_gas, self.transaction_rules.max_gas)
                ));
            }

            total_gas += tx_gas;
        }

        // 验证区块总Gas
        if total_gas > self.max_block_gas {
            return Err(ValidationError::GasLimitExceeded);
        }

        // 验证Merkle根
        let tx_hashes: Vec<String> = block.body.transactions.iter().map(|tx| tx.hash()).collect();
        let calculated_root = self.calculate_merkle_root_from_hashes(&tx_hashes);
        if calculated_root != block.header.merkle_root {
            return Err(ValidationError::MerkleRootMismatch);
        }

        Ok(())
    }

    /// 合规检查
    fn validate_compliance(&self, block: &Block) -> Result<(), ValidationError> {
        // 检查提议者合规性
        self.compliance_checker.check_address(&block.header.validator)?;
        self.compliance_checker.check_kyc(&block.header.validator)?;

        // 检查交易合规性
        for tx in &block.body.transactions {
            // 简化实现：从交易中提取地址
            // 实际应该解析交易数据
            // 检查交易发送者
            self.compliance_checker.check_address(&tx.from)?;
            
            // 检查AML
            self.compliance_checker.check_aml(&tx.from, tx.amount)?;
        }

        Ok(())
    }

    /// 状态转换验证
    fn validate_state_transition(&self, block: &Block) -> Result<(), ValidationError> {
        // 验证状态根
        if block.header.state_root.is_empty() {
            return Err(ValidationError::StateTransitionError(
                "State root is empty".to_string()
            ));
        }

        // 简化实现：实际应该执行所有交易并验证状态根
        // 这里只做基本检查
        if block.header.state_root.len() != 64 {
            return Err(ValidationError::StateTransitionError(
                "Invalid state root format".to_string()
            ));
        }

        Ok(())
    }

    /// 估算区块大小
    fn estimate_block_size(&self, block: &Block) -> usize {
        let mut size = 0;
        
        // 区块头大小
        size += 200; // 简化估算
        
        // 交易大小
        for tx in &block.body.transactions {
            size += serde_json::to_string(tx).expect("FIX-006: unexpected None/Err").len();
        }
        
        size
    }

    /// 计算Merkle根
    fn calculate_merkle_root_from_hashes(&self, hashes: &[String]) -> String {
        if hashes.is_empty() {
            return "0".repeat(64);
        }

        // 简化实现：使用SHA256
        use sha2::{Sha256, Digest};
        let mut hasher = Sha256::new();
        for hash in hashes {
            hasher.update(hash.as_bytes());
        }
        hex::encode(hasher.finalize())
    }

    /// 获取合规检查器的可变引用
    pub fn compliance_checker_mut(&mut self) -> &mut ComplianceChecker {
        &mut self.compliance_checker
    }

    /// 添加宪法规则
    pub fn add_constitutional_rule(&mut self, rule: ConstitutionalRule) {
        self.constitutional_rules.push(rule);
    }

    /// 更新交易规则
    pub fn update_transaction_rules(&mut self, rules: TransactionRule) {
        self.transaction_rules = rules;
    }
}

impl Default for BlockValidator {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::block::{Block, BlockBody};

    #[test]
    fn test_compliance_checker() {
        let mut checker = ComplianceChecker::new();
        
        // 测试黑名单
        checker.add_to_blacklist("0x123".to_string());
        assert!(checker.check_address("0x123").is_err());
        
        // 测试白名单
        checker.add_to_whitelist("0x456".to_string());
        assert!(checker.check_address("0x456").is_ok());
    }

    #[test]
    fn test_kyc_check() {
        let checker = ComplianceChecker::new();
        
        // 短地址应该失败
        assert!(checker.check_kyc("0x123").is_err());
        
        // 长地址应该通过
        let long_address = "0x1234567890123456789012345678901234567890";
        assert!(checker.check_kyc(long_address).is_ok());
    }

    #[test]
    fn test_aml_check() {
        let checker = ComplianceChecker::new();
        
        // 小额交易应该通过
        assert!(checker.check_aml("0x123", 1000).is_ok());
        
        // 大额交易应该需要审查
        assert!(checker.check_aml("0x123", 2_000_000_000).is_err());
    }

    #[test]
    fn test_block_validator_creation() {
        let validator = BlockValidator::new();
        assert_eq!(validator.constitutional_rules.len(), 4);
        assert_eq!(validator.max_block_size, 10 * 1024 * 1024);
    }

    #[test]
    fn test_validate_header() {
        let validator = BlockValidator::new();
        let mut block = Block::new(0, "0".repeat(96), "validator1".to_string());
        
        // 设置有效的时间戳（当前时间）
        block.header.timestamp = chrono::Utc::now();
        
        // 创世区块应该通过
        assert!(validator.validate_header(&block.header, None).is_ok());
    }

    #[test]
    fn test_validate_block_size() {
        let validator = BlockValidator::new();
        let mut block = Block::new(1, "genesis".to_string(), "validator1".to_string());
        
        // 添加一些交易
        use crate::block::Transaction;
        block.body.transactions.push(Transaction::new(
            "0x123".to_string(),
            "0x456".to_string(),
            1000,
            1,
        ));
        
        // 应该通过
        assert!(validator.validate_constitutional(&block).is_ok());
    }

    #[test]
    fn test_merkle_root_calculation() {
        let validator = BlockValidator::new();
        let hashes = vec![
            "hash1".to_string(),
            "hash2".to_string(),
        ];
        
        let root = validator.calculate_merkle_root_from_hashes(&hashes);
        assert_eq!(root.len(), 64);
    }

    #[test]
    fn test_state_transition_validation() {
        let validator = BlockValidator::new();
        let mut block = Block::new(1, "genesis".to_string(), "validator1".to_string());
        
        // 设置有效的状态根
        block.header.state_root = "0".repeat(64);
        
        assert!(validator.validate_state_transition(&block).is_ok());
    }
}