//! 规则引擎模块
//!
//! 实现规则定义DSL、执行引擎、更新机制和冲突检测

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

/// 规则引擎
pub struct RuleEngine {
    /// 规则集
    rules: HashMap<String, Rule>,
    /// 规则执行器
    executor: RuleExecutor,
}

impl RuleEngine {
    /// 创建新的规则引擎
    pub fn new() -> Self {
        Self {
            rules: HashMap::new(),
            executor: RuleExecutor::new(),
        }
    }

    /// 添加规则
    pub fn add_rule(&mut self, rule: Rule) -> Result<()> {
        // 检查规则冲突
        self.check_conflicts(&rule)?;

        self.rules.insert(rule.id.clone(), rule);
        Ok(())
    }

    /// 移除规则
    pub fn remove_rule(&mut self, rule_id: &str) -> Option<Rule> {
        self.rules.remove(rule_id)
    }

    /// 更新规则
    pub fn update_rule(&mut self, rule: Rule) -> Result<()> {
        if !self.rules.contains_key(&rule.id) {
            return Err(Error::RuleError(format!("规则不存在: {}", rule.id)));
        }

        // 检查规则冲突
        self.check_conflicts(&rule)?;

        self.rules.insert(rule.id.clone(), rule);
        Ok(())
    }

    /// 获取规则
    pub fn get_rule(&self, rule_id: &str) -> Option<&Rule> {
        self.rules.get(rule_id)
    }

    /// 获取所有规则
    pub fn get_all_rules(&self) -> Vec<&Rule> {
        self.rules.values().collect()
    }

    /// 应用规则
    pub fn apply(&self, result: &mut ComplianceResult, data: &ComplianceData) -> Result<()> {
        // 获取适用于当前层级的规则
        let applicable_rules: Vec<&Rule> = self.rules.values()
            .filter(|r| r.layer == result.layer && r.enabled)
            .collect();

        // 执行规则
        for rule in applicable_rules {
            self.executor.execute(rule, result, data)?;
        }

        Ok(())
    }

    /// 检查规则冲突
    fn check_conflicts(&self, new_rule: &Rule) -> Result<()> {
        for existing_rule in self.rules.values() {
            if existing_rule.id == new_rule.id {
                continue;
            }

            // 检查是否有冲突
            if existing_rule.layer == new_rule.layer && 
               existing_rule.priority == new_rule.priority &&
               existing_rule.condition.conflicts_with(&new_rule.condition) {
                return Err(Error::RuleError(format!(
                    "规则冲突: {} 与 {}",
                    existing_rule.id,
                    new_rule.id
                )));
            }
        }

        Ok(())
    }
}

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

/// 规则
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Rule {
    /// 规则ID
    pub id: String,
    /// 规则名称
    pub name: String,
    /// 规则描述
    pub description: String,
    /// 适用层级
    pub layer: ComplianceLayer,
    /// 条件
    pub condition: RuleCondition,
    /// 动作
    pub action: RuleAction,
    /// 优先级（数字越大优先级越高）
    pub priority: i32,
    /// 是否启用
    pub enabled: bool,
    /// 版本
    pub version: u32,
}

impl Rule {
    /// 创建新规则
    pub fn new(id: String, name: String, layer: ComplianceLayer) -> Self {
        Self {
            id,
            name,
            description: String::new(),
            layer,
            condition: RuleCondition::Always,
            action: RuleAction::Pass,
            priority: 0,
            enabled: true,
            version: 1,
        }
    }

    /// 设置描述
    pub fn with_description(mut self, description: String) -> Self {
        self.description = description;
        self
    }

    /// 设置条件
    pub fn with_condition(mut self, condition: RuleCondition) -> Self {
        self.condition = condition;
        self
    }

    /// 设置动作
    pub fn with_action(mut self, action: RuleAction) -> Self {
        self.action = action;
        self
    }

    /// 设置优先级
    pub fn with_priority(mut self, priority: i32) -> Self {
        self.priority = priority;
        self
    }
}

/// 规则条件
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RuleCondition {
    /// 总是满足
    Always,
    /// 从不满足
    Never,
    /// 置信度条件
    Confidence {
        operator: ComparisonOperator,
        value: f64,
    },
    /// 风险等级条件
    RiskLevel {
        operator: ComparisonOperator,
        value: RiskLevel,
    },
    /// 状态条件
    Status {
        value: ComplianceStatus,
    },
    /// 字段条件
    Field {
        field: String,
        operator: ComparisonOperator,
        value: serde_json::Value,
    },
    /// AND条件
    And(Vec<RuleCondition>),
    /// OR条件
    Or(Vec<RuleCondition>),
    /// NOT条件
    Not(Box<RuleCondition>),
}

impl RuleCondition {
    /// 检查是否与另一个条件冲突
    pub fn conflicts_with(&self, _other: &RuleCondition) -> bool {
        // 简化实现：假设不冲突
        // 实际实现需要复杂的逻辑分析
        false
    }
}

/// 比较运算符
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum ComparisonOperator {
    /// 等于
    Equal,
    /// 不等于
    NotEqual,
    /// 大于
    GreaterThan,
    /// 大于等于
    GreaterThanOrEqual,
    /// 小于
    LessThan,
    /// 小于等于
    LessThanOrEqual,
}

