//! 估值验证系统
//! 
//! 提供估值验证机制、精度评估、差异分析和模型优化

use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use chrono::{DateTime, Utc};

use crate::{FinalValuationResult, AIProvider, AIValuationResult};

/// 验证规则
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationRule {
    /// 规则名称
    pub name: String,
    /// 规则描述
    pub description: String,
    /// 最小估值（XTZH）
    pub min_valuation: Option<Decimal>,
    /// 最大估值（XTZH）
    pub max_valuation: Option<Decimal>,
    /// 最小置信度
    pub min_confidence: Option<f64>,
    /// 最大模型差异率（%）
    pub max_model_divergence: Option<f64>,
    /// 是否启用
    pub enabled: bool,
}

impl ValidationRule {
    /// 创建默认验证规则
    pub fn default_rules() -> Vec<Self> {
        vec![
            ValidationRule {
                name: "估值范围检查".to_string(),
                description: "确保估值在合理范围内".to_string(),
                min_valuation: Some(Decimal::ZERO),
                max_valuation: Some(Decimal::new(1_000_000_000_000, 0)), // 1万亿XTZH
                min_confidence: None,
                max_model_divergence: None,
                enabled: true,
            },
            ValidationRule {
                name: "置信度检查".to_string(),
                description: "确保置信度达到最低要求".to_string(),
                min_valuation: None,
                max_valuation: None,
                min_confidence: Some(0.5),
                max_model_divergence: None,
                enabled: true,
            },
            ValidationRule {
                name: "模型差异检查".to_string(),
                description: "确保AI模型估值差异不过大".to_string(),
                min_valuation: None,
                max_valuation: None,
                min_confidence: None,
                max_model_divergence: Some(30.0), // 30%
                enabled: true,
            },
        ]
    }

    /// 验证估值结果
    pub fn validate(&self, result: &FinalValuationResult) -> ValidationResult {
        if !self.enabled {
            return ValidationResult::passed(self.name.clone());
        }

        let mut issues = Vec::new();

        // 检查估值范围
        if let Some(min_val) = self.min_valuation {
            if result.valuation_xtzh < min_val {
                issues.push(format!(
                    "估值 {} XTZH 低于最小值 {} XTZH",
                    result.valuation_xtzh, min_val
                ));
            }
        }

        if let Some(max_val) = self.max_valuation {
            if result.valuation_xtzh > max_val {
                issues.push(format!(
                    "估值 {} XTZH 超过最大值 {} XTZH",
                    result.valuation_xtzh, max_val
                ));
            }
        }

        // 检查置信度
        if let Some(min_conf) = self.min_confidence {
            if result.confidence < min_conf {
                issues.push(format!(
                    "置信度 {:.1}% 低于最小值 {:.1}%",
                    result.confidence * 100.0,
                    min_conf * 100.0
                ));
            }
        }

        // 检查模型差异
        if let Some(max_div) = self.max_model_divergence {
            if !result.model_results.is_empty() {
                let valuations: Vec<Decimal> = result.model_results
                    .iter()
                    .map(|r| r.valuation_xtzh)
                    .collect();
                
                if let Some(divergence) = Self::calculate_divergence(&valuations) {
                    if divergence > max_div {
                        issues.push(format!(
                            "模型差异 {:.1}% 超过最大值 {:.1}%",
                            divergence, max_div
                        ));
                    }
                }
            }
        }

        if issues.is_empty() {
            ValidationResult::passed(self.name.clone())
        } else {
            ValidationResult::failed(self.name.clone(), issues)
        }
    }

    /// 计算模型差异率
    fn calculate_divergence(valuations: &[Decimal]) -> Option<f64> {
        if valuations.len() < 2 {
            return None;
        }

        let min = valuations.iter().min()?;
        let max = valuations.iter().max()?;
        
        if *min == Decimal::ZERO {
            return None;
        }

        let divergence = ((*max - *min) / *min * Decimal::new(100, 0))
            .to_string()
            .parse::<f64>()
            .ok()?;

        Some(divergence)
    }
}

/// 验证结果
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ValidationResult {
    /// 规则名称
    pub rule_name: String,
    /// 是否通过
    pub passed: bool,
    /// 问题列表
    pub issues: Vec<String>,
    /// 验证时间
    pub timestamp: DateTime<Utc>,
}

impl ValidationResult {
    /// 创建通过的验证结果
    pub fn passed(rule_name: String) -> Self {
        Self {
            rule_name,
            passed: true,
            issues: Vec::new(),
            timestamp: Utc::now(),
        }
    }

