"""规则执行引擎

该模块负责执行不同类型的规则，包括Python代码规则、断言规则等，
支持在API测试的不同生命周期阶段（请求准备、执行、响应验证等）执行规则。
"""

import logging
import importlib
import inspect
import time
import threading
from typing import Dict, List, Any, Optional, Union, Callable

from ..models.rule_models import (
    AnyRule, BaseRule, RuleCategory, TargetType, RuleLifecycle, RuleScope,
    PythonCodeRule, BusinessAssertionTemplate, PerformanceRule, SecurityRule,
    RESTfulDesignRule, ErrorHandlingRule
)
from ..api_caller.caller import APIRequest, APIResponse
from ..rule_repository.repository import RuleRepository

class RuleExecutionError(Exception):
    """规则执行过程中发生的错误"""
    pass

class RuleExecutionResult:
    """规则执行结果"""
    
    def __init__(self, 
                 rule: BaseRule, 
                 is_valid: bool, 
                 message: str = "", 
                 details: Optional[Dict[str, Any]] = None, 
                 error: Optional[Exception] = None):
        """
        初始化规则执行结果
        
        Args:
            rule: 执行的规则
            is_valid: 验证是否通过
            message: 执行结果消息
            details: 详细信息
            error: 执行过程中发生的异常（如果有）
        """
        self.rule = rule
        self.rule_id = rule.id
        self.rule_name = rule.name
        self.rule_category = rule.category
        self.is_valid = is_valid
        self.message = message
        self.details = details or {}
        self.error = error
    
    def __bool__(self):
        """允许直接使用结果对象作为布尔值，表示验证是否通过"""
        return self.is_valid
    
    def to_dict(self) -> Dict[str, Any]:
        """将结果转换为字典"""
        return {
            'rule_id': self.rule_id,
            'rule_name': self.rule_name,
            'rule_category': self.rule_category.value,
            'is_valid': self.is_valid,
            'message': self.message,
            'details': self.details,
            'error': str(self.error) if self.error else None
        }

