package cn.huge.module.cust.constant;

import cn.huge.module.cust.dto.CtUserDTO;
import org.apache.commons.lang3.StringUtils;

/**
 * @title: 调解相关常量枚举类
 * @description: 调解相关常量枚举类
 * @company: hugeinfo
 * @author: liyj
 * @time: 2021-11-05 16:51:48
 * @version: 1.0.0
 */
public enum RoleBaseEnum {

    /**
     * 平台基础角色
     */
    ROLE_1("22_00024-1", "运维技术人员"),
    ROLE_2("22_00024-2", "超级管理员"),
    ROLE_3("22_00024-3", "组织管理员"),
    ROLE_4("22_00024-4", "人民调解员"),
    ROLE_5("22_00024-5", "法官"),
    ROLE_6("22_00024-6", "法院"),
    ROLE_7("22_00024-7", "调度人员"),
    ROLE_8("22_00024-8", "法官助理/书记员"),
    ROLE_9("22_00024-9", "调委会管理员"),
    ROLE_10("22_00024-10", "司法局");

    /**
     * 代码编号
     */
    private String index;

    /**
     * 描述
     */
    private String des;

    public String getIndex() {
        return index;
    }

    public void setIndex(String index) {
        this.index = index;
    }

    public String getDes() {
        return des;
    }

    public void setDes(String desc) {
        this.des = desc;
    }

    /**
     * 构造方法
     * @param index
     * @param des
     */
    RoleBaseEnum(String index, String des) {
        this.index = index;
        this.des = des;
    }

    /**
     * 静态方法
     * @param index
     * @return
     */
    public static String getDes(String index) {
        for (RoleBaseEnum constantEnum : RoleBaseEnum.values()) {
            if (constantEnum.getIndex().equals(index)) {
                return constantEnum.des;
            }
        }
        return null;
    }

    /**
     * 判断是否有超级管理员权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkAdminPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_1.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_2.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_7.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 临时-演示用户赋予超级管理员角色
     * 判断是否有超级管理员权限
     * @param loginUser 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkAdminPower(CtUserDTO loginUser){
        String acc = loginUser.getAcc();
        if ("yanstjy".equals(acc) || "yansjdb".equals(acc)){
            return true;
        }
        String roleCodes = loginUser.getRoleCodes();
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_1.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_2.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_7.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有组织管理员权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkUnitPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_3.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有调委会管理员权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkTwhPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_9.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有是个人权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkUserPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_4.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_5.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_8.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否是法院或组织管理员的权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkCourtOrUnitPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_3.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_6.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否是法院的权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkCourtPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_5.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_6.getIndex()) != -1 ||
                    roleCodes.indexOf(ROLE_8.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有法院管理权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkCourtAdminPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_6.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有法官权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkJudgePower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_5.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有调度权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkDispPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_7.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }

    /**
     * 判断是否有司法局权限
     * @param roleCodes 角色代码编号，多个用,分开
     * @return Boolean
     */
    public static Boolean checkSfjPower(String roleCodes){
        if (StringUtils.isNotEmpty(roleCodes)) {
            if (roleCodes.indexOf(ROLE_10.getIndex()) != -1) {
                return true;
            } else {
                return false;
            }
        }else {
            return false;
        }
    }
}