    /// 创建失败的验证结果
    pub fn failed(rule_name: String, issues: Vec<String>) -> Self {
        Self {
            rule_name,
            passed: false,
            issues,
            timestamp: Utc::now(),
        }
    }
}

/// 估值验证器
pub struct ValuationValidator {
    /// 验证规则列表
    rules: Vec<ValidationRule>,
}

impl ValuationValidator {
    /// 创建新的验证器
    pub fn new(rules: Vec<ValidationRule>) -> Self {
        Self { rules }
    }

    /// 使用默认规则创建验证器
    pub fn with_default_rules() -> Self {
        Self::new(ValidationRule::default_rules())
    }

    /// 验证估值结果
    pub fn validate(&self, result: &FinalValuationResult) -> Vec<ValidationResult> {
        self.rules
            .iter()
            .map(|rule| rule.validate(result))
            .collect()
    }

    /// 检查是否所有验证都通过
    pub fn validate_all(&self, result: &FinalValuationResult) -> bool {
        self.validate(result).iter().all(|r| r.passed)
    }

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

    /// 移除验证规则
    pub fn remove_rule(&mut self, rule_name: &str) {
        self.rules.retain(|r| r.name != rule_name);
    }

    /// 启用/禁用规则
    pub fn set_rule_enabled(&mut self, rule_name: &str, enabled: bool) {
        if let Some(rule) = self.rules.iter_mut().find(|r| r.name == rule_name) {
            rule.enabled = enabled;
        }
    }
}

/// 精度评估器
pub struct AccuracyEvaluator;

impl AccuracyEvaluator {
    /// 评估估值精度（与实际价值比较）
    pub fn evaluate(
        estimated: Decimal,
        actual: Decimal,
    ) -> AccuracyMetrics {
        let absolute_error = if estimated > actual {
            estimated - actual
        } else {
            actual - estimated
        };

        let relative_error = if actual != Decimal::ZERO {
            (absolute_error / actual * Decimal::new(100, 0))
                .to_string()
                .parse::<f64>()
                .unwrap_or(0.0)
        } else {
            0.0
        };

        let accuracy = 100.0 - relative_error.min(100.0);

        AccuracyMetrics {
            estimated,
            actual,
            absolute_error,
            relative_error,
            accuracy,
        }
    }

    /// 批量评估精度
    pub fn evaluate_batch(
        pairs: Vec<(Decimal, Decimal)>,
    ) -> BatchAccuracyMetrics {
        let metrics: Vec<AccuracyMetrics> = pairs
            .iter()
            .map(|(est, act)| Self::evaluate(*est, *act))
            .collect();

        let avg_accuracy = metrics.iter().map(|m| m.accuracy).sum::<f64>() / metrics.len() as f64;
        let avg_relative_error = metrics.iter().map(|m| m.relative_error).sum::<f64>() / metrics.len() as f64;

        BatchAccuracyMetrics {
            total_samples: metrics.len(),
            avg_accuracy,
            avg_relative_error,
            individual_metrics: metrics,
        }
    }
}

/// 精度指标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AccuracyMetrics {
    /// 估值
    pub estimated: Decimal,
    /// 实际值
    pub actual: Decimal,
    /// 绝对误差
    pub absolute_error: Decimal,
    /// 相对误差（%）
    pub relative_error: f64,
    /// 精度（%）
    pub accuracy: f64,
}

/// 批量精度指标
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BatchAccuracyMetrics {
    /// 样本总数
    pub total_samples: usize,
    /// 平均精度（%）
    pub avg_accuracy: f64,
    /// 平均相对误差（%）
    pub avg_relative_error: f64,
    /// 各样本指标
    pub individual_metrics: Vec<AccuracyMetrics>,
}

/// 差异分析器
pub struct DivergenceAnalyzer;

impl DivergenceAnalyzer {
    /// 分析AI模型估值差异
    pub fn analyze(model_results: &[AIValuationResult]) -> DivergenceAnalysis {
        if model_results.is_empty() {
            return DivergenceAnalysis::empty();
        }

        let valuations: Vec<Decimal> = model_results
            .iter()
            .map(|r| r.valuation_xtzh)
            .collect();

        let min_valuation = valuations.iter().min().unwrap().clone();
        let max_valuation = valuations.iter().max().unwrap().clone();
        let avg_valuation = valuations.iter().sum::<Decimal>() / Decimal::new(valuations.len() as i64, 0);

        let divergence_rate = if min_valuation != Decimal::ZERO {
            ((max_valuation - min_valuation) / min_valuation * Decimal::new(100, 0))
                .to_string()
                .parse::<f64>()
                .unwrap_or(0.0)
        } else {
            0.0
        };

        // 识别异常值
        let outliers = Self::identify_outliers(model_results, avg_valuation);

        // 模型一致性评分
        let consistency_score = Self::calculate_consistency_score(divergence_rate);

        DivergenceAnalysis {
            model_count: model_results.len(),
            min_valuation,
            max_valuation,
            avg_valuation,
            divergence_rate,
            outliers,
            consistency_score,
        }
    }

