package cn.com.ty.lift.common.verify;

import cn.hutool.core.util.ObjectUtil;

/**
 * <p>
 *     条件判断，如果不符合条件，抛出异常
 * </p>
 * @author wcz
 * @since  2020/1/9 8:46
 */
public interface Verify {

    String IDENTIFIER_INVALID      = "标识ID无效";
    String MUST_GT0                = "数值必须大于0";
    String MUST_LT0                = "数值必须小于0";
    String MUST_EQ0                = "数值必须等于0";
    String MUST_NGT0               = "数值必须大于或等于0";
    String MUST_NLT0               = "数值必须小于或等于0";
    String MUST_NEQ0               = "数值必须不等于0";
    String DATA_MUST_EMPTY         = "数据必须为空";
    String DATA_MISSING_INCORRECT  = "缺少相关数据";
    String DATA_INVALID_CONDITIONS = "数据无效或条件不成立";

    static VerifyException judgeException(String message){
        return new VerifyException(message);
    }

    static boolean yesNull(Object value){
        return null == value;
    }

    static boolean noNull(Object value){
        return null != value;
    }

    static int compare0(Number value){
        if(isLong(value)){
            return Long.compare(value.longValue(), 0);
        }else if (isInteger(value)){
            return Integer.compare(value.intValue(), 0);
        }else if(isDouble(value)){
            return Double.compare(value.doubleValue(), 0);
        }else if(isFloat(value)){
            return Float.compare(value.floatValue(), 0);
        }else if(isByte(value)){
            return Byte.compare(value.byteValue(), (byte) 0);
        }else if(isShort(value)){
            return Short.compare(value.shortValue(), (short) 0);
        }else {
            return -2;
        }
    }

    //compare0 > 0
    static boolean gt0(Number value) {
        return compare0(value) > 0;
    }

    //compare0 < 0
    static boolean lt0(Number value) {
        return compare0(value) < 0;
    }

    static boolean gte0(Number value) {
        return compare0(value) >= 0;
    }

    static boolean lte0(Number value) {
        return compare0(value) <= 0;
    }

    static boolean eq0(Number value){
        return compare0(value) == 0;
    }
    static boolean neq0(Number value){
        return compare0(value) != 0;
    }

    static boolean isLong(Object value){
        return (value instanceof Long);
    }
    static boolean isInteger(Object value){
        return (value instanceof Integer);
    }
    static boolean isDouble(Object value){
        return (value instanceof Double);
    }
    static boolean isFloat(Object value){
        return (value instanceof Float);
    }
    static boolean isByte(Object value){
        return (value instanceof Byte);
    }
    static boolean isShort(Object value){
        return (value instanceof Short);
    }

    /**
     * 判断对象object是否为空，如果不为空,直接抛出异常，返回message
     *
     * @param object  参数值
     * @param message 抛出异常的消息
     */
    static void isNull(Object object, String message) {
        notTrue(noNull(object), message);
    }

    /**
     * 判断对象object是否为空，如果不为空,直接抛出异常，返回默认消息
     *
     * @param object 参数值
     */
    static void isNull(Object object) {
        isNull(object, DATA_MISSING_INCORRECT);
    }

    /**
     * 判断对象object是否为空，如果为真,直接抛出异常，返回message
     *
     * @param object  参数值
     * @param message 抛出异常的消息
     */
    static void notNull(Object object, String message) {
        notTrue(yesNull(object), message);
    }

    /**
     * 判断对象object是否为空，如果为真,直接抛出异常，返回默认消息
     *
     * @param object 参数值
     */
    static void notNull(Object object) {
        notNull(object, DATA_MISSING_INCORRECT);
    }

    /**
     * 判断表达式是否为真，如果为假，直接抛出异常，返回message
     *
     * @param expression 需要判断的布尔表达式
     * @param message    抛出异常的消息
     */
    static void isTrue(boolean expression, String message) {
        if (!expression) {
            throw judgeException(message);
        }
    }

    /**
     * 判断表达式是否为真，如果为假，直接抛出异常，返回
     *
     * @param expression 需要判断的布尔表达式
     */
    static void isTrue(boolean expression) {
        isTrue(expression, DATA_INVALID_CONDITIONS);
    }

    /**
     * 判断表达式是否为真，如果为真，直接抛出异常，返回message
     *
     * @param expression 需要判断的布尔表达式
     * @param message    抛出异常的消息
     */
    static void notTrue(boolean expression, String message) {
        if (expression) {
            throw judgeException(message);
        }
    }

