//! AI验证器模块
//!
//! 实现KYC、AML、风险评估和智能决策引擎

use crate::compliance_layer::*;
use crate::error::*;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use async_trait::async_trait;

/// 合规数据
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComplianceData {
    /// 用户ID
    pub user_id: String,
    /// 资产ID
    pub asset_id: Option<String>,
    /// 数据字段
    pub fields: HashMap<String, serde_json::Value>,
    /// 元数据
    pub metadata: HashMap<String, String>,
}

impl ComplianceData {
    /// 创建新的合规数据
    pub fn new(user_id: String) -> Self {
        Self {
            user_id,
            asset_id: None,
            fields: HashMap::new(),
            metadata: HashMap::new(),
        }
    }

    /// 设置资产ID
    pub fn with_asset_id(mut self, asset_id: String) -> Self {
        self.asset_id = Some(asset_id);
        self
    }

    /// 添加字段
    pub fn add_field<T: Serialize>(&mut self, key: String, value: T) -> Result<()> {
        self.fields.insert(key, serde_json::to_value(value)?);
        Ok(())
    }

    /// 获取字段
    pub fn get_field<T: for<'de> Deserialize<'de>>(&self, key: &str) -> Result<Option<T>> {
        match self.fields.get(key) {
            Some(value) => Ok(Some(serde_json::from_value(value.clone())?)),
            None => Ok(None),
        }
    }

    /// 添加元数据
    pub fn add_metadata(&mut self, key: String, value: String) {
        self.metadata.insert(key, value);
    }
}

/// AI验证器trait
#[async_trait]
pub trait AIValidator: Send + Sync {
    /// 验证数据
    async fn validate(&self, data: &ComplianceData) -> Result<ComplianceResult>;

    /// 获取验证器名称
    fn name(&self) -> &str;

    /// 获取验证器版本
    fn version(&self) -> &str;
}

/// KYC验证器
pub struct KYCValidator {
    /// 最小置信度阈值
    min_confidence: f64,
}

impl KYCValidator {
    /// 创建新的KYC验证器
    pub fn new() -> Self {
        Self {
            min_confidence: 0.8,
        }
    }

    /// 设置最小置信度
    pub fn with_min_confidence(mut self, confidence: f64) -> Self {
        self.min_confidence = confidence;
        self
    }

    /// 验证身份文件
    fn verify_identity_documents(&self, data: &ComplianceData) -> Result<f64> {
        // 模拟AI模型验证身份文件
        // 实际实现应调用真实的AI模型
        let has_passport: bool = data.get_field("has_passport")?.unwrap_or(false);
        let has_id_card: bool = data.get_field("has_id_card")?.unwrap_or(false);
        let has_driver_license: bool = data.get_field("has_driver_license")?.unwrap_or(false);

        let mut confidence = 0.0;
        if has_passport { confidence += 0.4; }
        if has_id_card { confidence += 0.3; }
        if has_driver_license { confidence += 0.3; }

        Ok(confidence)
    }

    /// 验证地址证明
    fn verify_address_proof(&self, data: &ComplianceData) -> Result<f64> {
        let has_utility_bill: bool = data.get_field("has_utility_bill")?.unwrap_or(false);
        let has_bank_statement: bool = data.get_field("has_bank_statement")?.unwrap_or(false);

        let mut confidence = 0.0;
        if has_utility_bill { confidence += 0.5; }
        if has_bank_statement { confidence += 0.5; }

        Ok(confidence)
    }
}

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

#[async_trait]
impl AIValidator for KYCValidator {
    async fn validate(&self, data: &ComplianceData) -> Result<ComplianceResult> {
        let identity_confidence = self.verify_identity_documents(data)?;
        let address_confidence = self.verify_address_proof(data)?;

        let confidence = (identity_confidence + address_confidence) / 2.0;

        let (status, risk_level) = if confidence >= self.min_confidence {
            (ComplianceStatus::Passed, RiskLevel::Low)
        } else if confidence >= 0.6 {
            (ComplianceStatus::ConditionalPass, RiskLevel::Medium)
        } else if confidence >= 0.4 {
            (ComplianceStatus::ManualReview, RiskLevel::High)
        } else {
            (ComplianceStatus::Failed, RiskLevel::Critical)
        };

        let mut issues = Vec::new();
        if identity_confidence < 0.5 {
            issues.push(ComplianceIssue {
                code: "KYC001".to_string(),
                description: "身份文件验证不足".to_string(),
                severity: IssueSeverity::Warning,
                regulations: vec!["KYC规范".to_string()],
            });
        }

        Ok(ComplianceResult {
            layer: ComplianceLayer::IdentityVerification,
            status,
            confidence,
            risk_level,
            details: format!("KYC验证完成，置信度: {:.2}", confidence),
            issues,
            recommendations: vec!["建议提供更多身份证明文件".to_string()],
            timestamp: chrono::Utc::now(),
        })
    }

