package com.highdatas.mdm.util;


import com.baomidou.mybatisplus.annotations.TableName;
import com.highdatas.mdm.entity.Maintain;
import com.highdatas.mdm.entity.MaintainField;
import com.highdatas.mdm.entity.TUser;
import com.highdatas.mdm.entity.TableSchemaResult;
import com.highdatas.mdm.pojo.Segment;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.security.MessageDigest;
import java.text.MessageFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * @author kimi
 * @description
 * @date 2019-12-16 15:13
 */

@Slf4j
public class DbUtils {
    private static final char HEX_DIGITS[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

    public static String versionAddSub (String baseVersion) {
        if (StringUtils.isEmpty(baseVersion)) {
            return null;
        }
        String[] split = baseVersion.split(Constant.Dot);
        if (split.length == 1) {
            return null;
        }
        int smallVersion = Integer.valueOf(split[1]);
        smallVersion++;
        return MessageFormat.format("{0}.{1}",split[0], smallVersion);
    }
    

    public static Integer compareVersion(Maintain baseVersion, Maintain compareVersion) {
        if ((baseVersion == null) || (compareVersion == null)) {
            return null;
        }
       return  baseVersion.getOrderNo().compareTo(compareVersion.getOrderNo());
    }
    public static Integer compareVersion(MaintainField baseVersion, MaintainField compareVersion) {
        if ((baseVersion == null) || (compareVersion == null)) {
            return null;
        }
        return  baseVersion.getOrderNo().compareTo(compareVersion.getOrderNo());
    }

    public static String versionAddBig(String baseVersion) {
        if (StringUtils.isEmpty(baseVersion)) {
            return null;
        }
        String[] split = baseVersion.split(Constant.Dot);
        if (split.length == 1) {
            return null;
        }
        String bigVersionStr = split[0].substring(1);

        int bigVersion = Integer.valueOf(bigVersionStr);
        bigVersion++;
        return MessageFormat.format("V{0}.{1}",bigVersion, 0);
    }

    public static Integer getSubVersion(String baseVersion) {
        if (StringUtils.isEmpty(baseVersion)) {
            return null;
        }

        String[] split = baseVersion.split(Constant.Dot);
        if (split.length == 1) {
            return null;
        }
        return  Integer.valueOf(split[1]);
    }
    public static Integer getBigVersion(String baseVersion) {
        if (StringUtils.isEmpty(baseVersion)) {
            return null;
        }

        String[] split = baseVersion.split(Constant.Dot);
        if (split.length == 0 || split[0].length() < 2) {
            return null;
        }

        return  Integer.valueOf(split[0].substring(1));
    }


    public static String getUUID()  {
        String id = UUID.randomUUID().toString().replaceAll("-", "");
        return id;
    }
    public static String getUUID(int i)  {
        String id = UUID.randomUUID().toString().replaceAll("-", "").substring(0, i);
        return id;
    }

    public static String combieOneSegment(String name, String value) {
        Segment segment = new Segment(name, value);
        return segment.toString();
    }

    public static String getTableNameFromEntity(Object object) {
        Field[] fields = object.getClass().getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true);
            // 获取表名
            TableName table = object.getClass().getAnnotation(TableName.class);
            if (table != null) {
                String tableName = table.value();
                return tableName;
            }
        }
        return null;
    }

    public static Object toSqlToJava(String value, TableSchemaResult tableSchema) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException {
        String dbType = tableSchema.getDbType();
        String javaType = toSqlToJava(dbType);
        Class<?> baseWapperClaz = Class.forName("java.lang." + javaType);
        Object baseWapper = baseWapperClaz.newInstance();
        Method valueOfMethod = baseWapperClaz.getDeclaredMethod("valueOf");
        return null;
//        valueOfMethod.invoke(baseWapper, )
    }

    public static String toSqlToJava(String sqlType) {
        if( sqlType == null || sqlType.trim().length() == 0 ) return sqlType;
        sqlType = sqlType.toLowerCase();
        switch(sqlType){
            case "nvarchar":return "String";
            case "char":return "String";
            case "varchar":return "String";
            case "text":return "String";
            case "nchar":return "String";
            case "blob":return "byte[]";
            case "integer":return "Long";
            case "tinyint":return "Integer";
            case "smallint":return "Integer";
            case "mediumint":return "Integer";
            case "bit":return "Boolean";
            case "bigint":return "java.math.BigInteger";
            case "float":return "Fload";
            case "double":return "Double";
            case "decimal":return "java.math.BigDecimal";
            case "boolean":return "Boolean";
            case "id":return "Long";
            case "date":return "java.util.Date";
            case "datetime":return "java.util.Date";
            case "year":return "java.util.Date";
            case "time":return "java.sql.Time";
            case "timestamp":return "java.sql.Timestamp";
            case "numeric":return "java.math.BigDecimal";
            case "real":return "java.math.BigDecimal";
            case "money":return "Double";
            case "smallmoney":return "Double";
            case "image":return "byte[]";
            default:
                log.error("-----------------》转化失败：未发现的类型:{0}",sqlType);
                break;
        }
        return sqlType;
    }

    public static void sqlValueToJava(Object value, String dbType) throws Exception {
        String javaType = toSqlToJava(dbType);
        Class<?> baseWapperClaz = Class.forName("java.lang." + javaType);
        Object baseWapper = baseWapperClaz.newInstance();
        Method valueOfMethod = baseWapperClaz.getDeclaredMethod("valueOf");
    }

    public static String quotedStr(Object o) {
       return quotedStr(String.valueOf(o));
    }

    public static String quotedStr(String str) {
        if (str != null)
            return "'" + str + "'";
        else
            return "''";
    }

    public static String bracketStr(String str) {
        if (str != null)
            return "(" + str + ")";
        else
            return "()";
    }

    public static String StrJoin(String... objects){
        ContentBuilder builder = new ContentBuilder(Constant.EMPTY);
        for (String object : objects) {
            builder.append(object);
        }
        return builder.toString();
    }

    public static String assemblParam(String objects){
        if (StringUtils.isEmpty(objects)) {
            return null;
        }else  {
            return  "@{" + objects + "}";
        }

    }
    public static String getRandomString(int length) {
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(3);
            long result = 0;
            switch (number) {
                case 0:
                    result = Math.round(Math.random() * 25 + 65);
                    sb.append(String.valueOf((char) result));
                    break;
                case 1:
                    result = Math.round(Math.random() * 25 + 97);
                    sb.append(String.valueOf((char) result));
                    break;
                case 2:
                    sb.append(String.valueOf(new Random().nextInt(10)));
                    break;
            }
        }
        return sb.toString();
    }

    public static int getOrderNoAdd(int orderNo) {
        return orderNo + 1;
    }

    public static final String getChineseOrEnglishOrNumber(String str) {
        StringBuffer sbf = new StringBuffer();
        char[] charArray = str.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            if ((charArray[i] >= 0x4e00) && (charArray[i] <= 0x9fbb)) {
                sbf.append(charArray[i]);
            }
            if ((charArray[i] >= 65) && (charArray[i] <= 122)) {
                sbf.append(charArray[i]);
            }
            if (str.charAt(i) >= 48 && str.charAt(i) <= 57) {
                sbf.append(charArray[i]);
            }
        }
        return sbf.toString();
    }


    public static Set<String> matcher(String testStr) {
        return matcher(Constant.Default_Patter, testStr);
    }

    public static String replaceEscape(String testStr) {
        String new_str = Pattern.compile("\t|\r|\n| ").matcher(testStr).replaceAll(Constant.EMPTY);
        return new_str;
    }

    public static Set<String> matcher(String patter, String testStr) {
//		String test = "@{databaseIp}:{databasePort}{instanceName};database";
//		String initCompile = "(?<=@\\{)(.+?)(?=\\})";

        Set<String> ls=new HashSet<>();

        Pattern pattern = Pattern.compile(patter);
        Matcher matcher = pattern.matcher(testStr);

        while(matcher.find()){

            ls.add(matcher.group());

        }
        return ls;
    }




    private static String toHexString(byte[] b) {
        StringBuilder sb = new StringBuilder(b.length * 2);
        for (int i = 0; i < b.length; i++) {
            sb.append(HEX_DIGITS[(b[i] & 0xf0) >>> 4]);
            sb.append(HEX_DIGITS[b[i] & 0x0f]);
        }
        return sb.toString();
    }

    public static String Bit32(String SourceString) throws Exception {
        MessageDigest digest = java.security.MessageDigest.getInstance("MD5");
        digest.update(SourceString.getBytes());
        byte messageDigest[] = digest.digest();
        return toHexString(messageDigest);
    }

    public static String Bit16(String SourceString) throws Exception {
        return Bit32(SourceString).substring(8, 24);
    }

    public static List<Segment> map2Segment(Map<String, String> masterModifiedMap) {
        ArrayList<Segment> result = new ArrayList<>();
        Set<String> keys = masterModifiedMap.keySet();
        for (String key : keys) {
            String value = masterModifiedMap.get(key);
            Segment segment = new Segment(key, value);
            result.add(segment);
        }
        return result;
    }

    public static String getFieldRedisKey(String tableName, String field) {
        if (StringUtils.isEmpty(tableName) && StringUtils.isEmpty(field)) {
            return null;
        }else if (StringUtils.isEmpty(field)){
            return tableName;
        }else if (StringUtils.isEmpty(tableName)){
            return field;
        }else {
            return tableName + Constant.UnderLine + field;
        }
    }

    public static List<String> split(String redisVal) {
        if (StringUtils.isEmpty(redisVal)) {
            return null;
        }
        String[] split = redisVal.split(Constant.SEMICOLON);
        List<String> strings = Arrays.asList(split);
        return strings;
    }

    public static TUser getUser(HttpServletRequest request) {
        return (TUser) request.getSession().getAttribute(Constant.USER);
    }

    public static Set<String> getRoleByUser(String userId) {
        Set<String> roleIds = new HashSet<>();
        roleIds.add("R001");
        roleIds.add("R002");
        return roleIds;
    }
}