/// 规则动作
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RuleAction {
    /// 通过
    Pass,
    /// 拒绝
    Reject {
        reason: String,
    },
    /// 修改状态
    SetStatus {
        status: ComplianceStatus,
    },
    /// 修改风险等级
    SetRiskLevel {
        level: RiskLevel,
    },
    /// 添加问题
    AddIssue {
        issue: ComplianceIssue,
    },
    /// 添加建议
    AddRecommendation {
        recommendation: String,
    },
    /// 修改置信度
    AdjustConfidence {
        adjustment: f64,
    },
}

/// 规则执行器
pub struct RuleExecutor;

impl RuleExecutor {
    /// 创建新的规则执行器
    pub fn new() -> Self {
        Self
    }

    /// 执行规则
    pub fn execute(&self, rule: &Rule, result: &mut ComplianceResult, data: &ComplianceData) -> Result<()> {
        // 检查条件是否满足
        if !self.evaluate_condition(&rule.condition, result, data)? {
            return Ok(());
        }

        // 执行动作
        self.execute_action(&rule.action, result)?;

        Ok(())
    }

    /// 评估条件
    fn evaluate_condition(&self, condition: &RuleCondition, result: &ComplianceResult, data: &ComplianceData) -> Result<bool> {
        match condition {
            RuleCondition::Always => Ok(true),
            RuleCondition::Never => Ok(false),
            RuleCondition::Confidence { operator, value } => {
                Ok(self.compare_f64(result.confidence, *value, *operator))
            }
            RuleCondition::RiskLevel { operator, value } => {
                Ok(self.compare_risk_level(result.risk_level, *value, *operator))
            }
            RuleCondition::Status { value } => {
                Ok(result.status == *value)
            }
            RuleCondition::Field { field, operator, value } => {
                let field_value = data.fields.get(field);
                match field_value {
                    Some(v) => Ok(self.compare_json(v, value, *operator)),
                    None => Ok(false),
                }
            }
            RuleCondition::And(conditions) => {
                for cond in conditions {
                    if !self.evaluate_condition(cond, result, data)? {
                        return Ok(false);
                    }
                }
                Ok(true)
            }
            RuleCondition::Or(conditions) => {
                for cond in conditions {
                    if self.evaluate_condition(cond, result, data)? {
                        return Ok(true);
                    }
                }
                Ok(false)
            }
            RuleCondition::Not(condition) => {
                Ok(!self.evaluate_condition(condition, result, data)?)
            }
        }
    }

    /// 执行动作
    fn execute_action(&self, action: &RuleAction, result: &mut ComplianceResult) -> Result<()> {
        match action {
            RuleAction::Pass => {
                // 不做任何修改
            }
            RuleAction::Reject { reason } => {
                result.status = ComplianceStatus::Failed;
                result.details = reason.clone();
            }
            RuleAction::SetStatus { status } => {
                result.status = *status;
            }
            RuleAction::SetRiskLevel { level } => {
                result.risk_level = *level;
            }
            RuleAction::AddIssue { issue } => {
                result.issues.push(issue.clone());
            }
            RuleAction::AddRecommendation { recommendation } => {
                result.recommendations.push(recommendation.clone());
            }
            RuleAction::AdjustConfidence { adjustment } => {
                result.confidence = (result.confidence + adjustment).clamp(0.0, 1.0);
            }
        }

        Ok(())
    }

    /// 比较浮点数
    fn compare_f64(&self, left: f64, right: f64, operator: ComparisonOperator) -> bool {
        match operator {
            ComparisonOperator::Equal => (left - right).abs() < f64::EPSILON,
            ComparisonOperator::NotEqual => (left - right).abs() >= f64::EPSILON,
            ComparisonOperator::GreaterThan => left > right,
            ComparisonOperator::GreaterThanOrEqual => left >= right,
            ComparisonOperator::LessThan => left < right,
            ComparisonOperator::LessThanOrEqual => left <= right,
        }
    }

    /// 比较风险等级
    fn compare_risk_level(&self, left: RiskLevel, right: RiskLevel, operator: ComparisonOperator) -> bool {
        match operator {
            ComparisonOperator::Equal => left == right,
            ComparisonOperator::NotEqual => left != right,
            ComparisonOperator::GreaterThan => left > right,
            ComparisonOperator::GreaterThanOrEqual => left >= right,
            ComparisonOperator::LessThan => left < right,
            ComparisonOperator::LessThanOrEqual => left <= right,
        }
    }

    /// 比较JSON值
    fn compare_json(&self, _left: &serde_json::Value, _right: &serde_json::Value, _operator: ComparisonOperator) -> bool {
        // 简化实现
        true
    }
}

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

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

    #[test]
    fn test_rule_creation() {
        let rule = Rule::new(
            "rule1".to_string(),
            "Test Rule".to_string(),
            ComplianceLayer::IdentityVerification,
        );
        assert_eq!(rule.id, "rule1");
        assert_eq!(rule.version, 1);
    }

    #[test]
    fn test_rule_engine() {
        let mut engine = RuleEngine::new();
        let rule = Rule::new(
            "rule1".to_string(),
            "Test Rule".to_string(),
            ComplianceLayer::IdentityVerification,
        );

        assert!(engine.add_rule(rule).is_ok());
        assert!(engine.get_rule("rule1").is_some());
    }

    #[test]
    fn test_rule_condition() {
        let condition = RuleCondition::Confidence {
            operator: ComparisonOperator::GreaterThan,
            value: 0.8,
        };

        let executor = RuleExecutor::new();
        let result = 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 data = ComplianceData::new("user123".to_string());

        assert!(executor.evaluate_condition(&condition, &result, &data).unwrap());
    }
}