    /**
     * 判断表达式是否为真，如果为真，直接抛出异常，返回
     *
     * @param expression 需要判断的布尔表达式
     */
    static void notTrue(boolean expression) {
        notTrue(expression, DATA_INVALID_CONDITIONS);
    }

    /**
     * id == null || id <= 0 throw new VerifyException(message)
     * @param id id值
     * @param message 抛出异常消息
     */
    static void id(Long id, String message) {
        notNull(id, message);
        notTrue(lte0(id), message);
    }

    /**
     * id == null || id <= 0 throw new VerifyException(IDENTIFIER_INVALID)
     *
     * @param ids 不定个id值
     */
    static void id(Long... ids) {
        notNull(ids, IDENTIFIER_INVALID);
        for (Long id : ids) {
            notTrue(yesNull(id) || lte0(id), IDENTIFIER_INVALID);
        }
    }

    /**
     * value == null || value <= 0 throw new VerifyException(message);
     *
     * @param value 数值型的参数值
     * @param message 抛出异常中的消息
     */
    static void gt0(Number value, String message) {
        notNull(value, message);
        isTrue(gt0(value) ,message);
    }

    /**
     * value == null || value <= 0 throw new VerifyException(message);
     *
     * @param values 不定个数的数值型的值
     */
    static void gt0(Number... values) {
        notNull(values, MUST_GT0);
        for (Number value : values) {
            gt0(value, MUST_GT0);
        }
    }

    /**
     * value == null || value >= 0 throw new VerifyException(message);
     *
     * @param value 数值型的值
     * @param message 抛出异常的消息值
     */
    static void lt0(Number value, String message) {
        notNull(value, message);
        isTrue(lt0(value), message);
    }

    /**
     * value == null || value >= 0 throw new VerifyException(message);
     *
     * @param values 一个或多个的数值
     */
    static void lt0(Number... values) {
        notNull(values, MUST_LT0);
        for (Number value : values) {
            lt0(value, MUST_LT0);
        }
    }

    /**
     * value == null || value != 0 throw new VerifyException(message);
     *
     * @param value 数值型的值
     * @param message 抛出异常的消息
     */
    static void eq0(Number value, String message) {
        notNull(value, message);
        isTrue(eq0(value), message);
    }

    /**
     * value == null || value != 0 throw new VerifyException(message);
     * @param values 一个或多个数的数值
     */
    static void eq0(Number... values) {
        notNull(values, MUST_EQ0);
        for (Number value : values) {
            eq0(value, MUST_EQ0);
        }
    }

    /**
     * value == null || value < 0 throw new VerifyException(message)
     *
     * @param value 数值型的值
     * @param message 抛出异常的消息
     */
    static void nogt0(Number value, String message) {
        notNull(value, message);
        isTrue(lte0(value), message);
    }

    /**
     * value == null || value < 0 throw new VerifyException(message);
     *
     * @param values 一个或多个数的数值型的值
     */
    static void nogt0(Number... values) {
        notNull(values, MUST_NGT0);
        for (Number value : values) {
            nogt0(value, MUST_NGT0);
        }
    }

    /**
     * value == null || value > 0 throw new VerifyException(message);
     *
     * @param value 数值型的值
     * @param message 抛出异常的消息
     */
    static void nolt0(Number value, String message) {
        notNull(value, message);
        isTrue(gte0(value), message);
    }

    /**
     * value == null || value > 0 throw new VerifyException(message);
     *
     * @param values 一个或多个数的数值
     */
    static void nolt0(Number... values) {
        notNull(values, MUST_NLT0);
        for (Number value : values) {
            nolt0(value, MUST_NLT0);
        }
    }

    /**
     * value == null || value == 0 throw new VerifyException(message);
     *
     * @param value 数值型的值
     * @param message 抛出异常的消息
     */
    static void noeq0(Number value, String message) {
        notNull(value, message);
        isTrue(neq0(value), message);
    }

    /**
     * value == null || value != 0 throw new VerifyException(message);
     *
     * @param values 一个或多个数的数值
     */
    static void noeq0(Number... values) {
        notNull(values, MUST_NEQ0);
        for (Number value : values) {
            noeq0(value, MUST_NEQ0);
        }
    }


