package com.zcxk.core.common.util;

import com.zcxk.core.common.enums.RespCodeEnum;
import com.zcxk.core.common.exception.BusinessException;
import com.zcxk.core.common.support.RespCode;
import org.springframework.util.StringUtils;

import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author Andy
 * @description: 数据校验
 * @date 2021/7/16
 * @version V1.0
 **/
public class AssertUtil {

    /**
     * 默认区号
     */
    private static final String NATION_CODE = "86";

    private static String regex = "\\+(9[976]\\d|8[987530]\\d|6[987]\\d|5[90]\\d|42\\d|3[875]\\d|\n" +
        "2[98654321]\\d|9[8543210]|8[6421]|6[6543210]|5[87654321]|\n" +
        "4[987654310]|3[9643210]|2[70]|7|1)\\d{1,14}$";

    private static Pattern regexPattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);

    private static String regex86 = "^(\\+\\d{2}-)([1][3,4,5,6,7,8,9]\\d{9})$";

    private static Pattern regex86Pattern = Pattern.compile(regex86, Pattern.CASE_INSENSITIVE);

    private static Pattern  idCardPattern = Pattern.compile ("(^\\d{15}$)|(^\\d{18}$)|(^\\d{17}(\\d|X|x)$)");

    private static Pattern regexNumber = Pattern.compile("[0-9]*");
    /**
     * 校验邮箱地址
     * @param email
     * @return
     */
    public static boolean checkEmail(String email) {
        return email.matches("^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\\.[a-zA-Z0-9_-]+)+$");
    }
    /**
     * 身份证号码保护 如：4304*****7733
     * @param idCardNo 证件号码
     * @return
     */
    public static String idCardProtectPrivacy(String idCardNo){
        return idCardNo.replaceAll("(\\d{4})\\d{10}(\\w{4})","$1*****$2");
    }
    /**
     * 手机号保护 如：152****4799
     * @param mobile 手机号
     * @return
     */
    public static String mobileProtectPrivacy(String mobile){
        return mobile.replaceAll("(\\d{3})\\d{4}(\\d{4})","$1****$2");
    }
    /**
     * 校验qq号码
     * @param qq
     * @return
     */
    public static boolean checkQq(String qq){
        //因为必须要求至少5位，所以第五位相当于就是第一位，{}里面是索引
       boolean flag=qq.matches("[1-9][0-9]{4,14}");
       return flag;
    }
    /**
     * 身份证格式校验
     * @param cardNo 身份证号码
     * @return
     */
    public static boolean checkCardNo(String cardNo){
        Matcher matcher = idCardPattern.matcher(cardNo);
        boolean b = matcher.find();
        return b;
    }
    /**
     * 校验手机号是否正确
     *
     * @param nationCode
     * @param mobile
     * @return
     */
    public static boolean isCheckMobile (String nationCode, String mobile){
        if (StringUtils.isEmpty(nationCode)) {
            nationCode = NATION_CODE;
        }
        if (StringUtils.pathEquals(NATION_CODE, nationCode)) {
            Matcher m86 = regex86Pattern.matcher("+86-" + mobile);
            return m86.matches();
        }
        Matcher m = regexPattern.matcher("+" + nationCode + mobile);
        return m.matches();
    }

    /**
     * 检查字符串是否为空，为空时则返回统一json报文给前端； 状态码统一返回G-601
     *
     * @param str 字符串
     * @param parameterName 参数名称，会统一返回：缺少参数【参数】
     */
    public static void isBlankUnifyMsg(String str, String parameterName) {
        isBlank(str, String.format(RespCodeEnum.GLOBAL_PARAMETER_NOT_NULL.getMessage(),parameterName),
            RespCodeEnum.GLOBAL_PARAMETER_NOT_NULL.getStatus());
    }

    /**
     * 检查字符串是否为空，为空时则返回统一json报文给前端； 状态码统一返回G-601
     * @param str 字符串
     * @param message 检验失败，提示语
     */
    public static void isBlank(String str, String message) {
        isBlank(str, message,RespCodeEnum.GLOBAL_PARAMETER_NOT_NULL.getStatus());
    }

    /**
     * 检查字符串是否为空，为空时则返回统一json报文给前端 自定义，状态码
     *
     * @param str 字符串
     * @param message 校验失败，提示语
     * @param code 状态码
     */
    public static void isBlank(String str, String message, int code) {
        str = "undefined".equals(str) ? "" : str;
        if (StringUtils.isEmpty(str)) {
            throw BusinessException.builder(code,message);
        }
    }

    /**
     * 校验是否为空，为空时则返回统一json报文给前端； 状态码默认为500
     *
     * @param object 校验类型
     * @param message 校验失败，提示语
     */
    public static void isNull(Object object, String message) {
        isNull(object, message, RespCodeEnum.GLOBAL_PARAMETER_NOT_NULL.getStatus());
    }

    /**
     * 校验是否为空，为空时则返回统一json报文给前端； 自定义，状态码
     * @param object 校验类型
     * @param message 校验失败，提示语
     * @param code 状态码
     */
    public static void isNull(Object object, String message, int code) {
        if (object == null || "".equals(object)) {
            throw BusinessException.builder(code,message);
        }
    }

    /**
     * 校验是否为空，为空时则返回统一json报文给前端； 继承RespCode的自定义错误
     * @param object 校验数据
     * @param respCode 错误信息
     */
    public static void isNull(Object object, RespCode respCode) {
        if (isEmpty(object)) {
            throw BusinessException.builder(respCode);
        }
    }

    /**
     * @描述：是否是2003的excel，返回true是2003
     */
    public static boolean isExcel2003(String filePath) {
        return filePath.matches("^.+\\.(?i)(xls)$");
    }

    /**
     * @描述：是否是2007的excel，返回true是2007
     */
    public static boolean isExcel2007(String filePath) {
        return filePath.matches("^.+\\.(?i)(xlsx)$");
    }

    /**
     * 验证EXCEL文件
     */
    public static boolean validateExcel(String filePath) {
        if (filePath == null) {
            return false;
        }
        if (!(isExcel2003(filePath) || isExcel2007(filePath))) {
            return false;
        }
        return true;
    }

    /**
     * 判断对象为空
     *
     * @param obj 对象名
     * @return 是否为空
     */
    @SuppressWarnings("rawtypes")
    public static boolean isEmpty(Object obj) {
        if (obj == null) {
            return true;
        }
        if ((obj instanceof List)) {
            return ((List) obj).size() == 0;
        }
        if ((obj instanceof String)) {
            return "".equals(((String) obj).trim());
        }
        return false;
    }

    /**
     * 判断对象不为空
     *
     * @param obj 对象名
     * @return 是否不为空
     */
    public static boolean isNotEmpty(Object obj) {
        return !isEmpty(obj);
    }

    /**
     * 利用正则表达式判断字符串是否是数字
     */
    public static boolean isNumeric(String str) {
        Matcher isNum = regexNumber.matcher(str);
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }
}