    /// 识别异常值（偏离平均值超过30%）
    fn identify_outliers(
        model_results: &[AIValuationResult],
        avg_valuation: Decimal,
    ) -> Vec<AIProvider> {
        let threshold = Decimal::new(30, 2); // 0.30 = 30%
        
        model_results
            .iter()
            .filter(|r| {
                let deviation = if r.valuation_xtzh > avg_valuation {
                    (r.valuation_xtzh - avg_valuation) / avg_valuation
                } else {
                    (avg_valuation - r.valuation_xtzh) / avg_valuation
                };
                deviation > threshold
            })
            .map(|r| r.provider)
            .collect()
    }

    /// 计算一致性评分（0-100）
    fn calculate_consistency_score(divergence_rate: f64) -> f64 {
        if divergence_rate <= 10.0 {
            100.0
        } else if divergence_rate <= 20.0 {
            90.0 - (divergence_rate - 10.0)
        } else if divergence_rate <= 30.0 {
            80.0 - (divergence_rate - 20.0) * 2.0
        } else {
            (60.0 - (divergence_rate - 30.0)).max(0.0)
        }
    }
}

/// 差异分析结果
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DivergenceAnalysis {
    /// 模型数量
    pub model_count: usize,
    /// 最小估值
    pub min_valuation: Decimal,
    /// 最大估值
    pub max_valuation: Decimal,
    /// 平均估值
    pub avg_valuation: Decimal,
    /// 差异率（%）
    pub divergence_rate: f64,
    /// 异常值模型
    pub outliers: Vec<AIProvider>,
    /// 一致性评分（0-100）
    pub consistency_score: f64,
}

impl DivergenceAnalysis {
    /// 创建空的分析结果
    fn empty() -> Self {
        Self {
            model_count: 0,
            min_valuation: Decimal::ZERO,
            max_valuation: Decimal::ZERO,
            avg_valuation: Decimal::ZERO,
            divergence_rate: 0.0,
            outliers: Vec::new(),
            consistency_score: 0.0,
        }
    }

    /// 生成分析报告
    pub fn generate_report(&self) -> String {
        let mut report = String::new();

        report.push_str("# 模型差异分析报告\n\n");
        report.push_str(&format!("- **模型数量**: {}\n", self.model_count));
        report.push_str(&format!("- **估值范围**: {} - {} XTZH\n", self.min_valuation, self.max_valuation));
        report.push_str(&format!("- **平均估值**: {} XTZH\n", self.avg_valuation));
        report.push_str(&format!("- **差异率**: {:.2}%\n", self.divergence_rate));
        report.push_str(&format!("- **一致性评分**: {:.1}/100\n\n", self.consistency_score));

        if !self.outliers.is_empty() {
            report.push_str("## ⚠️ 异常值检测\n\n");
            report.push_str("以下模型的估值偏离平均值超过30%：\n\n");
            for provider in &self.outliers {
                report.push_str(&format!("- {:?}\n", provider));
            }
            report.push_str("\n");
        }

        if self.divergence_rate > 30.0 {
            report.push_str("## 🔴 高差异警告\n\n");
            report.push_str("模型估值差异率超过30%，建议：\n");
            report.push_str("1. 检查输入数据的准确性\n");
            report.push_str("2. 审查异常模型的估值逻辑\n");
            report.push_str("3. 考虑人工审核\n");
        } else if self.divergence_rate > 20.0 {
            report.push_str("## 🟡 中等差异提示\n\n");
            report.push_str("模型估值差异率在20-30%之间，建议关注。\n");
        } else {
            report.push_str("## 🟢 差异正常\n\n");
            report.push_str("模型估值差异在可接受范围内。\n");
        }

        report
    }
}

/// 模型优化建议
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationSuggestion {
    /// 建议类型
    pub suggestion_type: SuggestionType,
    /// 建议描述
    pub description: String,
    /// 优先级
    pub priority: Priority,
    /// 目标模型
    pub target_model: Option<AIProvider>,
}