class RuleExecutor:
    """规则执行引擎"""
    
    def __init__(self, rule_repository: RuleRepository):
        """
        初始化规则执行引擎
        
        Args:
            rule_repository: 规则库实例
        """
        self.rule_repository = rule_repository
        self.logger = logging.getLogger(__name__)
    
    def execute_rule(self, rule: BaseRule, context: Dict[str, Any]) -> RuleExecutionResult:
        """
        执行单个规则
        
        Args:
            rule: 要执行的规则
            context: 执行上下文，包含API请求、响应等信息
            
        Returns:
            执行结果
        """
        if not rule.is_enabled:
            return RuleExecutionResult(
                rule=rule,
                is_valid=True,
                message=f"规则 {rule.id} 已禁用，跳过执行"
            )
        
        try:
            # 根据规则类型选择适当的执行方法
            if rule.category == RuleCategory.PYTHON_CODE or hasattr(rule, 'code') and rule.code:
                return self._execute_python_code_rule(rule, context)
            elif rule.category == RuleCategory.BUSINESS_LOGIC:
                return self._execute_business_assertion_rule(rule, context)
            elif rule.category == RuleCategory.PERFORMANCE:
                return self._execute_performance_rule(rule, context)
            elif rule.category == RuleCategory.SECURITY:
                return self._execute_security_rule(rule, context)
            elif rule.category == RuleCategory.API_DESIGN:
                return self._execute_api_design_rule(rule, context)
            elif rule.category == RuleCategory.ERROR_HANDLING:
                return self._execute_error_handling_rule(rule, context)
            else:
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message=f"不支持的规则类型: {rule.category}"
                )
        except Exception as e:
            self.logger.error(f"执行规则 {rule.id} 失败: {e}", exc_info=True)
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"规则执行失败: {e}",
                error=e
            )
    
    def _execute_python_code_rule(self, rule: BaseRule, context: Dict[str, Any]) -> RuleExecutionResult:
        """执行Python代码规则"""
        # 获取规则中的Python代码
        code = getattr(rule, 'code', None)
        if not code:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message="规则未提供Python代码"
            )
        
        # 准备执行环境
        namespace = {'__builtins__': __builtins__}
        namespace.update(context)
        
        try:
            # 编译并执行代码
            compiled_code = compile(code, f"<rule:{rule.id}>", 'exec')
            exec(compiled_code, namespace)
            
            # 查找并执行验证函数
            entry_function = 'validate'
            if hasattr(rule, 'entry_function') and rule.entry_function:
                entry_function = rule.entry_function
                
            if entry_function not in namespace:
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message=f"找不到入口函数 '{entry_function}'"
                )
                
            validate_func = namespace[entry_function]
            if not callable(validate_func):
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message=f"'{entry_function}' 不是可调用的函数"
                )
            
            # 调用验证函数
            timeout = getattr(rule, 'timeout', 5)  # 默认5秒超时
            result = self._execute_with_timeout(validate_func, (context,), {}, timeout)
            
            # 处理执行结果
            if isinstance(result, dict):
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=bool(result.get('is_valid', False)),
                    message=result.get('message', ''),
                    details=result.get('details', {})
                )
            else:
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=bool(result),
                    message=str(result) if result is not True else "验证通过"
                )
                
        except Exception as e:
            self.logger.error(f"执行Python代码规则 {rule.id} 失败: {e}", exc_info=True)
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"执行代码失败: {e}",
                error=e
            )
    
    def _execute_with_timeout(self, func: Callable, args: tuple, kwargs: Dict[str, Any], timeout: int) -> Any:
        """使用超时执行函数"""
        result = [None]
        exception = [None]
        
        def target():
            try:
                result[0] = func(*args, **kwargs)
            except Exception as e:
                exception[0] = e
        
        thread = threading.Thread(target=target)
        thread.daemon = True
        
        thread.start()
        thread.join(timeout)
        
        if thread.is_alive():
            raise RuleExecutionError(f"规则执行超时（超过{timeout}秒）")
        
        if exception[0]:
            raise exception[0]
            
        return result[0]
    
    def _execute_business_assertion_rule(self, rule: BusinessAssertionTemplate, context: Dict[str, Any]) -> RuleExecutionResult:
        """执行业务断言规则"""
        # 验证是否提供了所有必需的参数
        if rule.expected_parameters:
            missing_params = [p for p in rule.expected_parameters if p not in context]
            if missing_params:
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message=f"缺少必需的参数: {', '.join(missing_params)}"
                )
        
        if rule.template_language == "python_expression":
            try:
                # 使用eval执行Python表达式
                result = eval(rule.template_expression, {'__builtins__': __builtins__}, context)
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=bool(result),
                    message="断言通过" if result else "断言失败"
                )
            except Exception as e:
                self.logger.error(f"执行Python表达式断言失败: {e}", exc_info=True)
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message=f"表达式执行失败: {e}",
                    error=e
                )
        else:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"不支持的模板语言: {rule.template_language}"
            )
    
    def _execute_performance_rule(self, rule: PerformanceRule, context: Dict[str, Any]) -> RuleExecutionResult:
        """执行性能规则"""
        response = context.get('api_response')
        if not response or not isinstance(response, APIResponse):
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message="缺少有效的API响应对象"
            )
        
        # 获取响应时间（毫秒）
        elapsed_time = response.elapsed_time * 1000  # 转换为毫秒
        
        # 检查是否超过阈值
        if elapsed_time > rule.threshold:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"响应时间（{elapsed_time:.2f}ms）超过阈值（{rule.threshold}{rule.unit}）",
                details={
                    'actual_time': elapsed_time,
                    'threshold': rule.threshold,
                    'unit': rule.unit
                }
            )
        
        return RuleExecutionResult(
            rule=rule,
            is_valid=True,
            message=f"响应时间（{elapsed_time:.2f}ms）在阈值范围内",
            details={
                'actual_time': elapsed_time,
                'threshold': rule.threshold,
                'unit': rule.unit
            }
        )
    
    def _execute_security_rule(self, rule: SecurityRule, context: Dict[str, Any]) -> RuleExecutionResult:
        """执行安全规则"""
        if rule.check_type == "transport_security":
            request = context.get('api_request')
            if not request or not isinstance(request, APIRequest):
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message="缺少有效的API请求对象"
                )
            
            url = str(request.url)
            
            # 检查URL是否使用HTTPS
            if not url.startswith('https://'):
                return RuleExecutionResult(
                    rule=rule,
                    is_valid=False,
                    message="API请求必须使用HTTPS协议",
                    details={
                        'current_url': url,
                        'expected_protocol': 'https'
                    }
                )
            
            return RuleExecutionResult(
                rule=rule,
                is_valid=True,
                message="API请求使用了HTTPS协议",
                details={
                    'url': url
                }
            )
        else:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"不支持的安全检查类型: {rule.check_type}"
            )
    
    def _execute_api_design_rule(self, rule: RESTfulDesignRule, context: Dict[str, Any]) -> RuleExecutionResult:
        """执行API设计规则"""
        import re
        
        request = context.get('api_request')
        if not request or not isinstance(request, APIRequest):
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message="缺少有效的API请求对象"
            )
        
        url = str(request.url)
        
        # 解析URL，获取路径部分
        from urllib.parse import urlparse
        parsed_url = urlparse(url)
        path = parsed_url.path
        
        # 使用正则表达式验证路径
        if rule.pattern and not re.match(rule.pattern, path):
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"API路径不符合{rule.design_aspect}规范",
                details={
                    'current_path': path,
                    'expected_pattern': rule.pattern
                }
            )
        
        return RuleExecutionResult(
            rule=rule,
            is_valid=True,
            message=f"API路径符合{rule.design_aspect}规范",
            details={
                'path': path
            }
        )
    
    def _execute_error_handling_rule(self, rule: ErrorHandlingRule, context: Dict[str, Any]) -> RuleExecutionResult:
        """执行错误处理规则"""
        response = context.get('api_response')
        if not response or not isinstance(response, APIResponse):
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message="缺少有效的API响应对象"
            )
        
        # 只验证4xx和5xx状态码
        if response.status_code < 400:
            return RuleExecutionResult(
                rule=rule,
                is_valid=True,
                message="非错误响应，跳过验证",
                details={
                    'status_code': response.status_code
                }
            )
        
        # 验证状态码是否匹配
        if rule.expected_status != -1 and response.status_code != rule.expected_status:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"响应状态码（{response.status_code}）与预期（{rule.expected_status}）不符",
                details={
                    'actual_status': response.status_code,
                    'expected_status': rule.expected_status
                }
            )
        
        # 验证JSON响应
        if not response.json_content:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message="错误响应不是有效的JSON格式",
                details={
                    'status_code': response.status_code,
                    'content_type': response.headers.get('Content-Type', '未知')
                }
            )
        
        # 检查错误码
        if rule.error_code != "*" and str(response.json_content.get('code', '')) != rule.error_code:
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message=f"错误码（{response.json_content.get('code')}）与预期（{rule.error_code}）不符",
                details={
                    'actual_code': response.json_content.get('code'),
                    'expected_code': rule.error_code
                }
            )
        
        # 验证错误消息
        if rule.expected_message and rule.expected_message not in str(response.json_content.get('message', '')):
            return RuleExecutionResult(
                rule=rule,
                is_valid=False,
                message="错误消息与预期不符",
                details={
                    'actual_message': response.json_content.get('message'),
                    'expected_message': rule.expected_message
                }
            )
        
        return RuleExecutionResult(
            rule=rule,
            is_valid=True,
            message="错误响应符合预期",
            details={
                'status_code': response.status_code,
                'error_code': response.json_content.get('code'),
                'error_message': response.json_content.get('message')
            }
        )
    
    def execute_rules_for_lifecycle(self, lifecycle: RuleLifecycle, context: Dict[str, Any]) -> List[RuleExecutionResult]:
        """
        执行特定生命周期阶段的所有规则
        
        Args:
            lifecycle: 生命周期阶段
            context: 执行上下文
            
        Returns:
            执行结果列表
        """
        # 获取适用于该生命周期阶段的所有规则
        rules = self.rule_repository.get_rules_by_lifecycle(lifecycle)
        
        # 执行规则
        results = []
        for rule in rules:
            result = self.execute_rule(rule, context)
            results.append(result)
        
        return results
    
    def execute_rules_for_target(self, target_type: TargetType, target_id: str, context: Dict[str, Any]) -> List[RuleExecutionResult]:
        """
        执行特定目标的所有规则
        
        Args:
            target_type: 目标类型
            target_id: 目标ID
            context: 执行上下文
            
        Returns:
            执行结果列表
        """
        # 获取适用于该目标的所有规则
        rules = self.rule_repository.get_rules_for_target(target_type, target_id)
        
        # 执行规则
        results = []
        for rule in rules:
            result = self.execute_rule(rule, context)
            results.append(result)
        
        return results

    def execute_specific_rules(self, rules: List[AnyRule], context: Dict[str, Any], lifecycle_phase: Optional[RuleLifecycle] = None) -> List[RuleExecutionResult]:
        """
        执行一个明确指定的规则列表。

        Args:
            rules: 要执行的规则对象的列表。
            context: 执行上下文，包含API请求、响应等信息。
            lifecycle_phase: 可选的，名义上的生命周期阶段，可能用于上下文或某些规则的内部逻辑。
                            注意：此参数目前主要用于信息传递，核心执行逻辑在 execute_rule 中
                            并不直接依赖它来选择执行路径。

        Returns:
            一个包含每个规则执行结果的列表。
        """
        results = []
        if not rules:
            self.logger.info("execute_specific_rules_called_with_no_rules")
            return results

        # 如果需要，可以将 lifecycle_phase 添加到 context 中传递给每个规则
        # updated_context = context.copy()
        # if lifecycle_phase:
        # updated_context['current_lifecycle_phase'] = lifecycle_phase

        for rule in rules:
            # 使用现有的 execute_rule 方法执行单个规则
            # result = self.execute_rule(rule, updated_context if lifecycle_phase else context)
            result = self.execute_rule(rule, context) # 简化：暂时不修改context传递
            results.append(result)
        
        return results