    static void notEmpty(Object object, String message) {
        notTrue(ObjectUtil.isEmpty(object), message);
    }

    static void notEmpty(Object object) {
        notEmpty(object, DATA_MISSING_INCORRECT);
    }

    static void isEmpty(Object object, String message) {
        notTrue(ObjectUtil.isNotEmpty(object), message);
    }

    static void isEmpty(Object object) {
        isEmpty(object, DATA_MUST_EMPTY);
    }

    static void isBlank(CharSequence cs, String message) {
        isNull(cs, message);
        isTrue(cs.toString().trim().isEmpty(), message);
    }

    static void notBlank(CharSequence cs, String message) {
        notNull(cs, message);
        notTrue(cs.toString().trim().isEmpty(), message);
    }

    //======================年检相关状态值和判断方法======================================

    interface Inspection{
        /**
         * 年检未开始0
         */
        int STEP_NOT_START                          = 0;

        /**
         * 判断年检是否开始
         * @param step
         * @return
         */
        static boolean notStart(int step){
            return STEP_NOT_START == step;
        }
        /**
         * 年检 第一阶段
         */
        int STEP_ONE                                = 1;

        /**
         * 判断是否为年检阶段一
         * @param step
         * @return
         */
        static boolean stepOne(int step){
            return STEP_ONE == step;
        }
        /**
         * 年检 第二阶段
         */
        int STEP_TWO                                = 2;

        /**
         * 判断是否为年检阶段二
         * @param step
         * @return
         */
        static boolean stepTwo(int step){
            return STEP_TWO == step;
        }
        /**
         * 年检 第三阶段
         */
        int STEP_THREE                              = 3;

        /**
         * 判断是否为年检阶段三
         * @param step
         * @return
         */
        static boolean stepThree(int step){
            return STEP_THREE == step;
        }
        /**
         * 年检 第四阶段
         */
        int STEP_FOUR                               = 4;

        /**
         * 判断是否为年检阶段四
         * @param step
         * @return
         */
        static boolean stepFour(int step){
            return STEP_FOUR == step;
        }

        /**
         * 0 年检计划初始状态
         */
        int STATUS_NOT_START                        = 0;

        static boolean statusNotStart(int status){
            return STEP_NOT_START == status;
        }
        /**
         * 1  维保工确认年检计划
         */
        int STATUS_CONFIRM                          = 1;
        String confirm                              = "年检不存在，请确认年检计划";

        static boolean statusConfirm(int status){
            return STATUS_CONFIRM == status;
        }
        /**
         * 2  维保工上传自检报告,选择自检时间 或者 文员设置 是否检查限速器和荷载年检设置，
         *             文员也可以上传自检报告或者确认自检报告和自检时间，自检时间以最后设置的为准
         */
        int STATUS_SELFCHECK                        = 2;

        String selfcheckUpload                      = "请完善自检报告信息";
        String selfcheckDate                        = "请设置自检时间";
        String selfcheckReportImg                   = "请设置自检报告";

        static boolean statusSelfcheck(int status){
            return STATUS_SELFCHECK == status;
        }
        /**
         * 3  企业文员确认现场检验时间
         *             录入人员信息，政府质检，企业质检，联系电话
         */
        int STATUS_CHECK_CONFIRM                    = 3;
        String checkConfirm                         = "请确认检验结果";
        String checkDate                            = "请设置现场检验时间";
        String checkResultImg                       = "请设置现场检验结果";
        String inspector                            = "请设置政府质检人员";
        String operator                             = "请设置公司质检人员";
        String telephone                            = "请设置人员联系电话";

        static boolean statusCheckConfirm(int status){
            return STATUS_CHECK_CONFIRM == status;
        }
        /**
         * 4	维保工上传检验结果
         */
        int STATUS_CHECK_UPLOAD                     = 4;

        static boolean statusCheckUpload(int status){
            return STATUS_CHECK_UPLOAD == status;
        }
        /**
         * 5	企业文员确认检验结果-合格 --> 不能算年检超期
         */
        int STATUS_CHECK_QUALIFIED                  = 5;

        static boolean statusCheckQualified(int status){
            return STATUS_CHECK_QUALIFIED == status;
        }
        /**
         * 6	企业文员确认检验结果-整改 --> 回到第二阶段
         */
        int STATUS_CHECK_RECTIFICATION              = 6;

