package com.ningdatech.carapi.radar;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import com.google.common.collect.Lists;
import com.ningdatech.carapi.AppTests;
import com.ningdatech.carapi.radar.helper.RadarDataHelper;

import lombok.extern.slf4j.Slf4j;

/**
 * @author CMM
 * @author CMM
 * @date 2024/11/8 10:28
 * /
 * /**
 * @since 2024/11/08 10:28
 */
@Slf4j
public class RadarTest extends AppTests {

    @Autowired
    private RadarDataHelper radarDataHelper;

    @Test
    public void test(){
        // 目标轨迹数据
        String data = "55aa55bb01d001763231363236303932000000000000000000000000180b0d0f2d0c00530b7e210232140fffffff0e0cfe5c1aa4000a07761adc0000ff4c000047868a4c11e1baee0b4b210232140fffffff0e0cfe167d4600f0097e22560000fe8e000047868a0311e213880b63220232140fffffff003801183f0cffce06c21856000000b4000047868d2211e1dba20b4e210232140fffffff0e0cfe2069aa019007f81d3bffecffa6fef247868a0e11e201eb0b7fff0232140fffffff0debfbaa14faff2407801b2dfff6fe8eff4c4786878011e1b5d70b57210232140fffffff0e0efe3e53e8fff607d01c200000fdda000047868a2d11e1ee5f0b661f0232140fffffff0e0efb32442afff6091a20c40000ffa6ffa64786870411e1e03b0b5d2003961925ffffff0e0cfc9a4a60ffa606cc18800000000000004786887911e1e5cf0b71200232140fffffff0e0ffccc29ae0000073a1a04000000000000478688ad11e1c8710b67200232140fffffff0e0ffcf43c14000007bc1bd7000000000000478688d611e1d8f80b7b200232140fffffff0e0efcb81f900000078a1b230000000000004786889811e1bf5a0b3e210232140fffffff0e0cfdda6cf2007805be14bd0000ff4c0000478689c511e204de55cc55dd";
        // 交通流量数据
        //String data = "55aa55bb007803703231363236303932000000000000000000000000180b0d102914000f0000001f0064000600000000000602f9001e00660000000000200064000400000000000402e5003200350000000000210064000300000000000302eb004600350000000000220064000200000000000202520064002b000055cc55dd";
        String head = "55aa55bb";
        String tail = "55cc55dd";

        // 解析上面的数据帧data 包头是head 包尾是tail 从包头到包尾分段取出数据 放入一个字符串列表中 等待解析
        List<String> segments = Lists.newArrayList();
        int headIndex = data.indexOf(head);
        while (headIndex != -1) {
            int tailIndex = data.indexOf(tail, headIndex + head.length());
            if (tailIndex != -1) {
                // 提取从包头到包尾的数据段
                String segment = data.substring(headIndex + head.length(), tailIndex);
                segments.add(segment);
                // 移动到下一个包头的位置
                headIndex = data.indexOf(head, tailIndex + tail.length());
            } else {
                // 没有找到包尾，结束循环
                break;
            }
        }

        // 遍历这些数据帧 解析其中携带的数据
        for (String segment : segments) {
            System.out.println(segment);

            //// 获取数据长度 2字节 4字符 判断数据包长度
            byte[] dataLengthData = radarDataHelper.extractHexData(segment, 0, 2);
            String dataLengthHexString = radarDataHelper.byteArrayToHexStringAll(dataLengthData);
            // 将16进制字符串转换为字节数组
            byte[] lengthBytes = new byte[2];
            // 高8位
            lengthBytes[0] = (byte) Integer.parseInt(dataLengthHexString.substring(0, 2), 16);
            // 低8位
            lengthBytes[1] = (byte) Integer.parseInt(dataLengthHexString.substring(2, 4), 16);

            // 将字节数组转换为16位整数，注意网络字节序是大端序
            int byteLength = ((lengthBytes[0] & 0xFF) << 8) | (lengthBytes[1] & 0xFF);
            // 打印结果
            System.out.println("数据长度: " + byteLength);

            // 获取数据帧类型 1字节 2字符 判断是目标轨迹数据还是交通流量数据
            byte[] objectTypeData = radarDataHelper.extractHexData(segment, 2, 1);
            String objectTypeHexString = radarDataHelper.byteArrayToHexString(objectTypeData);
            System.out.println("数据帧类型：" + objectTypeHexString);

            // 获取设备编号 20字节 40字符 判断是哪个雷达的发送的数据
            byte[] deviceIdData = radarDataHelper.extractHexData(segment, 4, 16);
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < deviceIdData.length; i++) {
                byte b = deviceIdData[i];
                // 16进制数 "32"
                String hexString = String.format("%02X", b);
                // 将16进制字符串转换为十进制整数
                int decimalValue = Integer.parseInt(hexString, 16);
                // 将十进制整数转换为对应的ASCII字符
                char asciiChar = (char) decimalValue;
                // 如果不为0则添加到字符串中
                if (decimalValue != 0) {
                    builder.append(asciiChar);
                }
            }
            System.out.println("设备编号：" + builder);

            //String deviceIdHexString = radarDataHelper.byteArrayToHexString(deviceIdData);
            //System.out.println("设备编号：" + deviceIdHexString);

            byte[] timestampData = radarDataHelper.extractHexData(segment, 24, 8);
            String timestampHexString = radarDataHelper.byteArrayToHexString(timestampData);
            System.out.println("时间戳：" + timestampHexString);
            String localDateTime = getLocalDateTime(segment, timestampData);
            System.out.println("时间戳：" + localDateTime);
            // 获取数据
            // 用获取到的数据长度 减去数据长度(2字节)、数据帧类型(1字节)、校验和(1字节)、数据编号)、时间戳(8字节)、包头包尾(8字节)
            int dataLength = byteLength - 2 - 1 - 1 - 20 - 8;
            segment = segment.substring(64);
            System.out.println("总数据：" + segment);

            // 如果是目标轨迹数据
            if (objectTypeHexString.equals("01")) {
                if (dataLength >= 36) {
                    byte[] dataBytes = radarDataHelper.hexStringToByteArray(segment);
                    // 36个字节为一组数据 进行分组解析
                    for (int i = 0; i < dataBytes.length; i += 36) {
                        byte[] dataSegment = Arrays.copyOfRange(dataBytes, i, i + 36);
                        String dataSegmentHexString = radarDataHelper.byteArrayToHexStringAll(dataSegment);
                        System.out.println("数据：" + dataSegmentHexString);
                        // 获取目标所属车道
                        byte[] targetLaneData = radarDataHelper.extractHexData(dataSegmentHexString, 2, 1);
                        String targetLaneHexString = radarDataHelper.byteArrayToHexStringAll(targetLaneData);
                        // 将16进制数转换为10进制数
                        int targetLane = Integer.parseInt(targetLaneHexString, 16);
                        System.out.println("目标所属车道：" + targetLane);
                        // 获取目标类型
                        byte[] carTypeData = radarDataHelper.extractHexData(dataSegmentHexString, 3, 1);
                        String carTypeHexString = radarDataHelper.byteArrayToHexStringAll(carTypeData);
                        System.out.println("目标类型：" + carTypeHexString);
                        // 获取目标速度
                        byte[] targetSpeedData = radarDataHelper.extractHexData(dataSegmentHexString, 20, 2);
                        String targetSpeedHexString = radarDataHelper.byteArrayToHexStringAll(targetSpeedData);
                        double targetSpeed = Integer.parseInt(targetSpeedHexString, 16) * 0.01;
                        System.out.println("目标速度：" + targetSpeed);
                        // 获取目标经度
                        byte[] targetLongitudeData = radarDataHelper.extractHexData(dataSegmentHexString, 28, 4);
                        String targetLongitudeHexString = radarDataHelper.byteArrayToHexStringAll(targetLongitudeData);
                        // 将十六进制字符串转换为long类型的数字
                        long targetLongitudeLongValue = Long.parseLong(targetLongitudeHexString, 16);
                        // 将long类型的数字转换为double类型的数字
                        double targetLongitude = (double) targetLongitudeLongValue / 10000000;
                        System.out.println("目标经度：" + targetLongitude);
                        // 获取目标纬度
                        byte[] targetLatitudeData = radarDataHelper.extractHexData(dataSegmentHexString, 32, 4);
                        String targetLatitudeHexString = radarDataHelper.byteArrayToHexStringAll(targetLatitudeData);

                        // 将十六进制字符串转换为long类型的数字
                        long targetLatitudeLongValue = Long.parseLong(targetLatitudeHexString, 16);
                        // 将long类型的数字转换为double类型的数字
                        double targetLatitude = (double) targetLatitudeLongValue / 10000000;
                        System.out.println("目标纬度：" + targetLatitude);
                    }
                }
            }
            // 如果是交通流量数据
            else if (objectTypeHexString.equals("03")) {
                if (dataLength >= 22) {
                    byte[] dataBytes = radarDataHelper.hexStringToByteArray(segment);
                    // 22个字节为一组数据 进行分组解析
                    for (int i = 0; i < dataBytes.length; i += 22) {
                        byte[] dataSegment = Arrays.copyOfRange(dataBytes, i, i + 22);
                        String dataSegmentHexString = radarDataHelper.byteArrayToHexStringAll(dataSegment);
                        System.out.println("数据：" + dataSegmentHexString);
                        // 获取统计周期
                        byte[] statisticsCycleData = radarDataHelper.extractHexData(dataSegmentHexString, 0, 2);
                        String statisticsCycleHexString = radarDataHelper.byteArrayToHexStringAll(statisticsCycleData);
                        // 将16进制数转换为10进制数
                        int statisticsCycle = Integer.parseInt(statisticsCycleHexString, 16);
                        System.out.println("统计周期：" + statisticsCycle);
                        // 获取实时车流量
                        byte[] realTimeTrafficFlowData = radarDataHelper.extractHexData(dataSegmentHexString, 12, 2);
                        String realTimeTrafficFlowHexString = radarDataHelper.byteArrayToHexStringAll(realTimeTrafficFlowData);
                        // 将16进制数转换为10进制数
                        int realTimeTrafficFlow = Integer.parseInt(realTimeTrafficFlowHexString, 16);
                        System.out.println("总流量：" + realTimeTrafficFlow);
                        // 获取平均车速
                        byte[] averageSpeedData = radarDataHelper.extractHexData(dataSegmentHexString, 14, 2);
                        String averageSpeedHexString = radarDataHelper.byteArrayToHexStringAll(averageSpeedData);
                        double averageSpeed = Integer.parseInt(averageSpeedHexString, 16) * 0.1;
                        System.out.println("平均速度：" + averageSpeed);
                        // 获取最大排队长度
                        byte[] maxQueueLengthData = radarDataHelper.extractHexData(dataSegmentHexString, 20, 2);
                        String maxQueueLengthHexString = radarDataHelper.byteArrayToHexStringAll(maxQueueLengthData);
                        // 将16进制数转换为10进制数
                        int maxQueueLength = Integer.parseInt(maxQueueLengthHexString, 16);
                        System.out.println("最大排队长度：" + maxQueueLength);
                    }
                }
            }
        }
    }

    @Test
    public void test2(){
        String data = "\\x55\\xaa\\x55\\xbb\\x01\\x88\\x01\\x0121626098\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x18\\x0b\\x08\\x122\\x1e\\x02W\\x0fF\\x0b\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x04~\\x15r\\x00Z\\xf9\\xde\\x16\\x1d\\x00\\n\\x00\\xb4\\xff\\xa6G\\x86\\x90\\xa8\\x11\\xe1\\xb6C\\x0f^\\r\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x08\\x01\\xd66\\xe2\\x00\\x00\\xf8\\xd0\\x19\\xdf\\x06\\xa4\\x00\\x00\\x00\\x00G\\x86\\x8d\\xe7\\x11\\xe1\\xd4M\\x0fG\\x0c\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x02N.\\xf4\\x00\\x00\\xf9>\\x18S\\x00\\x00\\xfe\\xf2\\x00\\x00G\\x86\\x8ec\\x11\\xe1\\xcd-\\x0fH\\x0c\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x02\\xa8\\x18V\\x00\\x1e\\xf9 \\x18\\xc0\\x00\\x00\\x00\\x00\\x00\\x00G\\x86\\x8e\\xc1\\x11\\xe1\\xb8\\xdc\\x0f]\\r\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x08\\x01\\xa4c\\xe2\\x00\\x00\\xf7\\xea\\x1d\\x1c\\x00\\x00\\x00\\x00\\x00\\x00G\\x86\\x8d\\xb3\\x11\\xe1\\xfc\\xb9\\x0fA\\x0c\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x03H\\x11D\\x00F\\xf9\\x84\\x17]\\xff\\xec\\x00\\x00\\x01\\x0eG\\x86\\x8fg\\x11\\xe1\\xb2\\x82\\x0f@\\x0b\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x04V\\x1e2\\x00x\\xfaL\\x14\\x99\\x00\\x00\\x04\\xb0\\x00\\x00G\\x86\\x90\\x7f\\x11\\xe1\\xbe\\x1f\\x0fP\\x0b\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x04`\\\\\\xbc\\x00F\\xf9\\xa2\\x16\\xf1\\x00\\x00\\x00\\x00\\x00\\x00G\\x86\\x90\\x89\\x11\\xe1\\xf6N\\x0f\\x1d\\x0b\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x07\\x03\\xca\\'\\x1a\\xff\\xe2\\xfa8\\x14\\xd1\\x00\\x00\\x01r\\x00\\x00G\\x86\\x8f\\xee\\x11\\xe1\\xc6 \\x0f\\\\\\x0c\\x022\\x14\\x0f\\xff\\xff\\xff\\x07\\x08\\x03>j\"\\x00\\x00\\xf9z\\x17|\\x00\\x00\\x00\\x00\\x00\\x00G\\x86\\x8f\\\\\\x11\\xe2\\x02W\\x55\\xcc\\x55\\xdd'";
        // 替换 \n、\r、\t
        String dataString = data.replaceAll("\\\\n", "").replaceAll("\\\\r", "").replaceAll("\\\\t", "").replaceAll(" ", "");
        System.out.println(dataString);
        // 以\x为分割符将数据分组
        String[] segments = dataString.split("\\\\x");
        // 对每个字符串做分析 前两个字符作为为一个16进制字节 添加到字节数组中 如果还有剩余的字符 每个字符作为一个字节添加到字节数组中
        LinkedList<byte[]> byteArrayList = new LinkedList<>();
        for (int i = 0; i < segments.length; i++) {
            String segment = segments[i];
            if (segment.length() >= 2) {
                // 截取前两个字符
                String hexString = segment.substring(0, 2);
                // 将两位的字符转换为十六进制的字节
                byte b = hexStringToByte(hexString);
                byte[] bytes1 = {b};
                byteArrayList.add(bytes1);

                // 截取剩余的字符串
                String remainingString = segment.substring(2);
                // 如果是设备编号
                if (remainingString.equals("21626098") || remainingString.equals("21626092") ||
                        remainingString.equals("21626163") || remainingString.equals("21626114") ||
                        remainingString.equals("21626107") || remainingString.equals("21626197")) {
                    // 每个字符转换为ASIC码
                    for (int j = 0; j < remainingString.length(); j++) {
                        byte asic = charToAsciiByte(remainingString.substring(j, j + 1));
                        byte[] bytes2 = new byte[]{asic};
                        byteArrayList.add(bytes2);
                    }
                }else {
                    // 每个字符作为一个字节添加到字节数组列表中
                    for (int j = 0; j < remainingString.length(); j++) {
                        byte asic = charToAsciiByte(remainingString.substring(j, j + 1));
                        byte[] bytes2 = new byte[]{asic};
                        byteArrayList.add(bytes2);
                    }
                }
            }else if (segment.length() == 1){
                byte asic = charToAsciiByte(segment);
                byte[] bytes2 = new byte[]{asic};
                byteArrayList.add(bytes2);
            }else {
                System.out.println("无效的字符串：" + segment);
            }
        }
        // 将字节数组列表转换为字节数组
        byte[] mergedData;
        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            for (byte[] bytes : byteArrayList) {
                outputStream.write(bytes);
            }
            mergedData = outputStream.toByteArray();
        } catch (IOException e) {
            throw new RuntimeException("Failed to merge byte arrays", e);
        }

        StringBuilder hexString = new StringBuilder();
        for (byte b : mergedData) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }

        System.out.println(hexString);

    }

    public static byte charToAsciiByte(String charStr) {
        if (charStr == null || charStr.length() != 1) {
            throw new IllegalArgumentException("Input string must be one character long.");
        }
        // 获取字符的ASCII码值
        int asciiValue = charStr.charAt(0);
        // 将ASCII码值转换为字节
        return (byte) asciiValue;
    }

    public static byte hexStringToByte(String hexString) {
        if (hexString == null || hexString.length() != 2) {
            throw new IllegalArgumentException("Input string must be two characters long.");
        }
        // 将字符串转换为整数，并指定基数为16
        int intValue = Integer.parseInt(hexString, 16);
        // 将整数转换为字节
        return (byte) intValue;
    }

    @Test
    public void test3(){
        // 给定的转义过后的字节数据
        byte[] data = new byte[] {
                (byte) 0x55, (byte) 0xaa, (byte) 0x55, (byte) 0xbb,
                0x01, (byte) 0x88, 0x01, 0x01,
                '2', '1', '6', '2', '6', '0', '9', '8',
                0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, (byte) 0x18, 0x0b, 0x08, (byte) 0x12,
                '2', (byte) 0x1e, 0x02, 'W', (byte) 0x0f, 'F', (byte) 0x0b, 0x02,
                '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff, (byte) 0xff, 0x07, 0x07,
                0x04, '~', (byte) 0x15, 'r', 0x00, 'Z', (byte) 0xf9, (byte) 0xde,
                0x16, (byte) 0x1d, 0x00, 0x0a, 0x00, (byte) 0xb4, (byte) 0xff, (byte) 0xa6,
                'G', (byte) 0x86, (byte) 0x90, (byte) 0xa8, (byte) 0x11, (byte) 0xe1, (byte) 0xb6, 'C',
                0x0f, '^', 0x0d, 0x02, '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff,
                (byte) 0xff, (byte) 0xff, 0x07, 0x08, 0x01, (byte) 0xd6, '6', (byte) 0xe2,
                0x00, 0x00, (byte) 0xf8, (byte) 0xd0, (byte) 0x19, (byte) 0xdf, 0x06, (byte) 0xa4,
                0x00, 0x00, 0x00, 0x00, 'G', (byte) 0x86, (byte) 0x8d, (byte) 0xe7,
                (byte) 0x11, (byte) 0xe1, (byte) 0xd4, 'M', 0x0f, 'G', 0x0c, 0x02,
                '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff, (byte) 0xff, 0x07, 0x07,
                0x02, 'N', '.', (byte) 0xf4, 0x00, 0x00, (byte) 0xf9, '>',
                (byte) 0x18, 'S', 0x00, 0x00, (byte) 0xfe, (byte) 0xf2, 0x00, 0x00,
                'G', (byte) 0x86, (byte) 0x8e, 'c', (byte) 0x11, (byte) 0xe1, (byte) 0xcd, '-',
                0x0f, 'H', 0x0c, 0x02, '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff,
                (byte) 0xff, (byte) 0xff, 0x07, 0x07, 0x02, (byte) 0xa8, 0x18, 'V',
                0x00, (byte) 0x1e, (byte) 0xf9, ' ', (byte) 0x18, (byte) 0xc0, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 'G', (byte) 0x86, (byte) 0x8e, (byte) 0xc1,
                (byte) 0x11, (byte) 0xe1, (byte) 0xb8, (byte) 0xdc, 0x0f, ']',
                0x0d, 0x02, '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff,
                (byte) 0xff, 0x07, 0x08, 0x01, (byte) 0xa4, 'c', (byte) 0xe2, 0x00,
                0x00, (byte) 0xf7, (byte) 0xea, (byte) 0x1d, (byte) 0x1c, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00, 'G', (byte) 0x86, (byte) 0x8d, (byte) 0xb3,
                (byte) 0x11, (byte) 0xe1, (byte) 0xfc, (byte) 0xb9, 0x0f, 'A',
                0x0c, 0x02, '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff,
                (byte) 0xff, 0x07, 0x07, 0x03, 'H', 0x11, 'D', 0x00,
                'F', (byte) 0xf9, (byte) 0x84, 0x17, ']', (byte) 0xff, (byte) 0xec, 0x00,
                0x00, 0x01, 0x0e, 'G', (byte) 0x86, (byte) 0x8f, 'g', (byte) 0x11,
                (byte) 0xe1, (byte) 0xb2, (byte) 0x82, 0x0f, '@', 0x0b, 0x02, '2',
                (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff, (byte) 0xff, 0x07, 0x07, 0x04,
                'V', 0x1e, '2', 0x00, 'x', (byte) 0xfa, 'L', 0x14,
                (byte) 0x99, 0x00, 0x00, 0x04, (byte) 0xb0, 0x00, 0x00, 'G',
                (byte) 0x86, (byte) 0x90, (byte) 0x7f, (byte) 0x11, (byte) 0xe1, (byte) 0xbe, 0x1f, 0x0f,
                'P', 0x0b, 0x02, '2', (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff,
                (byte) 0xff, 0x07, 0x07, 0x04, '`', '\\', (byte) 0xbc, 0x00,
                'F', (byte) 0xf9, (byte) 0xa2, 0x16, (byte) 0xf1, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 'G', (byte) 0x86, (byte) 0x90, (byte) 0x89, (byte) 0x11,
                (byte) 0xe1, (byte) 0xf6, 'N', 0x0f, 0x1d, 0x0b, 0x02, '2',
                (byte) 0x14, (byte) 0x0f, (byte) 0xff, (byte) 0xff, (byte) 0xff, 0x07, 0x07, 0x03,
                (byte) 0xca, 0x27, 0x1a, (byte) 0xff, (byte) 0xe2, (byte) 0xfa, '8', 0x14,
                (byte) 0xd1, 0x00, 0x00, 0x01, 'r', 0x00, 0x00, 'G',
                (byte) 0x86, (byte) 0x8f, (byte) 0xee, (byte) 0x11, (byte) 0xe2, 0x02, 'W', 'U',
                (byte) 0xcc, 'U', (byte) 0xdd
        };

        StringBuilder hexString = new StringBuilder();
        for (byte b : data) {
            String hex = Integer.toHexString(0xFF & b);
            if (hex.length() == 1) {
                hexString.append('0');
            }
            hexString.append(hex);
        }

        System.out.println(hexString.toString());
    }

    private String getLocalDateTime(String segment, byte[] timestampData) {
        // 第一个字节 -> year
        byte year = timestampData[0];
        // 将16进制字节转换为整数
        int yearInt = Integer.parseInt(String.format("%02X", year), 16);
        // 创建位掩码来提取第0到7位
        int yearMask = 0xFF;
        // 使用位掩码提取第0到第7位
        int extractedYearBits = yearInt & yearMask;
        // 数据 0~255 对应 2000~2255 year 获取实际的年份
        int yearValue = extractedYearBits + 2000;
        System.out.println("年份：" + yearValue);

        // 第二个字节 -> month
        byte month = timestampData[1];
        // 将16进制字节转换为整数
        int monthInt = Integer.parseInt(String.format("%02X", month), 16);
        // 创建位掩码来提取第0到3位
        // 1~12 对应 1~12 month
        int monthMask = 0x0F;
        // 使用位掩码提取第0到第3位
        int monthValue = monthInt & monthMask;
        System.out.println("月份：" + monthValue);

        // 第三个字节 -> day
        byte day = timestampData[2];
        // 将16进制字节转换为整数
        int dayInt = Integer.parseInt(String.format("%02X", day), 16);
        // 创建位掩码来提取第0到4位
        // 数据 1~31 对应 1~31 day
        int dayMask = 0x1F;
        // 使用位掩码提取第0到第4位
        // 数据 1~31 对应 1~31 day
        int dayValue = dayInt & dayMask;
        System.out.println("天：" + dayValue);

        // 第四个字节 -> hour
        byte hour = timestampData[3];
        // 将16进制字节转换为整数
        int hourInt = Integer.parseInt(String.format("%02X", hour), 16);
        // 创建位掩码来提取第0到4位
        int hourMask = 0x1F;
        // 使用位掩码提取第0到第4位
        // 数据 0~31 对应 0~23 hour
        int hourValue = hourInt & hourMask;
        System.out.println("小时：" + hourValue);

        // 第五个字节 -> minute
        byte minute = timestampData[4];
        // 将16进制字节转换为整数
        int minuteInt = Integer.parseInt(String.format("%02X", minute), 16);
        // 创建位掩码来提取第0到5位
        int minuteMask = 0x3F;
        // 使用位掩码提取第0到第5位
        // 数据 0~63 对应 0~59 minute
        int minuteValue = minuteInt & minuteMask;
        System.out.println("分钟：" + minuteValue);

        // 第六个字节 -> second
        byte second = timestampData[5];
        // 将16进制字节转换为整数
        int secondInt = Integer.parseInt(String.format("%02X", second), 16);
        // 创建位掩码来提取第0到5位
        int secondMask = 0x3F;
        // 使用位掩码提取第0到第5位
        // 数据 0~63 对应 0~59 second
        int secondValue = secondInt & secondMask;
        System.out.println("秒：" + secondValue);
        // 第7、8个字节-> millisecond
        // 把第7和第8个字节拼接成16进制字符串 再转换为整数
        byte[] millisecondData = radarDataHelper.extractHexData(segment, 30, 2);
        String millisecondHexString = radarDataHelper.byteArrayToHexString(millisecondData);
        int millisecondValue = Integer.parseInt(millisecondHexString, 16);
        // 创建位掩码来提取第0到9位
        int millisecondMask = 0x3FF;
        // 使用位掩码提取第0到第9位
        millisecondValue = millisecondValue & millisecondMask;
        // 数据 0~999 对应 0~999 毫秒
        System.out.println("毫秒：" + millisecondValue);
        // 拼接成LocalDateTime 类型的数据
        String localDateTime =  yearValue + "-" + monthValue + "-" + dayValue + " " + hourValue + ":" + minuteValue + ":" + secondValue;
        return localDateTime;
    }
}