/// 建议类型
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum SuggestionType {
    /// 调整权重
    AdjustWeight,
    /// 更新模型
    UpdateModel,
    /// 增加训练数据
    AddTrainingData,
    /// 调整参数
    TuneParameters,
    /// 人工审核
    HumanReview,
}

/// 优先级
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum Priority {
    /// 高
    High,
    /// 中
    Medium,
    /// 低
    Low,
}

/// 模型优化器
pub struct ModelOptimizer;

impl ModelOptimizer {
    /// 生成优化建议
    pub fn generate_suggestions(
        result: &FinalValuationResult,
        divergence: &DivergenceAnalysis,
    ) -> Vec<OptimizationSuggestion> {
        let mut suggestions = Vec::new();

        // 如果差异率过高
        if divergence.divergence_rate > 30.0 {
            suggestions.push(OptimizationSuggestion {
                suggestion_type: SuggestionType::HumanReview,
                description: "模型差异过大，建议人工审核".to_string(),
                priority: Priority::High,
                target_model: None,
            });
        }

        // 如果有异常值
        for provider in &divergence.outliers {
            suggestions.push(OptimizationSuggestion {
                suggestion_type: SuggestionType::AdjustWeight,
                description: format!("模型 {:?} 估值异常，建议降低权重", provider),
                priority: Priority::Medium,
                target_model: Some(*provider),
            });
        }

        // 如果置信度过低
        if result.confidence < 0.7 {
            suggestions.push(OptimizationSuggestion {
                suggestion_type: SuggestionType::AddTrainingData,
                description: "整体置信度偏低，建议增加训练数据".to_string(),
                priority: Priority::Medium,
                target_model: None,
            });
        }

        // 如果一致性评分低
        if divergence.consistency_score < 70.0 {
            suggestions.push(OptimizationSuggestion {
                suggestion_type: SuggestionType::TuneParameters,
                description: "模型一致性不足，建议调整参数".to_string(),
                priority: Priority::Low,
                target_model: None,
            });
        }

        suggestions
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::Utc;
    use std::collections::HashMap;

    fn create_test_result(valuation: i64, confidence: f64) -> FinalValuationResult {
        FinalValuationResult {
            valuation_xtzh: Decimal::new(valuation, 0),
            confidence,
            model_results: vec![],
            weights: HashMap::new(),
            is_anomaly: false,
            anomaly_report: None,
            divergence_report: "Test".to_string(),
            requires_human_review: false,
        }
    }

    #[test]
    fn test_validation_rule() {
        let rule = ValidationRule {
            name: "Test Rule".to_string(),
            description: "Test".to_string(),
            min_valuation: Some(Decimal::new(1000, 0)),
            max_valuation: Some(Decimal::new(10000, 0)),
            min_confidence: Some(0.7),
            max_model_divergence: None,
            enabled: true,
        };

        let result = create_test_result(5000, 0.8);
        let validation = rule.validate(&result);
        assert!(validation.passed);

        let result2 = create_test_result(500, 0.5);
        let validation2 = rule.validate(&result2);
        assert!(!validation2.passed);
    }

    #[test]
    fn test_accuracy_evaluator() {
        let metrics = AccuracyEvaluator::evaluate(
            Decimal::new(100, 0),
            Decimal::new(110, 0),
        );

        assert_eq!(metrics.absolute_error, Decimal::new(10, 0));
        assert!(metrics.relative_error > 9.0 && metrics.relative_error < 10.0);
        assert!(metrics.accuracy > 90.0);
    }

    #[test]
    fn test_divergence_analyzer() {
        let model_results = vec![
            AIValuationResult {
                provider: AIProvider::ChatGPT,
                valuation_xtzh: Decimal::new(1000, 0),
                confidence: 0.85,
                reasoning: "Test".to_string(),
                timestamp: Utc::now(),
            },
            AIValuationResult {
                provider: AIProvider::DeepSeek,
                valuation_xtzh: Decimal::new(1100, 0),
                confidence: 0.88,
                reasoning: "Test".to_string(),
                timestamp: Utc::now(),
            },
            AIValuationResult {
                provider: AIProvider::DouBao,
                valuation_xtzh: Decimal::new(1050, 0),
                confidence: 0.82,
                reasoning: "Test".to_string(),
                timestamp: Utc::now(),
            },
        ];

        let analysis = DivergenceAnalyzer::analyze(&model_results);
        assert_eq!(analysis.model_count, 3);
        assert!(analysis.divergence_rate < 15.0);
        assert!(analysis.consistency_score > 85.0);
    }
}