package com.sandu.ximon.admin.utils;

import java.util.ArrayList;

/**
 * 16
 */
public class HexStrConvertUtil {
    /**
     * byte数组转换二进制字符串
     **/
    public static String HexToByteStr(String hexStr) {
        String[] strs = new String[]{
                "0000","0001","0010","0011",
                "0100","0101","0110","0111",
                "1000","1001","1010","1011",
                "1100","1101","1110","1111"
        };
        String result = "";
        for(char c:hexStr.toCharArray()){
            result = result + strs["0123456789ABCDEF".indexOf(c)];
        }

        return result;
    }

    /**
     * 字符串转换为16进制字符串
     *
     * @param s
     * @return
     */
    public static String stringToHexString(String s) {
        String str = "";
        for (int i = 0; i < s.length(); i++) {
            int ch = s.charAt(i);
            String s4 = Integer.toHexString(ch);
            str = str + s4;
        }
        return str;
    }

    /**
     * 16进制转换成为string类型字符串
     * @param s
     * @return
     */
    public static String hexStringToString(String s) {
        if (s == null || s.equals("")) {
            return null;
        }
        s = s.replace(" ", "");
        byte[] baKeyword = new byte[s.length() / 2];
        for (int i = 0; i < baKeyword.length; i++) {
            try {
                baKeyword[i] = (byte) (0xff & Integer.parseInt(s.substring(i * 2, i * 2 + 2), 16));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        try {
            s = new String(baKeyword, "UTF-8");
            new String();
        } catch (Exception e1) {
            e1.printStackTrace();
        }
        return s;
    }


    /**
     * @param: [content]
     * @return: int
     * @description: 十六进制转十进制
     */
//    public static int HexToInt(String content){
//        int number=0;
//        String [] HighLetter = {"A","B","C","D","E","F"};
//        Map<String,Integer> map = new HashMap<>();
//        for(int i = 0;i <= 9;i++){
//            map.put(i+"",i);
//        }
//        for(int j= 10;j<HighLetter.length+10;j++){
//            map.put(HighLetter[j-10],j);
//        }
//        String[]str = new String[content.length()];
//        for(int i = 0; i < str.length; i++){
//            str[i] = content.substring(i,i+1);
//        }
//        for(int i = 0; i < str.length; i++){
//            number += map.get(str[i])*Math.pow(16,str.length-1-i);
//        }
//        return number;
//    }


    /**
     * @param bArray
     * @return HexString
     */
    public static final ArrayList bytesToHexList(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2) {
                arrayList.add(0 + sTemp);
            } else {
                arrayList.add(sTemp);
            }
        }
        return arrayList;
    }

    public static final String bytesToHexString(byte[] bArray) {
        StringBuffer sb = new StringBuffer(bArray.length);
        String sTemp;
        for (int i = 0; i < bArray.length; i++) {
            sTemp = Integer.toHexString(0xFF & bArray[i]);
            if (sTemp.length() < 2) {
                sb.append(0);
            }
            sb.append(sTemp.toLowerCase());
        }
        return sb.toString();
    }

    public static final String byteToHexString(byte b) {
        StringBuffer sb = new StringBuffer();
        String sTemp;
        sTemp = Integer.toHexString(0xFF & b);
        if (sTemp.length() < 2) {
            sb.append(0);
        }
        sb.append(sTemp.toLowerCase());
        return sb.toString();
    }

    /**
     * 十进制转换成十六进制
     */
    public static String tenToHex(int t) {
        return Integer.toHexString(t).toUpperCase();
    }

    /**
     * @param src String
     * @return byte[]
     **/
    public static byte[] hexStringToByt (String src) {
        src = src.replaceAll(" ", "");
//        "\"19 03 00 00 00 0b 07 d5\""
        byte[] ret = new byte[src.length() / 2];
        byte[] tmp = src.getBytes();
        for (int i = 0; i < src.length() / 2; i++) {
            ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
        }
        return ret;
    }

    public static byte[] hexStringToByteArray (String s) {

        int len = s.length();
        byte[] data = new byte[len/2];

        for(int i = 0; i < len+1; i+=2){
            data[i/2] = (byte) ((Character.digit(s.charAt(i), 16) << 4) + Character.digit(s.charAt(i+1), 16));
        }

        return data;
    }

    public static byte[] hexToByteArrays(String hex) {

        hex = hex.length()%2 != 0?"0"+hex:hex;

        byte[] b = new byte[hex.length() / 2];

        for (int i = 0; i < b.length; i++) {
            int index = i * 2;
            int v = Integer.parseInt(hex.substring(index, index + 2), 16);
            b[i] = (byte) v;
        }
        return b;
    }



    /** 十六进制转换成字节数组 */
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase(); // 十六进制转大写字母
        int length = hexString.length() / 2; // 获取十六进制的长度，2个字符为一个十六进制
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }
    /** char转byte */
    private static byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }
