package com.qaup.collision.rule.model.enums;

/**
 * 规则执行结果枚举
 * 定义规则执行的最终结果分类
 * 
 * @author AI Assistant
 * @version 1.0
 * @since 2025-01-17
 */
public enum RuleExecutionResult {
    /**
     * 规则通过
     * 车辆状态符合规则要求，无违规
     */
    PASS("规则通过", "车辆状态符合规则要求，无违规"),
    
    /**
     * 规则违规
     * 车辆状态违反规则要求，产生违规事件
     */
    VIOLATION("规则违规", "车辆状态违反规则要求，产生违规事件"),
    
    /**
     * 规则不适用
     * 当前条件下规则不适用（如时间窗口外、车辆类型不匹配等）
     */
    NOT_APPLICABLE("规则不适用", "当前条件下规则不适用"),
    
    /**
     * 数据不足
     * 缺少必要的数据进行规则判断
     */
    INSUFFICIENT_DATA("数据不足", "缺少必要的数据进行规则判断"),
    
    /**
     * 执行异常
     * 规则执行过程中发生技术异常
     */
    EXECUTION_ERROR("执行异常", "规则执行过程中发生技术异常"),
    
    /**
     * 配置错误
     * 规则配置存在错误，无法正常执行
     */
    CONFIGURATION_ERROR("配置错误", "规则配置存在错误，无法正常执行"),
    
    /**
     * 已被覆盖
     * 被更高优先级的规则覆盖，结果无效
     */
    OVERRIDDEN("已被覆盖", "被更高优先级的规则覆盖，结果无效"),
    
    /**
     * 待定
     * 需要进一步确认或人工干预
     */
    PENDING_CONFIRMATION("待定", "需要进一步确认或人工干预");

    private final String displayName;
    private final String description;

    RuleExecutionResult(String displayName, String description) {
        this.displayName = displayName;
        this.description = description;
    }

    /**
     * 获取执行结果的显示名称
     * @return 显示名称
     */
    public String getDisplayName() {
        return displayName;
    }

    /**
     * 获取执行结果的描述信息
     * @return 描述信息
     */
    public String getDescription() {
        return description;
    }

    /**
     * 检查是否为成功结果
     * @return 如果是成功结果返回true
     */
    public boolean isSuccessful() {
        switch (this) {
            case PASS:
            case NOT_APPLICABLE:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否为违规结果
     * @return 如果是违规结果返回true
     */
    public boolean isViolation() {
        return this == VIOLATION;
    }

    /**
     * 检查是否为错误结果
     * @return 如果是错误结果返回true
     */
    public boolean isError() {
        switch (this) {
            case EXECUTION_ERROR:
            case CONFIGURATION_ERROR:
            case INSUFFICIENT_DATA:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否需要进一步处理
     * @return 如果需要进一步处理返回true
     */
    public boolean requiresAction() {
        switch (this) {
            case VIOLATION:
            case EXECUTION_ERROR:
            case CONFIGURATION_ERROR:
            case PENDING_CONFIRMATION:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否为最终结果
     * @return 如果是最终结果返回true
     */
    public boolean isFinalResult() {
        switch (this) {
            case PASS:
            case VIOLATION:
            case NOT_APPLICABLE:
            case OVERRIDDEN:
                return true;
            default:
                return false;
        }
    }

    /**
     * 获取结果的严重程度
     * @return 严重程度评分（1-10，数值越高越严重）
     */
    public int getSeverityLevel() {
        switch (this) {
            case VIOLATION:
                return 8;
            case EXECUTION_ERROR:
                return 6;
            case CONFIGURATION_ERROR:
                return 5;
            case PENDING_CONFIRMATION:
                return 4;
            case INSUFFICIENT_DATA:
                return 3;
            case OVERRIDDEN:
                return 2;
            case NOT_APPLICABLE:
            case PASS:
            default:
                return 1;
        }
    }

    /**
     * 获取结果的优先级（用于排序显示）
     * @return 优先级数值，数值越小优先级越高
     */
    public int getPriority() {
        switch (this) {
            case VIOLATION:
                return 1;
            case EXECUTION_ERROR:
                return 2;
            case CONFIGURATION_ERROR:
                return 3;
            case PENDING_CONFIRMATION:
                return 4;
            case INSUFFICIENT_DATA:
                return 5;
            case OVERRIDDEN:
                return 6;
            case NOT_APPLICABLE:
                return 7;
            case PASS:
            default:
                return 8;
        }
    }

    /**
     * 根据字符串名称获取执行结果
     * @param name 结果名称
     * @return 对应的执行结果枚举，如果不存在则返回null
     */
    public static RuleExecutionResult fromString(String name) {
        if (name == null || name.trim().isEmpty()) {
            return null;
        }
        
        try {
            return RuleExecutionResult.valueOf(name.toUpperCase());
        } catch (IllegalArgumentException e) {
            return null;
        }
    }

    /**
     * 根据布尔值和异常情况推断执行结果
     * @param passed 是否通过规则检查
     * @param hasError 是否发生错误
     * @param applicable 规则是否适用
     * @return 推断的执行结果
     */
    public static RuleExecutionResult inferResult(boolean passed, boolean hasError, boolean applicable) {
        if (hasError) {
            return EXECUTION_ERROR;
        }
        
        if (!applicable) {
            return NOT_APPLICABLE;
        }
        
        return passed ? PASS : VIOLATION;
    }

    /**
     * 检查是否应该记录到违规事件表
     * @return 如果应该记录返回true
     */
    public boolean shouldRecordViolationEvent() {
        switch (this) {
            case VIOLATION:
            case EXECUTION_ERROR:
            case CONFIGURATION_ERROR:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否应该发送告警通知
     * @return 如果应该发送告警返回true
     */
    public boolean shouldSendAlert() {
        switch (this) {
            case VIOLATION:
            case EXECUTION_ERROR:
            case CONFIGURATION_ERROR:
            case PENDING_CONFIRMATION:
                return true;
            default:
                return false;
        }
    }

    /**
     * 获取推荐的告警级别
     * @return 推荐的告警级别
     */
    public RuleAlertLevel getRecommendedAlertLevel() {
        switch (this) {
            case VIOLATION:
                return RuleAlertLevel.WARNING;
            case EXECUTION_ERROR:
            case CONFIGURATION_ERROR:
                return RuleAlertLevel.CRITICAL;
            case PENDING_CONFIRMATION:
                return RuleAlertLevel.INFO;
            default:
                return RuleAlertLevel.INFO;
        }
    }

    /**
     * 获取推荐的违规类型
     * @return 推荐的违规类型，如果不适用返回null
     */
    public ViolationType getRecommendedViolationType() {
        switch (this) {
            case VIOLATION:
                return ViolationType.CUSTOM_RULE;
            case EXECUTION_ERROR:
            case CONFIGURATION_ERROR:
                return ViolationType.CUSTOM_RULE;
            default:
                return null;
        }
    }

    @Override
    public String toString() {
        return String.format("%s(%s)", name(), displayName);
    }
} 