        static boolean statusCheckRectification(int status){
            return STATUS_CHECK_RECTIFICATION == status;
        }
        /**
         * 7	企业文员确认检验结果-不合格 --> 可以算年检超期
         */
        int STATUS_CHECK_UNQUALIFIED                = 7;

        static boolean statusCheckUnqualified(int status){
            return STATUS_CHECK_UNQUALIFIED == status;
        }
        /**
         * 8	维保工上传年检报告和合格证
         */
        int STATUS_CERTIFICATE_REPORT_UPLOAD        = 8;
        String certificateReportUpload              = "请上传年检报告和合格证";

        static boolean statusCertificateReportUpload(int status){
            return STATUS_CERTIFICATE_REPORT_UPLOAD == status;
        }
        /**
         * 9	企业文员确认年检报告和合格证-合格
         */
        int STATUS_CERTIFICATE_REPORT_QUALIFIED     = 9;
        String nextInspectionTime                   = "请设置下次年检时间";

        static boolean statusCertificateReportQualified(int status){
            return STATUS_CERTIFICATE_REPORT_QUALIFIED == status;
        }
        /**
         * 10	企业文员确认年检报告和合格证-不合格 -->停用电梯
         */
        int STATUS_CERTIFICATE_REPORT_UNQUALIFIED   = 10;

        static boolean statusCertificateReportUnqualified(int status){
            return STATUS_CERTIFICATE_REPORT_UNQUALIFIED == status;
        }
        String statusError                          = "年检状态有误";

        /**
         * 根据年检的状态值返回成年检的状态阶段
         * @param stepStatus 年检状态值
         * @return int
         */
        static int status2StepName(Integer stepStatus){
            int stepName;
            switch (stepStatus){
                case STATUS_NOT_START:
                    stepName = 0;
                    break;
                case STATUS_CONFIRM:
                case STATUS_SELFCHECK:
                    stepName = 1;
                    break;
                case STATUS_CHECK_CONFIRM:
                    stepName = 2;
                    break;
                case STATUS_CHECK_UPLOAD:
                case STATUS_CHECK_QUALIFIED:
                case STATUS_CHECK_RECTIFICATION:
                case STATUS_CHECK_UNQUALIFIED:
                    stepName = 3;
                    break;
                case STATUS_CERTIFICATE_REPORT_UPLOAD:
                case STATUS_CERTIFICATE_REPORT_QUALIFIED:
                case STATUS_CERTIFICATE_REPORT_UNQUALIFIED:
                    stepName = 4;
                    break;
                default:
                    stepName = -1;
                    break;
            }
            return stepName;
        }


        /**
         * 判断年检状态是否处于其他阶段之间 min < middle < max
         * @param middle 中间值
         * @param min 最小值
         * @param max 最大值
         * @return boolean
         */
        static boolean inStatus(int min, int middle,int max){
            return min <= middle && middle <= max;
        }

        /**
         * 判断两个年检状态是否一样 one == two
         * @param one 一个值
         * @param other 另一个值
         * @return boolean
         */
        static boolean sameStatus(int one,int other){
            return one == other;
        }

        /**
         * 判断年检中一个状态是否为另一个状态的下一个状态
         * @param front 前一个值
         * @param behind 后一个值
         * @return boolean
         */
        static boolean nextStatus(int front,int behind){
            return front + 1 == behind;
        }

        /**
         * 判断年检中两个状态相同或者为下一个状态
         * @param front 前一个值
         * @param behind 后一个值
         * @return boolean
         */
        static boolean sameNext(int front,int behind){
            return front == behind || front + 1 == behind;
        }

        //==============================================================================
    }

    interface Repair{
        //===================急修相关状态值和判断方法======================================
        /**
         * 急修状态（-1 暂停中）
         */
        int STATUS_STOPING          = -1;

        static boolean statusStoping(int status){
            return STATUS_STOPING == status;
        }
        /**
         * 急修状态（0 待修理）
         */
        int STATUS_TO_REPAIRED      = 0;

        static boolean statusToRepaired(int status){
            return STATUS_TO_REPAIRED == status;
        }
        /**
         * 急修状态（1 修理中）
         */
        int STATUS_REPAIRING        = 1;

        static boolean statusRepairing(int status){
            return STATUS_REPAIRING == status;
        }
        /**
         * 急修状态（2 完成）
         */
        int STATUS_FINISH           = 2;