    fn name(&self) -> &str {
        "KYC Validator"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }
}

/// AML验证器
pub struct AMLValidator {
    /// 风险阈值
    risk_threshold: f64,
}

impl AMLValidator {
    /// 创建新的AML验证器
    pub fn new() -> Self {
        Self {
            risk_threshold: 0.7,
        }
    }

    /// 检查黑名单
    fn check_blacklist(&self, data: &ComplianceData) -> Result<bool> {
        // 模拟检查黑名单
        let is_blacklisted: bool = data.get_field("is_blacklisted")?.unwrap_or(false);
        Ok(is_blacklisted)
    }

    /// 检查交易模式
    fn check_transaction_pattern(&self, data: &ComplianceData) -> Result<f64> {
        // 模拟AI模型分析交易模式
        let transaction_count: u32 = data.get_field("transaction_count")?.unwrap_or(0);
        let high_value_count: u32 = data.get_field("high_value_count")?.unwrap_or(0);

        let risk_score = if transaction_count > 100 && high_value_count > 10 {
            0.8
        } else if transaction_count > 50 {
            0.5
        } else {
            0.2
        };

        Ok(risk_score)
    }
}

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

#[async_trait]
impl AIValidator for AMLValidator {
    async fn validate(&self, data: &ComplianceData) -> Result<ComplianceResult> {
        let is_blacklisted = self.check_blacklist(data)?;
        let risk_score = self.check_transaction_pattern(data)?;

        let (status, risk_level, confidence) = if is_blacklisted {
            (ComplianceStatus::Failed, RiskLevel::Critical, 0.0)
        } else if risk_score >= self.risk_threshold {
            (ComplianceStatus::ManualReview, RiskLevel::High, 0.3)
        } else if risk_score >= 0.5 {
            (ComplianceStatus::ConditionalPass, RiskLevel::Medium, 0.6)
        } else {
            (ComplianceStatus::Passed, RiskLevel::Low, 0.9)
        };

        let mut issues = Vec::new();
        if is_blacklisted {
            issues.push(ComplianceIssue {
                code: "AML001".to_string(),
                description: "用户在黑名单中".to_string(),
                severity: IssueSeverity::Critical,
                regulations: vec!["反洗钱法".to_string()],
            });
        }

        Ok(ComplianceResult {
            layer: ComplianceLayer::IdentityVerification,
            status,
            confidence,
            risk_level,
            details: format!("AML验证完成，风险评分: {:.2}", risk_score),
            issues,
            recommendations: if risk_score > 0.5 {
                vec!["建议进行人工审核".to_string()]
            } else {
                vec![]
            },
            timestamp: chrono::Utc::now(),
        })
    }

    fn name(&self) -> &str {
        "AML Validator"
    }

    fn version(&self) -> &str {
        "1.0.0"
    }
}

/// 风险评估引擎
pub struct RiskAssessmentEngine {
    /// 风险因子权重
    risk_weights: HashMap<String, f64>,
}

impl RiskAssessmentEngine {
    /// 创建新的风险评估引擎
    pub fn new() -> Self {
        let mut risk_weights = HashMap::new();
        risk_weights.insert("kyc_risk".to_string(), 0.3);
        risk_weights.insert("aml_risk".to_string(), 0.3);
        risk_weights.insert("asset_risk".to_string(), 0.2);
        risk_weights.insert("legal_risk".to_string(), 0.2);

        Self { risk_weights }
    }

    /// 计算综合风险评分
    pub fn calculate_risk(&self, data: &ComplianceData) -> Result<f64> {
        let mut total_risk = 0.0;

        for (factor, weight) in &self.risk_weights {
            let risk: f64 = data.get_field(factor)?.unwrap_or(0.0);
            total_risk += risk * weight;
        }

        Ok(total_risk)
    }

