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

/**
 * 车辆类型路径编码枚举
 * 基于路径编码模式重构的车辆类型管理
 * 支持分层查询和业务属性判断
 * 
 * @author Claude Code
 * @version 2.0
 */
public enum VehicleTypeCode {
    
    // ========== 一级分类 ==========
    
    /** 无人车 */
    UV("UV", "无人车", "Unmanned Vehicle", 1, null, true, false, 30),
    /** 特勤车 */
    SP("SP", "特勤车", "Special Vehicle", 1, null, false, true, 80),
    /** 普通车 */
    NM("NM", "普通车", "Normal Vehicle", 1, null, false, false, 40),
    
    // ========== 二级分类 - 无人车具体类型 ==========
    
    /** 无人车 - 巡逻车 */
    UV_PT("UV.PT", "巡逻车", "Patrol Vehicle", 2, UV, true, false, 25),
    /** 无人车 - 配送车 */
    UV_DL("UV.DL", "配送车", "Delivery Vehicle", 2, UV, true, false, 30),
    /** 无人车 - 检查车 */
    UV_IN("UV.IN", "检查车", "Inspection Vehicle", 2, UV, true, false, 20),
    /** 无人车 - 接驳车 */
    UV_SH("UV.SH", "接驳车", "Shuttle Vehicle", 2, UV, true, false, 35),
    /** 无人车 - 驱鸟车 */
    UV_BD("UV.BD", "驱鸟车", "Bird Deterrent Vehicle", 2, UV, true, false, 25),
    
    // ========== 二级分类 - 特勤车具体类型 ==========
    
    /** 特勤车 - 消防车 */
    SP_FT("SP.FT", "消防车", "Fire Truck", 2, SP, false, true, 60),
    /** 特勤车 - 警车 */
    SP_PC("SP.PC", "警车", "Police Car", 2, SP, false, true, 80),
    /** 特勤车 - 救护车 */
    SP_AM("SP.AM", "救护车", "Ambulance", 2, SP, false, true, 70),
    /** 特勤车 - 引导车 */
    SP_FM("SP.FM", "引导车", "Follow Me Car", 2, SP, false, true, 50),
    /** 特勤车 - 安保车 */
    SP_SC("SP.SC", "安保车", "Security Car", 2, SP, false, true, 60),
    
    // ========== 二级分类 - 普通车具体类型 ==========
    
    /** 普通车 - 行李车 */
    NM_BG("NM.BG", "行李车", "Baggage Cart", 2, NM, false, false, 25),
    /** 普通车 - 清洁车 */
    NM_CL("NM.CL", "清洁车", "Cleaning Vehicle", 2, NM, false, false, 20),
    /** 普通车 - 餐车 */
    NM_CT("NM.CT", "餐车", "Catering Truck", 2, NM, false, false, 25),
    /** 普通车 - 拖车 */
    NM_TG("NM.TG", "拖车", "Tug Vehicle", 2, NM, false, false, 15),
    /** 普通车 - 加油车 */
    NM_FL("NM.FL", "加油车", "Fuel Truck", 2, NM, false, false, 20),
    /** 普通车 - 维护车 */
    NM_MT("NM.MT", "维护车", "Maintenance Vehicle", 2, NM, false, false, 30),
    /** 普通车 - 运输车 */
    NM_TR("NM.TR", "运输车", "Transport Truck", 2, NM, false, false, 40);
    
    private final String code;                    // 路径编码
    private final String displayNameCn;           // 中文显示名称
    private final String displayNameEn;           // 英文显示名称
    private final int level;                      // 层级
    private final VehicleTypeCode parent;         // 父类型
    private final boolean isAutonomous;           // 是否自动驾驶
    private final boolean hasSpecialPrivileges;   // 是否有特殊权限
    private final int maxSpeedKmh;               // 最大速度(km/h)
    