        static boolean statusFinish(int status){
            return STATUS_FINISH == status;
        }
        /**
         * 急修状态（3 关闭）
         */
        int STATUS_CLOSE            = 3;
        static boolean statusClose(int status){
            return STATUS_CLOSE == status;
        }

        String haveUnfinisedRepair = "该电梯存在未完成的急修，无法创建";
        String repairHadTaked      = "急修已经接单，不能转派";
        String mustToRepair        = "待急修才能操作";
        String mustInRepairing     = "急修中才能操作";
        String missingFault        = "缺少故障信息";
        String mustFinish          = "急修完成后才能操作";
        String hadEvaluate         = "急修已经评价了";
        String incorrectAmount     = "金额有误";
        String inspection          = "电梯正在年检中,无法创建";

        //==============================================================================
    }

    interface Upload{
        //===================上传相关状态值和判断方法======================================
        /**
         * 图片上传最大大小10M * 1024 * 1024
         */
        long maxSizePic             = 10 << 20;
        String maxSizePicDesc       = "10M";
        /**
         * 文件上传最大大小50M * 1024 * 1024
         */
        long maxSizeFile            = 50 << 20;
        String maxSizeFileDesc      = "50M";
        /**
         * 视频上传最大大小100M * 1024 * 1024
         */
        long maxSizeVideo           = 100 << 20;
        String maxSizeVideoDesc     = "100M";

        /**
         * 上传图片文件类型
         */
        String[] pics               = {".jpg",".jpeg", ".png", ".bmp", ".gif"};
        /**
         * 上传其他文件类型
         */
        String[] files              = {".pdf",".txt",".rar",".zip",".7z", ".xls", ".xlsx", ".doc",".docx",".ppt",".pptx"};
        /**
         * 上传视频文件类型
         */
        String[] videos             = {".mov",".mp4", ".avi",".mpg",".mpeg",".rm",".rmvb",".wmv"};


        String fileDataMissing      = "没有文件数据";
        String fileUploadFail       = "上传文件失败";
        String fileFormatNotSupport = "文件格式暂时不支持";
        String fileFormatIllegal    = "文件格式不合法";
        //==============================================================================
    }

    /**
     * 操作证相关常量
     */
    interface LiftCert{
        //0：无证，1：待审核，2：审核未通过，3：审核通过，4：超期
        int Status_Unlicense        = 0;
        int Status_ToAudit          = 1;
        int Status_AuditFail        = 2;
        int Status_AuditPass        = 3;
        int Status_Overdue          = 4;

        String MustToAudit          = "待审核才能操作";
        String CertHadExist         = "操作证已存在";
        String CertNotExist         = "操作证不存在";

        static boolean unlicense(int status){
            return status == Status_Unlicense;
        }
        static boolean toAudit(int status){
            return status == Status_ToAudit;
        }
        static boolean auditFail(int status){
            return status == Status_AuditFail;
        }
        static boolean auditPass(int status){
            return status == Status_AuditPass;
        }
        static boolean overdue(int status){
            return status == Status_Overdue;
        }
    }

    /**
     * 签到相关常量
     */
    interface Attend{
        String SetAmTime            = "请设置上午的上/下班时间";
        String SetPmTime            = "请设置下午的上/下班时间";
        String SetOtTime            = "请设置加班的上/下班时间";
        String InvalidAmTime        = "上午的上/下班时间有误";
        String InvalidPmTime        = "下午的上/下班时间有误";
        String InvalidOtTime        = "加班的上/下班时间有误";
        String AmTopClock           = "上午上班打卡";
        String AmDownClock          = "上午下班打卡";
        String PmTopClock           = "下午上班打卡";
        String PmDownClock          = "下午下班打卡";
        String OtTopClock           = "加班上班打卡";
        String OtDownClock          = "加班下班打卡";
        String hadClock             = "打卡记录已存在";
        String missingTime          = "请至少设置一组打卡时间";

        String AmDownPmTop = "下午的上班时间不得早于上午的下班时间";
        String PmDownOtTop = "加班的上班时间不得早于下午的下班时间";
    }

    interface Excel{
        String ValidDataMissing     = "未解析到有效数据";
        String FormatSupport        = "文件格式不支持，暂时只支持xls,xlsx";
        String[] excelSuffix        = {".xls",".xlsx"};
        /**
         * 一次导入表格的最大有效记录数
         */
        int maxRows                 = 5000;
        String outMaxRows           = "一次性导入不能超过5000条数据";
    }
}