    /// 评估风险等级
    pub fn assess_risk_level(&self, risk_score: f64) -> RiskLevel {
        if risk_score >= 0.8 {
            RiskLevel::Critical
        } else if risk_score >= 0.6 {
            RiskLevel::High
        } else if risk_score >= 0.4 {
            RiskLevel::Medium
        } else {
            RiskLevel::Low
        }
    }
}

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

/// 智能决策引擎
pub struct DecisionEngine {
    /// 决策规则
    rules: Vec<DecisionRule>,
}

#[derive(Debug, Clone)]
pub struct DecisionRule {
    /// 规则ID
    pub id: String,
    /// 规则名称
    pub name: String,
    /// 条件
    pub condition: String,
    /// 动作
    pub action: DecisionAction,
}

#[derive(Debug, Clone)]
pub enum DecisionAction {
    /// 批准
    Approve,
    /// 拒绝
    Reject,
    /// 人工审核
    ManualReview,
    /// 有条件批准
    ConditionalApprove(String),
}

impl DecisionEngine {
    /// 创建新的决策引擎
    pub fn new() -> Self {
        Self {
            rules: Vec::new(),
        }
    }

    /// 添加规则
    pub fn add_rule(&mut self, rule: DecisionRule) {
        self.rules.push(rule);
    }

    /// 执行决策
    pub fn make_decision(&self, results: &[ComplianceResult]) -> DecisionAction {
        // 检查是否有任何层级失败
        if results.iter().any(|r| r.status == ComplianceStatus::Failed) {
            return DecisionAction::Reject;
        }

        // 检查是否有高风险或极高风险
        if results.iter().any(|r| r.risk_level >= RiskLevel::High) {
            return DecisionAction::ManualReview;
        }

        // 检查是否有需要人工审核的
        if results.iter().any(|r| r.status == ComplianceStatus::ManualReview) {
            return DecisionAction::ManualReview;
        }

        // 检查是否有条件通过
        if results.iter().any(|r| r.status == ComplianceStatus::ConditionalPass) {
            return DecisionAction::ConditionalApprove("需要满足额外条件".to_string());
        }

        // 所有层级都通过
        DecisionAction::Approve
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_kyc_validator() {
        let validator = KYCValidator::new();
        let mut data = ComplianceData::new("user123".to_string());
        data.add_field("has_passport".to_string(), true).unwrap();
        data.add_field("has_id_card".to_string(), true).unwrap();
        data.add_field("has_utility_bill".to_string(), true).unwrap();
        data.add_field("has_bank_statement".to_string(), true).unwrap();

        let result = validator.validate(&data).await.unwrap();
        assert_eq!(result.status, ComplianceStatus::Passed);
    }

    #[tokio::test]
    async fn test_aml_validator() {
        let validator = AMLValidator::new();
        let mut data = ComplianceData::new("user123".to_string());
        data.add_field("is_blacklisted".to_string(), false).unwrap();
        data.add_field("transaction_count".to_string(), 10u32).unwrap();

        let result = validator.validate(&data).await.unwrap();
        assert_eq!(result.status, ComplianceStatus::Passed);
    }

    #[test]
    fn test_risk_assessment() {
        let engine = RiskAssessmentEngine::new();
        let mut data = ComplianceData::new("user123".to_string());
        data.add_field("kyc_risk".to_string(), 0.2).unwrap();
        data.add_field("aml_risk".to_string(), 0.3).unwrap();

        let risk = engine.calculate_risk(&data).unwrap();
        assert!(risk > 0.0 && risk < 1.0);
    }

    #[test]
    fn test_decision_engine() {
        let engine = DecisionEngine::new();
        let results = vec![
            ComplianceResult {
                layer: ComplianceLayer::IdentityVerification,
                status: ComplianceStatus::Passed,
                confidence: 0.9,
                risk_level: RiskLevel::Low,
                details: "Test".to_string(),
                issues: vec![],
                recommendations: vec![],
                timestamp: chrono::Utc::now(),
            }
        ];

        let decision = engine.make_decision(&results);
        matches!(decision, DecisionAction::Approve);
    }
}