package publicway;

import java.io.UnsupportedEncodingException;
import java.util.Arrays;

public class HexUtil {
    
    private static final String HEX_CHARS = "0123456789ABCDEF";
    
    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param src 字节数组
     * @return 十六进制字符串，如果输入为空则返回null
     */
    public static String bytesToHexString(byte[] src) {
        return bytesToHexString(src, 0, src != null ? src.length : 0);
    }
    
    /**
     * 将字节数组转换为十六进制字符串
     *
     * @param src 字节数组
     * @param len 要转换的长度
     * @return 十六进制字符串，如果输入为空则返回null
     */
    public static String bytesToHexString(byte[] src, int len) {
        return bytesToHexString(src, 0, len);
    }
    
    /**
     * 将字节数组指定范围转换为十六进制字符串
     *
     * @param src 字节数组
     * @param start 起始位置
     * @param end 结束位置
     * @return 十六进制字符串，如果输入为空则返回null
     */
    public static String bytesToHexString(byte[] src, int start, int end) {
        if (src == null || src.length == 0) {
            return null;
        }
        
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = start; i < end && i < src.length; i++) {
            int v = src[i] & 0xFF;
            stringBuilder.append(HEX_CHARS.charAt(v >>> 4));
            stringBuilder.append(HEX_CHARS.charAt(v & 0x0F));
        }
        return stringBuilder.toString();
    }
    
    /**
     * 将十六进制字符串转换为字节数组
     *
     * @param hexString 十六进制字符串
     * @return 字节数组，如果输入为空则返回null
     */
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.isEmpty()) {
            return null;
        }
        
        String normalizedHex = hexString.toUpperCase().replaceAll("[^0-9A-F]", "");
        if (normalizedHex.length() % 2 != 0) {
            throw new IllegalArgumentException("十六进制字符串长度必须为偶数");
        }
        
        int length = normalizedHex.length() / 2;
        byte[] result = new byte[length];
        
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            int high = charToByte(normalizedHex.charAt(pos));
            int low = charToByte(normalizedHex.charAt(pos + 1));
            result[i] = (byte) ((high << 4) | low);
        }
        return result;
    }
    
    /**
     * 字符转换为字节
     *
     * @param c 字符
     * @return 字节值
     */
    private static byte charToByte(char c) {
        return (byte) HEX_CHARS.indexOf(c);
    }
    
    /**
     * 整数转换为4字节数组（大端序）
     *
     * @param num 整数
     * @return 4字节数组
     */
    public static byte[] intToBytes(int num) {
        byte[] bytes = new byte[4];
        for (int i = 0; i < 4; i++) {
            bytes[i] = (byte) (num >>> (24 - i * 8));
        }
        return bytes;
    }
    
    /**
     * 字符串转换为十六进制字符串
     *
     * @param str 输入字符串
     * @return 十六进制字符串
     */
    public static String strToHexStr(String str) {
        if (str == null) return "";
        
        StringBuilder sb = new StringBuilder();
        byte[] bytes = str.getBytes();
        for (byte b : bytes) {
            sb.append(HEX_CHARS.charAt((b & 0xF0) >> 4));
            sb.append(HEX_CHARS.charAt(b & 0x0F));
        }
        return sb.toString();
    }
    
    /**
     * 计算Modbus CRC-16校验码（返回大写十六进制字符串）
     *
     * @param data 输入数据
     * @return 4位大写的十六进制CRC字符串
     */
    public static String calculate(byte[] data) {
        int crc = 0xFFFF;
        for (byte b : data) {
            crc ^= b & 0xFF;
            for (int i = 0; i < 8; i++) {
                if ((crc & 1) == 1) {
                    crc = (crc >>> 1) ^ 0xA001;
                } else {
                    crc = crc >>> 1;
                }
            }
        }
        // 使用大写格式，确保4位长度，不足补零
        return String.format("%04X", crc);
    }
    
    /**
     * BCD码转为字符串
     *
     * @param bytes BCD码字节数组
     * @return 十进制字符串
     */
    public static String bcdToStr(byte[] bytes) {
        if (bytes == null || bytes.length == 0) {
            return "";
        }
        
        StringBuilder temp = new StringBuilder(bytes.length * 2);
        for (byte b : bytes) {
            temp.append((b & 0xF0) >>> 4);
            temp.append(b & 0x0F);
        }
        
        // 去除前导零
        String result = temp.toString();
        return result.startsWith("0") ? result.substring(1) : result;
    }
    
    /**
     * 字符串转为BCD码
     *
     * @param asc 十进制字符串
     * @return BCD码字节数组
     */
    public static byte[] strToBcd(String asc) {
        if (asc == null || asc.isEmpty()) {
            return new byte[0];
        }
        
        // 确保长度为偶数
        String normalized = asc.length() % 2 != 0 ? "0" + asc : asc;
        byte[] result = new byte[normalized.length() / 2];
        
        for (int i = 0; i < result.length; i++) {
            char highChar = normalized.charAt(2 * i);
            char lowChar = normalized.charAt(2 * i + 1);
            
            int high = charToBcdValue(highChar);
            int low = charToBcdValue(lowChar);
            
            result[i] = (byte) ((high << 4) | low);
        }
        return result;
    }
    
    private static int charToBcdValue(char c) {
        if (c >= '0' && c <= '9') {
            return c - '0';
        } else if (c >= 'a' && c <= 'f') {
            return c - 'a' + 10;
        } else if (c >= 'A' && c <= 'F') {
            return c - 'A' + 10;
        } else {
            throw new IllegalArgumentException("无效的BCD字符: " + c);
        }
    }
    
    /**
     * 反转字节数组
     *
     * @param data 字节数组
     * @param len 要反转的长度
     */
    public static void reverse(byte[] data, int len) {
        if (data == null || len <= 1) return;
        
        for (int i = 0; i < len / 2; i++) {
            byte temp = data[i];
            data[i] = data[len - 1 - i];
            data[len - 1 - i] = temp;
        }
    }
    
    /**
     * 字节数组转换为字符串（遇到0x00终止）
     *
     * @param data 字节数组
     * @return 字符串
     */
    public static String bytesToString(byte[] data) {
        if (data == null || data.length == 0) {
            return "";
        }
        
        int length = 0;
        for (int i = 0; i < data.length; i++) {
            if (data[i] == 0) {
                length = i;
                break;
            }
            length = data.length;
        }
        
        return new String(data, 0, length);
    }
    
    /**
     * 获取异常的堆栈跟踪信息
     *
     * @param e 异常
     * @return 格式化的异常信息
     */
    public static String getExceptionTrace(Exception e) {
        if (e == null) return "";
        
        StringBuilder message = new StringBuilder("异常消息: " + e.getMessage());
        
        StackTraceElement[] stackTrace = e.getStackTrace();
        if (stackTrace != null && stackTrace.length > 0) {
            StackTraceElement firstElement = stackTrace[0];
            message.append(" 报错位置: ")
                  .append(firstElement.getClassName()).append(".")
                  .append(firstElement.getMethodName()).append("(")
                  .append(firstElement.getFileName()).append(":")
                  .append(firstElement.getLineNumber()).append(")");
        }
        return message.toString();
    }
    
    // 以下方法保持原有功能，但建议使用Java标准库替代
    // 由于时间关系，这里只优化主要方法
    
    /**
     * 字节数组（去掉后面的0）转Unicode字符串
     * 注意：此方法逻辑较复杂，建议在实际使用中验证
     */
    public static String bytesToUnicodeString(byte[] src) {
        // 保持原有实现，但建议重构
        if (src == null || src.length == 0) {
            return "";
        }
        
        int strlen = 0;
        for (int j = src.length - 1; j >= 0; j--) {
            if (src[j] != 0) {
                strlen = j + 1;
                break;
            }
        }
        
        if (strlen == 0) {
            return "";
        }
        
        // 确保长度为偶数
        if (strlen % 2 != 0) {
            strlen++;
        }
        
        byte[] strData = Arrays.copyOfRange(src, 0, strlen);
        try {
            // 交换字节序
            swapBytes(strData);
            return new String(strData, "UNICODE");
        } catch (UnsupportedEncodingException e) {
            throw new RuntimeException("不支持的编码: UNICODE", e);
        }
    }
    
    private static void swapBytes(byte[] data) {
        for (int i = 0; i < data.length / 2; i++) {
            byte temp = data[2 * i];
            data[2 * i] = data[2 * i + 1];
            data[2 * i + 1] = temp;
        }
    }
}