    VehicleTypeCode(String code, String displayNameCn, String displayNameEn, int level, 
                   VehicleTypeCode parent, boolean isAutonomous, boolean hasSpecialPrivileges, int maxSpeedKmh) {
        this.code = code;
        this.displayNameCn = displayNameCn;
        this.displayNameEn = displayNameEn;
        this.level = level;
        this.parent = parent;
        this.isAutonomous = isAutonomous;
        this.hasSpecialPrivileges = hasSpecialPrivileges;
        this.maxSpeedKmh = maxSpeedKmh;
    }
    
    // ========== Getter方法 ==========
    
    public String getCode() {
        return code;
    }
    
    public String getDisplayNameCn() {
        return displayNameCn;
    }
    
    public String getDisplayNameEn() {
        return displayNameEn;
    }
    
    public int getLevel() {
        return level;
    }
    
    public VehicleTypeCode getParent() {
        return parent;
    }
    
    public boolean isAutonomous() {
        return isAutonomous;
    }
    
    public boolean hasSpecialPrivileges() {
        return hasSpecialPrivileges;
    }
    
    public int getMaxSpeedKmh() {
        return maxSpeedKmh;
    }
    
    // ========== 业务判断方法 ==========
    
    /**
     * 判断是否为无人车
     */
    public boolean isUnmannedVehicle() {
        return getTopLevelType() == UV;
    }
    
    /**
     * 判断是否为特勤车
     */
    public boolean isSpecialVehicle() {
        return getTopLevelType() == SP;
    }
    
    /**
     * 判断是否为普通车
     */
    public boolean isNormalVehicle() {
        return getTopLevelType() == NM;
    }
    
    /**
     * 判断是否为紧急车辆
     */
    public boolean isEmergencyVehicle() {
        return this == SP_FT || this == SP_PC || this == SP_AM;
    }
    
    /**
     * 获取一级分类
     */
    public VehicleTypeCode getTopLevelType() {
        if (level == 1) {
            return this;
        }
        return parent;
    }
    
    /**
     * 获取完整路径描述
     */
    public String getFullPath() {
        if (parent == null) {
            return displayNameCn;
        }
        return parent.getDisplayNameCn() + "/" + displayNameCn;
    }
    
    // ========== 静态查询方法 ==========
    
    /**
     * 根据路径编码查找车辆类型
     */
    public static VehicleTypeCode fromCode(String code) {
        for (VehicleTypeCode type : values()) {
            if (type.code.equals(code)) {
                return type;
            }
        }
        throw new IllegalArgumentException("未知的车辆类型编码: " + code);
    }
    
    /**
     * 根据路径编码查找车辆类型（安全版本）
     */
    public static VehicleTypeCode fromCodeSafe(String code) {
        for (VehicleTypeCode type : values()) {
            if (type.code.equals(code)) {
                return type;
            }
        }
        return null;
    }
    
    /**
     * 获取所有一级分类
     */
    public static VehicleTypeCode[] getTopLevelTypes() {
        return new VehicleTypeCode[]{UV, SP, NM};
    }
    
    /**
     * 获取指定父类型的所有子类型
     */
    public static VehicleTypeCode[] getChildTypes(VehicleTypeCode parent) {
        return java.util.Arrays.stream(values())
                .filter(type -> type.parent == parent)
                .toArray(VehicleTypeCode[]::new);
    }
    
    /**
     * 获取所有无人车类型
     */
    public static VehicleTypeCode[] getUnmannedVehicleTypes() {
        return getChildTypes(UV);
    }
    
    /**
     * 获取所有特勤车类型
     */
    public static VehicleTypeCode[] getSpecialVehicleTypes() {
        return getChildTypes(SP);
    }
    
    /**
     * 获取所有普通车类型
     */
    public static VehicleTypeCode[] getNormalVehicleTypes() {
        return getChildTypes(NM);
    }
    
    /**
     * 获取所有紧急车辆类型
     */
    public static VehicleTypeCode[] getEmergencyVehicleTypes() {
        return java.util.Arrays.stream(values())
                .filter(VehicleTypeCode::isEmergencyVehicle)
                .toArray(VehicleTypeCode[]::new);
    }
    
    @Override
    public String toString() {
        return code + "(" + displayNameCn + ")";
    }
}