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

/**
 * 空间规则状态枚举
 * 定义空间规则的各种生命周期状态
 * 
 * @author AI Assistant
 * @version 1.0
 * @since 2025-01-17
 */
public enum RuleStatus {
    /**
     * 草稿状态
     * 规则已创建但尚未激活，可以进行编辑
     */
    DRAFT("草稿", "规则已创建但尚未生效，可以编辑"),
    
    /**
     * 活跃状态
     * 规则正在生效中，系统会执行该规则
     */
    ACTIVE("生效中", "规则正在生效中，系统正在执行该规则"),
    
    /**
     * 暂停状态
     * 规则被临时暂停，不会执行但保留配置
     */
    SUSPENDED("已暂停", "规则被临时暂停，暂不执行但保留配置"),
    
    /**
     * 已过期状态
     * 规则已过有效期，系统自动停止执行
     */
    EXPIRED("已过期", "规则已过有效期，系统自动停止执行"),
    
    /**
     * 已删除状态
     * 规则被标记为删除，但保留历史记录
     */
    DELETED("已删除", "规则被标记为删除，但保留历史记录"),
    
    /**
     * 配置错误状态
     * 规则配置存在错误，无法正常执行
     */
    ERROR("配置错误", "规则配置存在错误，无法正常执行");

    private final String displayName;
    private final String description;

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

    /**
     * 获取规则状态的显示名称
     * @return 显示名称
     */
    public String getDisplayName() {
        return displayName;
    }

    /**
     * 获取规则状态的描述信息
     * @return 描述信息
     */
    public String getDescription() {
        return description;
    }

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

    /**
     * 检查规则是否为可执行状态
     * @return 如果规则可以被执行返回true
     */
    public boolean isExecutable() {
        return this == ACTIVE;
    }

    /**
     * 检查规则是否为可编辑状态
     * @return 如果规则可以被编辑返回true
     */
    public boolean isEditable() {
        return this == DRAFT || this == SUSPENDED || this == ERROR;
    }

    /**
     * 检查规则是否为终止状态
     * @return 如果规则已终止（不可恢复）返回true
     */
    public boolean isTerminated() {
        return this == EXPIRED || this == DELETED;
    }

    /**
     * 检查规则是否为临时状态
     * @return 如果规则处于临时状态（可恢复）返回true
     */
    public boolean isTemporary() {
        return this == SUSPENDED || this == ERROR;
    }

    /**
     * 获取状态的优先级
     * 数值越小优先级越高，用于状态变更时的验证
     * @return 状态优先级
     */
    public int getPriority() {
        switch (this) {
            case DRAFT:
                return 1;
            case ACTIVE:
                return 2;
            case SUSPENDED:
                return 3;
            case ERROR:
                return 4;
            case EXPIRED:
                return 5;
            case DELETED:
                return 6;
            default:
                return 999;
        }
    }

    /**
     * 检查是否可以从当前状态变更到目标状态
     * @param targetStatus 目标状态
     * @return 如果可以变更返回true
     */
    public boolean canTransitionTo(RuleStatus targetStatus) {
        if (targetStatus == null) {
            return false;
        }
        
        // 已删除的规则不能变更到其他状态
        if (this == DELETED) {
            return false;
        }
        
        // 任何状态都可以变更为删除或错误状态
        if (targetStatus == DELETED || targetStatus == ERROR) {
            return true;
        }
        
        // 已过期的规则只能删除或修复错误
        if (this == EXPIRED) {
            return targetStatus == DELETED;
        }
        
        // 其他状态变更规则
        switch (this) {
            case DRAFT:
                return targetStatus == ACTIVE || targetStatus == SUSPENDED;
            case ACTIVE:
                return targetStatus == SUSPENDED || targetStatus == EXPIRED;
            case SUSPENDED:
                return targetStatus == ACTIVE || targetStatus == DRAFT;
            case ERROR:
                return targetStatus == DRAFT || targetStatus == ACTIVE || targetStatus == SUSPENDED;
            default:
                return false;
        }
    }

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