package com.hboxs.serialport.plc.util;

import android.text.TextUtils;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.List;

/**
 * @author whw
 * @time 2019/3/4
 * @Description 进制操作工具类
 */
public class HexadecimalUtil {

    /**
     *  16进制转2进制
     * @param hexStr 16进制
     * @return 2进制
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }
    /**
     * 16进制转2进制
     *
     * @param hex
     * @return 2进制字符串
     */
    public static String hexStringToByte(String hex) {
        final int maxNum=16;
//        int i = Integer.parseInt(hex, 16);
        BigInteger i = new BigInteger(hex,16);
//        String str2 = Integer.toBinaryString(i);
        String str2 = Integer.toBinaryString(i.intValue());
        StringBuilder sb=new StringBuilder(str2);
        int length = str2.length();
        if (length <maxNum){
            int len=maxNum-length;
            for (int j = 0; j < len; j++) {
                sb.insert(j,0);
            }

        }
        return sb.toString();
    }

    /**
     * 16进制转10进制
     * @param text
     * @return
     */
    public static long hex2dec(String text){
       return Long.parseLong(text, 16);
    }

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

    /**
     * 把原始字符串分割成指定长度的字符串列表
     * @param inputString 原始字符串
     * @param length 指定长度
     * @return
     */
    public static List<String> getStrList(String inputString, int length) {
        int size = inputString.length() / length;
        if (inputString.length() % length != 0) {
            size += 1;
        }
        return getStrList(inputString, length, size);
    }

    /**
     * 把原始字符串分割成指定长度的字符串列表
     * @param inputString 原始字符串
     * @param length 指定长度
     * @param size 指定列表大小
     * @return
     */
    public static List<String> getStrList(String inputString, int length,
                                          int size) {
        List<String> list = new ArrayList<String>();
        for (int index = 0; index < size; index++) {
            String childStr = substring(inputString, index * length,
                    (index + 1) * length);
            list.add(childStr);
        }
        return list;
    }

    /**
     * 分割字符串，如果开始位置大于字符串长度，返回空
     * @param str 原始字符串
     * @param f 开始位置
     * @param t 结束位置
     * @return
     */
    public static String substring(String str, int f, int t) {
        if (f > str.length())
            return null;
        if (t > str.length()) {
            return str.substring(f, str.length());
        } else {
            return str.substring(f, t);
        }
    }

    /**
     * 进行翻转拼接
     * @param inputString 字符源
     * @param length 每个字符串长度
     * @return
     */
    public static String flipString(String inputString, int length){
        StringBuilder sb=new StringBuilder();
        List<String> strList = getStrList(inputString, length);
        for (int i=0;i<strList.size();i++) {
            //进行翻转
            String s = strList.get(i);
            String s1 = TextUtils.getReverse(s, 0, s.length()).toString();
            sb.append(s1);
        }
        return sb.toString();
    }

    /**
     * 将16进制的字符串进行高低位翻转
     * @param text 16进制字符串
     * @return 翻转后的列表
     */
    public static ArrayList<String> flipString(String text){
        ArrayList<String> arrayList=new ArrayList();

        if ((text.length()%4)==0){
            //切割 每隔4位进行切割
            List<String> strList = HexadecimalUtil.getStrList(text, 4);
          //  System.out.println("切割后："+strList.size());

            //每个进行翻转
            for (int i=0;i<strList.size();i++){
                String s = strList.get(i);
               // System.out.println("第"+i+"个："+ s);
                List<String> strList1 = HexadecimalUtil.getStrList(s, 2);
                StringBuilder sb=new StringBuilder();
                sb.append(strList1.get(1));
                sb.append(strList1.get(0));
               // System.out.println("第"+i+"个翻转后的数组为："+ sb.toString());
                arrayList.add(sb.toString());
            }
        }
        return arrayList;
    }

}
