#!/usr/bin/env python
# -*- coding: utf-8 -*-

"""
规则库演示脚本

此示例演示如何使用规则库创建、保存和加载规则。
"""

import sys
import logging
import json
import shutil
import tempfile
from pathlib import Path
from typing import Dict, Any, List

# 添加项目根目录到Python路径
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

from ddms_compliance_suite.models.rule_models import (
    BaseRule, PerformanceRule, SecurityRule, RESTfulDesignRule, ErrorHandlingRule,
    RuleCategory, TargetType, RuleLifecycle, RuleScope, SeverityLevel
)
from ddms_compliance_suite.models.config_models import RuleRepositoryConfig, RuleStorageConfig
from ddms_compliance_suite.rule_repository.repository import RuleRepository

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

logger = logging.getLogger(__name__)

def create_test_rules() -> List[BaseRule]:
    """创建测试用的规则"""
    rules = []
    
    # 1. 性能规则 - 响应时间不超过500毫秒
    performance_rule = PerformanceRule(
        id="response-time-max-500ms",
        name="响应时间不超过500毫秒",
        description="验证API响应时间不超过500毫秒",
        category=RuleCategory.PERFORMANCE,
        severity=SeverityLevel.WARNING,
        target_type=TargetType.API_RESPONSE,
        lifecycle=RuleLifecycle.RESPONSE_VALIDATION,
        scope=RuleScope.RESPONSE_TIME,
        threshold=500.0,
        metric="response_time",
        unit="ms"
    )
    rules.append(performance_rule)
    
    # 2. 安全规则 - HTTPS强制使用
    security_rule = SecurityRule(
        id="https-only-rule",
        name="HTTPS强制使用规则",
        description="验证API请求是否使用了HTTPS协议",
        category=RuleCategory.SECURITY,
        severity=SeverityLevel.ERROR,
        target_type=TargetType.API_REQUEST,
        lifecycle=RuleLifecycle.REQUEST_PREPARATION,
        scope=RuleScope.SECURITY,
        check_type="transport_security",
        expected_value="https"
    )
    rules.append(security_rule)
    
    # 3. RESTful设计规则 - URL路径格式
    restful_rule = RESTfulDesignRule(
        id="restful-url-pattern",
        name="RESTful URL设计规则",
        description="验证API URL是否符合RESTful设计规范",
        category=RuleCategory.API_DESIGN,
        severity=SeverityLevel.WARNING,
        target_type=TargetType.API_REQUEST,
        lifecycle=RuleLifecycle.REQUEST_PREPARATION,
        scope=RuleScope.REQUEST_URL,
        design_aspect="URL设计",
        pattern=r"^/api/v\d+/[a-z0-9-]+(/[a-z0-9-]+)*$"
    )
    rules.append(restful_rule)
    
    # 4. 错误处理规则 - 错误响应格式
    error_rule = ErrorHandlingRule(
        id="standard-error-response",
        name="标准错误响应格式规则",
        description="验证API错误响应是否符合标准格式",
        category=RuleCategory.ERROR_HANDLING,
        severity=SeverityLevel.WARNING,
        target_type=TargetType.API_RESPONSE,
        lifecycle=RuleLifecycle.RESPONSE_VALIDATION,
        scope=RuleScope.RESPONSE_BODY,
        error_code="*",
        expected_status=400
    )
    rules.append(error_rule)
    
    return rules

def test_rule_repository():
    """演示规则库的使用"""
    # 创建临时目录用于存储规则
    temp_dir = tempfile.mkdtemp(prefix="rule_repo_demo_")
    logger.info(f"使用临时目录: {temp_dir}")
    
    try:
        # 创建规则库配置
        config = RuleRepositoryConfig(
            storage=RuleStorageConfig(
                type="filesystem",
                path=temp_dir
            ),
            preload_rules=True
        )
        
        # 创建规则库
        repo = RuleRepository(config)
        logger.info("规则库初始化完成")
        
        # 创建测试规则并保存到规则库
        rules = create_test_rules()
        for rule in rules:
            saved = repo.save_rule(rule)
            logger.info(f"保存规则 {rule.id} ({rule.__class__.__name__}): {'成功' if saved else '失败'}")
        
        # 从规则库加载规则
        logger.info("\n加载规则进行验证:")
        for rule_id in [r.id for r in rules]:
            loaded_rule = repo.get_rule(rule_id)
            if loaded_rule:
                logger.info(f"加载规则 {rule_id}: 成功, 类型: {loaded_rule.__class__.__name__}")
                # 检查类型特定属性
                if isinstance(loaded_rule, PerformanceRule):
                    logger.info(f"  - 性能阈值: {loaded_rule.threshold} {loaded_rule.unit}")
                elif isinstance(loaded_rule, SecurityRule):
                    logger.info(f"  - 安全检查类型: {loaded_rule.check_type}, 预期值: {loaded_rule.expected_value}")
                elif isinstance(loaded_rule, RESTfulDesignRule):
                    logger.info(f"  - URL模式: {loaded_rule.pattern}")
                elif isinstance(loaded_rule, ErrorHandlingRule):
                    logger.info(f"  - 错误码: {loaded_rule.error_code}, 预期状态码: {loaded_rule.expected_status}")
            else:
                logger.error(f"加载规则 {rule_id}: 失败")
        
        # 按生命周期查询规则
        logger.info("\n按生命周期查询规则:")
        for lifecycle in [RuleLifecycle.REQUEST_PREPARATION, RuleLifecycle.RESPONSE_VALIDATION]:
            rules_for_lifecycle = repo.get_rules_by_lifecycle(lifecycle)
            logger.info(f"生命周期 {lifecycle.value} 的规则数量: {len(rules_for_lifecycle)}")
            for rule in rules_for_lifecycle:
                logger.info(f"  - {rule.id} ({rule.__class__.__name__})")
    
    finally:
        # 清理临时目录
        logger.info(f"清理临时目录: {temp_dir}")
        shutil.rmtree(temp_dir)

if __name__ == "__main__":
    test_rule_repository()