package com.ard.utils.other;

import javax.xml.bind.DatatypeConverter;
import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.zip.CRC32;

/**
 * @Description: 字节工具类
 * @ClassName: byteUtils
 * @Author: 刘苏义
 * @Date: 2023年07月03日15:18
 * @Version: 1.0
 **/
public class ByteUtils {

    /**
     * 打印十六进制二进制
     */
    public static String printHexBinary(byte[] bytes) {
        return DatatypeConverter.printHexBinary(bytes);
    }

    /**
     * byte数组转中文字符串
     */
    public static String bytesToStringZh(byte[] bytes) {
        String zhStr = "";
        try {
            int position = ByteUtils.findIndexOfDoubleZero(bytes);
            if (position != -1) {
                byte[] result = new byte[position];
                System.arraycopy(bytes, 0, result, 0, position);
                zhStr = new String(result, "GBK");
            } else {
                zhStr = new String(bytes, "GBK");
            }
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return zhStr;
    }

    /**
     * Byte字节转Hex
     *
     * @param b 字节
     * @return Hex
     */
    public static String byteToHex(byte b) {
        String hexString = Integer.toHexString(b & 0xFF);
        //由于十六进制是由0~9、A~F来表示1~16，所以如果Byte转换成Hex后如果是<16,就会是一个字符（比如A=10），通常是使用两个字符来表示16进制位的,
        //假如一个字符的话，遇到字符串11，这到底是1个字节，还是1和1两个字节，容易混淆，如果是补0，那么1和1补充后就是0101，11就表示纯粹的11
        if (hexString.length() < 2) {
            hexString = new StringBuilder(String.valueOf(0)).append(hexString).toString();
        }
        return hexString.toUpperCase();
    }

    /**
     * byte数组转float
     */
    public static float bytesToFloat(byte[] bytes) {
        ByteBuffer buffer = ByteBuffer.wrap(bytes);
        return buffer.getFloat();
    }

    /**
     * byte数组转整型
     */
    public static int bytesToDecimal(byte[] byteArray) {
        int decimalValue = 0;
        for (int i = 0; i < byteArray.length; i++) {
            decimalValue = (decimalValue << 8) | (byteArray[i] & 0xFF);
        }
        return decimalValue;
    }

    /**
     * byte数组转Double
     */
    public static double bytesToDouble(byte[] byteArray) {
        // 创建一个ByteBuffer并设置字节顺序为大端
        ByteBuffer buffer = ByteBuffer.wrap(byteArray);
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        // 从ByteBuffer中获取double值
        double doubleValue = buffer.getDouble();
        return doubleValue;
    }

    /**
     * 大端转小端
     */
    public static byte[] toLittleEndian(byte[] bigEndianBytes) {
        byte[] littleEndianBytes = new byte[bigEndianBytes.length];

        for (int i = 0; i < bigEndianBytes.length; i++) {
            int j = bigEndianBytes.length - i - 1;
            littleEndianBytes[i] = bigEndianBytes[j];
        }

        return littleEndianBytes;
    }

    /**
     * 小端转大端
     */
    public static byte[] toBigEndian(byte[] littleEndianBytes) {
        byte[] bigEndianBytes = new byte[littleEndianBytes.length];
        for (int i = 0; i < littleEndianBytes.length; i++) {
            bigEndianBytes[i] = littleEndianBytes[littleEndianBytes.length - 1 - i];
        }
        return bigEndianBytes;
    }

    /**
     * int转byte数组
     */
    public static byte[] decimalToBytes(int decimalValue) {
        ByteBuffer buffer = ByteBuffer.allocate(Integer.BYTES);
        buffer.putInt(decimalValue);
        return buffer.array();
    }

    /**
     * double转byte数组
     */
    public static byte[] doubleToBytes(double d) {
        long value = Double.doubleToRawLongBits(d);
        byte[] byteRet = new byte[8];
        for (int i = 0; i < 8; i++) {
            byteRet[i] = (byte) ((value >> 8 * i) & 0xff);
        }
        return byteRet;
    }
    /**
     * float转byte数组
     */
    public static byte[] floatToBytes(float f) {
        // 创建一个 ByteBuffer，分配足够的空间来存储一个 float 值
        ByteBuffer buffer = ByteBuffer.allocate(Float.BYTES);
        // 将 float 值写入 ByteBuffer
        buffer.putFloat(f);
        // 获取字节数组
        return buffer.array();
    }
    /**
     * byte数组拼接
     */
    public static byte[] appendArrays(byte[]... arrays) {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        try {
            for (byte[] array : arrays) {
                outputStream.write(array);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return outputStream.toByteArray();
    }

    /**
     * byte数组CRC32校验
     */
    public static byte[] parseCrc32(byte[] bytes) {
        CRC32 crc32 = new CRC32();
        crc32.update(bytes);
        bytes = ByteUtils.decimalToBytes((int) crc32.getValue());
        bytes = ByteUtils.toBigEndian(bytes);
        // System.out.print("校验:"+DatatypeConverter.printHexBinary(bytes));//打印crc32的校验值
        return bytes;
    }

    /**
     * 去除包头包尾
     * 刘苏义
     * 2023/7/4 11:24
     */
    public static byte[] removeHeaderAndFooter(byte[] data, int headerLength, int footerLength) {
        int payloadLength = data.length - headerLength - footerLength;
        byte[] payload = new byte[payloadLength];
        System.arraycopy(data, headerLength, payload, 0, payloadLength);
        return payload;
    }

    /**
     * 去除包头包尾crc校验
     * 刘苏义
     * 2023/7/4 11:24
     */
    public static byte[] removeHeaderFooterAndCRC(byte[] data, int headerLength, int footerLength, int crcLength) {
        int payloadLength = data.length - headerLength - footerLength - crcLength;
        byte[] payload = new byte[payloadLength];
        System.arraycopy(data, headerLength, payload, 0, payloadLength);
        return payload;
    }

    /**
     * 获取后面的字节数组
     * 刘苏义
     * 2023/7/4 11:24
     */
    public static byte[] getLastBytes(byte[] data, int count) {
        int startIndex = data.length - count;
        byte[] lastBytes = new byte[count];
        System.arraycopy(data, startIndex, lastBytes, 0, count);
        return lastBytes;
    }

    /**
     * 找到00的索引位置
     */
    public static int findIndexOfDoubleZero(byte[] bytes) {
        for (int i = 0; i < bytes.length - 1; i++) {
            if (bytes[i] == 0x00) {
                return i;
            }
        }
        return -1;
    }
}