package com.doumee.core.utils;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.util.*;

/**
 * @author yezhihao
 * https://gitee.com/yezhihao/jt808-server
 */
public class StringTools {

    public static final int[] EMPTY = new int[0];

    public static final Integer[] EMPTY_ = new Integer[0];

    public static int[] toInts(String str, String delimiter) {
        String[] split = str.split(delimiter);
        int[] result = new int[split.length];
        for (int i = 0; i < split.length; i++)
            result[i] = Integer.parseInt(split[i]);
        return result;
    }

    public static double[] toDoubles(String str, String delimiter) {
        String[] split = str.split(delimiter);
        double[] result = new double[split.length];
        for (int i = 0; i < split.length; i++)
            result[i] = Double.parseDouble(split[i]);
        return result;
    }

    public static byte[] toBytes(String str, String delimiter) {
        String[] split = str.split(delimiter);
        byte[] result = new byte[split.length];
        for (int i = 0; i < split.length; i++)
            result[i] = (byte) Integer.parseInt(split[i]);
        return result;
    }

    public static String merge(String delimiter, Collection value) {
        if (value == null || value.size() == 0)
            return null;

        StringBuilder result = new StringBuilder(value.size() * 5);
        for (Object id : value)
            result.append(id).append(delimiter);

        return result.substring(0, result.length() - 1);
    }

    public static String merge(String delimiter, Object... value) {
        if (value == null || value.length == 0)
            return null;

        StringBuilder result = new StringBuilder(value.length * 5);
        for (Object id : value)
            result.append(id).append(delimiter);

        return result.substring(0, result.length() - 1);
    }

    public static String merge(String delimiter, int... value) {
        if (value == null || value.length == 0)
            return null;

        StringBuilder result = new StringBuilder(value.length * 5);
        for (int id : value)
            result.append(id).append(delimiter);

        return result.substring(0, result.length() - 1);
    }

    public static int[] toInts(Integer[] src) {
        if (src == null || src.length == 0)
            return EMPTY;

        int[] dest = new int[src.length];
        for (int i = 0; i < src.length; i++)
            dest[i] = src[i];
        return dest;
    }

    public static Integer[] toInts(int[] src) {
        if (src == null || src.length == 0)
            return EMPTY_;

        Integer[] dest = new Integer[src.length];
        for (int i = 0; i < src.length; i++)
            dest[i] = src[i];
        return dest;
    }

    public static Integer parseInt(String num) {
        return parseInt(num, null);
    }

    public static Integer parseInt(String num, Integer defVal) {
        if (isBlank(num))
            return defVal;
        try {
            return Integer.parseInt(num);
        } catch (NumberFormatException e) {
            return defVal;
        }
    }

    public static String toUnderline(String str) {
        StringBuilder result = new StringBuilder(str.length() + 4);
        char[] chars = str.toCharArray();

        result.append(Character.toLowerCase(chars[0]));

        for (int i = 1; i < chars.length; i++) {
            char c = chars[i];
            if (Character.isUpperCase(c))
                result.append('_').append(Character.toLowerCase(c));
            else
                result.append(c);
        }
        return result.toString();
    }

    public static String subPrefix(String str, String prefix) {
        if (str != null && str.startsWith(prefix))
            str = str.substring(prefix.length());
        return str;
    }

    public static Map newMap(Object... entrys) {
        Map result = new HashMap((int) (entrys.length / 1.5) + 1);
        for (int i = 0; i < entrys.length; )
            result.put(entrys[i++], entrys[i++]);
        return result;
    }

    public static boolean isNotBlank(String str) {
        return !isBlank(str);
    }

    public static boolean isBlank(String str) {
        return str == null || str.length() == 0 || str.trim().length() == 0;
    }

    public static <T> T getDefault(T value, T defaultValue) {
        return value != null ? value : defaultValue;
    }

    public static String leftPad(String str, int size, char ch) {
        if(str ==null){
            str = "";
        }
        int length = str.length();
        int pads = size - length;
        if (pads > 0) {
            char[] result = new char[size];
            str.getChars(0, length, result, pads);
            while (pads > 0)
                result[--pads] = ch;
            return new String(result);
        }
        return str;
    }
    public static String leftTrip(String str,  char ch) {
        if(str==null ){
            return null;
        }
        int index = 0;
        while (index < str.length() && str.charAt(index) == ch) {
            index++;
        }
        String result = str.substring(index);
        return result;
    }

    public static int[] toArray(Collection<Integer> list) {
        if (list == null || list.isEmpty())
            return null;

        int[] result = new int[list.size()];
        int i = 0;
        for (Integer e : list) {
            if (e != null)
                result[i++] = e;
        }
        return result;
    }

    public static Set<Integer> toSet(int... num) {
        if (num == null || num.length == 0) {
            return Collections.EMPTY_SET;
        }
        Set<Integer> result;
        if (num.length <= 3) {
            result = new TreeSet<>();
        } else {
            result = new HashSet<>(num.length << 1);
        }
        for (int i : num) {
            result.add(i);
        }
        return result;
    }

    public static boolean isNum(String val) {
        if (isBlank(val)) {
            return false;
        }
        int sz = val.length();
        for (int i = 0; i < sz; i++) {
            if (!Character.isDigit(val.charAt(i))) {
                return false;
            }
        }
        return true;
    }

    public static String getStackTrace(final Throwable throwable) {
        final StringWriter sw = new StringWriter(7680);
        final PrintWriter pw = new PrintWriter(sw, true);
        throwable.printStackTrace(pw);
        return sw.getBuffer().toString();
    }

    private static final char[] hexCode = "0123456789abcdef".toCharArray();

    public static String bytes2Hex(byte[] bytes) {
        char[] hex = new char[bytes.length << 1];
        for (int j = 0, i = 0; i < bytes.length; i++) {
            byte b = bytes[i];
            hex[j++] = hexCode[(b >> 4) & 0xF];
            hex[j++] = hexCode[(b & 0xF)];
        }
        return new String(hex);
    }

    public static byte[] hex2Bytes(String hex) {
        final int len = hex.length();

        if (len % 2 != 0) {
            throw new IllegalArgumentException("hexBinary needs to be even-length: " + hex);
        }

        byte[] out = new byte[len >> 1];
        for (int i = 0; i < len; i += 2) {

            int h = hexToBin(hex.charAt(i));
            int l = hexToBin(hex.charAt(i + 1));
            if (h == -1 || l == -1) {
                throw new IllegalArgumentException("contains illegal character for hexBinary: " + hex);
            }
            out[i >> 1] = (byte) (h * 16 + l);
        }
        return out;
    }

    public static int hexToBin(char ch) {
        if ('0' <= ch && ch <= '9') {
            return ch - '0';
        }
        if ('A' <= ch && ch <= 'F') {
            return ch - ('A' - 10);
        }
        if ('a' <= ch && ch <= 'f') {
            return ch - ('a' - 10);
        }
        return -1;
    }
}