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

/**
 * 规则执行状态枚举
 * 定义规则执行过程中的各种状态
 * 
 * @author AI Assistant
 * @version 1.0
 * @since 2025-01-17
 */
public enum RuleExecutionStatus {
    /**
     * 待执行
     * 规则已被触发，等待执行
     */
    PENDING("待执行", "规则已被触发，等待执行"),
    
    /**
     * 执行中
     * 规则正在执行过程中
     */
    EXECUTING("执行中", "规则正在执行过程中"),
    
    /**
     * 执行成功
     * 规则执行完成且成功
     */
    SUCCESS("执行成功", "规则执行完成且成功"),
    
    /**
     * 执行失败
     * 规则执行过程中发生错误
     */
    FAILED("执行失败", "规则执行过程中发生错误"),
    
    /**
     * 部分成功
     * 规则执行部分成功，有些动作未完成
     */
    PARTIAL_SUCCESS("部分成功", "规则执行部分成功，有些动作未完成"),
    
    /**
     * 已跳过
     * 由于条件不满足或其他原因跳过执行
     */
    SKIPPED("已跳过", "由于条件不满足或其他原因跳过执行"),
    
    /**
     * 超时
     * 规则执行超过预定时间限制
     */
    TIMEOUT("超时", "规则执行超过预定时间限制"),
    
    /**
     * 已取消
     * 规则执行被手动取消
     */
    CANCELLED("已取消", "规则执行被手动取消"),
    
    /**
     * 重试中
     * 规则执行失败后正在重试
     */
    RETRYING("重试中", "规则执行失败后正在重试");

    private final String displayName;
    private final String description;

    RuleExecutionStatus(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 isFinalState() {
        switch (this) {
            case SUCCESS:
            case FAILED:
            case PARTIAL_SUCCESS:
            case SKIPPED:
            case TIMEOUT:
            case CANCELLED:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否为成功状态
     * @return 如果是成功状态返回true
     */
    public boolean isSuccessful() {
        return this == SUCCESS || this == PARTIAL_SUCCESS;
    }

    /**
     * 检查是否为失败状态
     * @return 如果是失败状态返回true
     */
    public boolean isFailed() {
        switch (this) {
            case FAILED:
            case TIMEOUT:
            case CANCELLED:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否为进行中状态
     * @return 如果是进行中状态返回true
     */
    public boolean isInProgress() {
        switch (this) {
            case PENDING:
            case EXECUTING:
            case RETRYING:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否可以重试
     * @return 如果可以重试返回true
     */
    public boolean canRetry() {
        switch (this) {
            case FAILED:
            case TIMEOUT:
            case PARTIAL_SUCCESS:
                return true;
            default:
                return false;
        }
    }

    /**
     * 检查是否可以取消
     * @return 如果可以取消返回true
     */
    public boolean canCancel() {
        switch (this) {
            case PENDING:
            case EXECUTING:
            case RETRYING:
                return true;
            default:
                return false;
        }
    }

    /**
     * 获取状态的优先级（用于排序显示）
     * @return 优先级数值，数值越小优先级越高
     */
    public int getPriority() {
        switch (this) {
            case EXECUTING:
                return 1;
            case RETRYING:
                return 2;
            case PENDING:
                return 3;
            case FAILED:
                return 4;
            case TIMEOUT:
                return 5;
            case PARTIAL_SUCCESS:
                return 6;
            case CANCELLED:
                return 7;
            case SKIPPED:
                return 8;
            case SUCCESS:
                return 9;
            default:
                return 10;
        }
    }

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

    /**
     * 获取可以转换到的下一个状态列表
     * @return 可转换的状态列表
     */
    public RuleExecutionStatus[] getNextPossibleStates() {
        switch (this) {
            case PENDING:
                return new RuleExecutionStatus[]{EXECUTING, SKIPPED, CANCELLED};
            case EXECUTING:
                return new RuleExecutionStatus[]{SUCCESS, FAILED, PARTIAL_SUCCESS, TIMEOUT, CANCELLED};
            case RETRYING:
                return new RuleExecutionStatus[]{SUCCESS, FAILED, PARTIAL_SUCCESS, TIMEOUT, CANCELLED};
            case FAILED:
            case TIMEOUT:
            case PARTIAL_SUCCESS:
                return new RuleExecutionStatus[]{RETRYING};
            case SUCCESS:
            case SKIPPED:
            case CANCELLED:
            default:
                return new RuleExecutionStatus[]{}; // 终态，无法转换
        }
    }

    /**
     * 检查是否可以转换到指定状态
     * @param targetStatus 目标状态
     * @return 如果可以转换返回true
     */
    public boolean canTransitionTo(RuleExecutionStatus targetStatus) {
        if (targetStatus == null) {
            return false;
        }
        
        for (RuleExecutionStatus allowedState : getNextPossibleStates()) {
            if (allowedState == targetStatus) {
                return true;
            }
        }
        return false;
    }

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