package chuankou;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class SerialDataReceiver {
    private static final int BUFFER_SIZE = 1024;
    private static final int MIN_PACKET_LENGTH = 9;
    private static final byte[] START_MARKER = {(byte) 0xDD, (byte) 0xCC};
    
    // 使用非静态成员避免多线程环境下的竞争条件
    private byte[] dataBuffer = new byte[BUFFER_SIZE];
    private int bufferPosition = 0;
    private final List<byte[]> reusablePackets = new ArrayList<>();
    
    /**
     * 实例方法：接收串口原始数据并解析完整数据包
     * @param rawData 原始数据
     * @param debugEnabled 是否启用调试
     * @param maxRawDataPrintLength 最大打印长度
     * @return 解析出的完整数据包列表，如果没有完整包则返回空列表
     */
    public List<byte[]> receiveData(byte[] rawData, boolean debugEnabled, int maxRawDataPrintLength) {
        reusablePackets.clear();
        
        if (rawData == null || rawData.length == 0) {
            return reusablePackets;
        }
        
        // 打印原始接收数据（调试用）
        if (debugEnabled) {
            printRawData("收到串口原始数据", rawData, maxRawDataPrintLength);
        }
        
        // 检查缓冲区容量，动态处理
        if (!ensureBufferCapacity(rawData.length)) {
            // 缓冲区不足时，清理并重新开始
            if (debugEnabled) {
                System.out.println("缓冲区不足，清空缓冲区重新开始");
            }
            bufferPosition = 0;
        }
        
        // 将数据添加到缓冲区
        System.arraycopy(rawData, 0, dataBuffer, bufferPosition, rawData.length);
        bufferPosition += rawData.length;
        
        // 处理缓冲区中的数据并收集完整包
        processBuffer(reusablePackets, debugEnabled);
        
        return new ArrayList<>(reusablePackets);
    }
    
    /**
     * 确保缓冲区有足够容量，如不够则尝试压缩
     */
    private boolean ensureBufferCapacity(int required) {
        if (bufferPosition + required <= dataBuffer.length) {
            return true;
        }
        
        // 尝试通过压缩缓冲区来腾出空间
        int startIndex = findStartMarker();
        if (startIndex > 0) {
            compactBuffer(startIndex);
            return bufferPosition + required <= dataBuffer.length;
        }
        
        return false;
    }
    
    /**
     * 处理缓冲区中的数据，解析完整数据包
     */
    private void processBuffer(List<byte[]> completePackets, boolean debugEnabled) {
        while (bufferPosition >= MIN_PACKET_LENGTH) {
            // 查找起始标记
            int startIndex = findStartMarker();
            if (startIndex == -1) {
                // 没有找到起始标记，清空无效数据
                if (debugEnabled) {
                    System.out.println("未找到起始标记，清空缓冲区");
                }
                bufferPosition = 0;
                return;
            }
            
            // 检查是否有足够的数据读取数据长度
            if (startIndex + 4 > bufferPosition) {
                // 数据不足，等待更多数据
                compactBuffer(startIndex);
                return;
            }
            
            // 读取数据长度 (大端序)
            int dataLength = ((dataBuffer[startIndex + 2] & 0xFF) << 8) | 
                           (dataBuffer[startIndex + 3] & 0xFF);
            int totalPacketLength = 2 + 2 + dataLength + 2; // 起始标记2 + 数据长度2 + 数据内容 + CRC2
            
            // 检查数据长度有效性
            if (dataLength < 0 || totalPacketLength > BUFFER_SIZE) {
                if (debugEnabled) {
                    System.out.println("无效数据长度: " + dataLength + ", 跳过起始字节");
                }
                // 跳过错误的起始标记，继续查找
                compactBuffer(startIndex + 1);
                continue;
            }
            
            // 检查是否收到完整数据包
            if (startIndex + totalPacketLength > bufferPosition) {
                // 数据包不完整，等待更多数据
                compactBuffer(startIndex);
                return;
            }
            
            // 提取完整数据包
            byte[] packet = Arrays.copyOfRange(dataBuffer, startIndex, startIndex + totalPacketLength);
            
            if (debugEnabled) {
                System.out.println("解析到完整数据包: " + bytesToHex(packet));
            }
            
            // 添加到返回列表
            completePackets.add(packet);
            
            // 移动缓冲区位置
            int remaining = bufferPosition - (startIndex + totalPacketLength);
            if (remaining > 0) {
                System.arraycopy(dataBuffer, startIndex + totalPacketLength, 
                               dataBuffer, 0, remaining);
            }
            bufferPosition = remaining;
        }
    }
    
    /**
     * 查找起始标记位置
     */
    private int findStartMarker() {
        for (int i = 0; i <= bufferPosition - START_MARKER.length; i++) {
            if (dataBuffer[i] == START_MARKER[0] && dataBuffer[i + 1] == START_MARKER[1]) {
                return i;
            }
        }
        return -1;
    }
    
    /**
     * 压缩缓冲区，将有效数据移到开头
     */
    private void compactBuffer(int startIndex) {
        if (startIndex > 0 && startIndex < bufferPosition) {
            System.arraycopy(dataBuffer, startIndex, dataBuffer, 0, 
                           bufferPosition - startIndex);
            bufferPosition -= startIndex;
        }
    }
    
    /**
     * 打印原始数据（调试用）
     */
    private void printRawData(String prefix, byte[] data, int maxPrintLength) {
        if (data == null || data.length == 0) {
            System.out.println(prefix + ": 空数据");
            return;
        }
        
        StringBuilder sb = new StringBuilder();
        sb.append(prefix).append(" [长度: ").append(data.length).append("]: ");
        
        int printLength = Math.min(data.length, maxPrintLength);
        for (int i = 0; i < printLength; i++) {
            sb.append(String.format("%02X ", data[i]));
        }
        
        if (data.length > maxPrintLength) {
            sb.append("... [截断，总长度: ").append(data.length).append("]");
        }
        
        System.out.println(sb.toString());
    }
    
    /**
     * 工具方法：字节数组转十六进制字符串
     */
    private String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return sb.toString().trim();
    }
    
    /**
     * 清空缓冲区（避免内存泄漏）
     */
    public void clearBuffer() {
        bufferPosition = 0;
        // 可选：清空缓冲区内容
        Arrays.fill(dataBuffer, (byte) 0);
    }
    
    /**
     * 获取当前缓冲区状态
     */
    public int getBufferStatus() {
        return bufferPosition;
    }
    
    /**
     * 获取缓冲区容量
     */
    public int getBufferCapacity() {
        return dataBuffer.length;
    }
}