//    /**
//     * 把16进制字符串转换成字节数组
//     *
//     * @param hex
//     * @return
//     */
//    public static byte[] hexStringToByte(String hex) {
//        int len = (hex.length() / 2);
//        byte[] result = new byte[len];
//        char[] achar = hex.toCharArray();
//        for (int i = 0; i < len; i++) {
//            int pos = i * 2;
//            result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
//        }
//        return result;
//    }

    /**
     * 16进制字符串 转换为对应的 byte数组
     */
    public static byte[] hex2Bytes(String hex) {
        if (hex == null || hex.length() == 0) {
            return null;
        }

        char[] hexChars = hex.toCharArray();
        byte[] bytes = new byte[hexChars.length / 2];   // 如果 hex 中的字符不是偶数个, 则忽略最后一个

        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) Integer.parseInt("" + hexChars[i * 2] + hexChars[i * 2 + 1], 16);
        }
        return bytes;
    }


    private static byte toByte(char c) {
        byte b = (byte) "0123456789ABCDEF".indexOf(c);
        return b;
    }

    /**
     * hex字符串转byte数组
     * @param inHex 待转换的Hex字符串
     * @return  转换后的byte数组结果
     */
    public static byte[] hexToByteArray(String inHex){

        int hexlen = inHex.length();
        byte[] result;
        if (hexlen % 2 == 1){
            //奇数
            hexlen++;
            result = new byte[(hexlen/2)];
            inHex="0"+inHex;
        }else {
            //偶数
            result = new byte[(hexlen/2)];
        }
        int j=0;
        for (int i = 0; i < hexlen; i+=2){
            result[j]=hexToByte(inHex.substring(i,i+2));
            j++;
        }
        return result;
    }


    /**
     * Hex字符串转byte
     * @param inHex 待转换的Hex字符串
     * @return  转换后的byte
     */
    public static byte hexToByte(String inHex){
        return (byte)Integer.parseInt(inHex,16);
    }

    public static byte[] hexStr2Bytes(String src) {
        int m = 0, n = 0;
        int l = src.length() / 2;
        System.out.println(l);
        byte[] ret = new byte[l];
        for (int i = 0; i < l; i++) {
            m = i * 2 + 1;
            n = m + 1;
            ret[i] = Byte.decode("0x" + src.substring(i * 2, m) + src.substring(m, n));
        }
        return ret;
    }

    public static byte[] bytes2HexByte(byte[] b) {
        byte[] result = new byte[b.length];
        String hex;
        for (int i = 0; i < b.length; i++) {
            hex = Integer.toHexString(b[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            result[i] = Byte.parseByte(hex);
        }
        return result;
    }

    public static byte uniteBytes(byte src0, byte src1) {
        byte _b0 = Byte.decode("0x" + new String(new byte[]{src0})).byteValue();
        _b0 = (byte) (_b0 << 4);
        byte _b1 = Byte.decode("0x" + new String(new byte[]{src1})).byteValue();
        byte ret = (byte) (_b0 ^ _b1);
        System.out.print(ret);
        return ret;
    }

    public static boolean isHex(String str) {
        boolean isHexFlg = true;
        int i = 0;
        char c;
        for (i = 0; i < str.length(); i++) {
            c = str.charAt(i);
            if (!(((c >= '0') && (c <= '9')) || ((c >= 'A') && (c <= 'F')) || ((c >= 'a') && (c <= 'f')) || (c == ' '))) {
                isHexFlg = false;
                break;
            }
        }
        return isHexFlg;
    }


//    public static byte[] readInputStream(InputStream inputStream) {
//        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
//
//        if (inputStream != null) {
//            try {
//                byte[] buffer = new byte[91];
//                int counts;
//                while ((counts = inputStream.read(buffer, 0, buffer.length)) > 0) {
//                    byteArrayOutputStream.write(buffer, 0, counts);
//                }
//            } catch (IOException e) {
//                e.printStackTrace();
//            }/* finally {
//                if (byteArrayOutputStream != null) {
//                    try {
//                        byteArrayOutputStream.close();
//                    } catch (IOException e) {
//                        e.printStackTrace();
//                    }
//                }
//            }*/
//        }
//        return byteArrayOutputStream.toByteArray();
//    }

    //                br = new BufferedReader(new InputStreamReader(inputStream));
//                byteArrayOutputStream = new ByteArrayOutputStream();
//                while ((data = br.readLine()) != null) {
//                    Log.i("HexStrConvertUtil", "readInputStream: " + data);
//                    byte[] ba = HexStrConvertUtil.hexStr2Bytes(data);
//                    Log.i("HexStrConvertUtil", "bytes : " + Arrays.toString(ba));
//                }

    /**
     * 合并数组
     *
     * @param firstArray  第一个数组
     * @param secondArray 第二个数组
     * @return 合并后的数组
     */
    public static byte[] connect(byte[] firstArray, byte[] secondArray) {
        if (firstArray == null || secondArray == null) {
            return null;
        }
        byte[] bytes = new byte[firstArray.length + secondArray.length];
        System.arraycopy(firstArray, 0, bytes, 0, firstArray.length);
        System.arraycopy(secondArray, 0, bytes, firstArray.length, secondArray.length);
        return bytes;
    }

    //合并数组
    public static byte[] connectByte(byte[] firstArray, byte[] secondArray) {
        if (firstArray == null || secondArray == null) {
            return null;
        }
        byte[] bytes = new byte[firstArray.length + secondArray.length];
        System.arraycopy(secondArray,0,bytes,firstArray.length,secondArray.length);
//        System.arraycopy(firstArray,0,secondArray,secondArray.length,bytes.length);

//        System.arraycopy(firstArray, 0, bytes, 0, firstArray.length);
//        System.arraycopy(secondArray, 0, bytes, firstArray.length, secondArray.length);
        return bytes;
    }
}