package com.evobms.project.bms.controller;
public class GBT32960ExtremeDataParser {

    /**
     * 解析极值数据 (数据类型 0x06)
     */
    public static ExtremeData parseExtremeData(byte[] data, int offset) {
        if (data == null || offset >= data.length) {
            return null;
        }

        ExtremeData extremeData = new ExtremeData();

        try {
            // 检查数据类型
            byte dataType = data[offset++];
            if (dataType != 0x06) {
                System.err.println("错误的数据类型，期望0x06(极值数据)，实际: 0x" + String.format("%02X", dataType));
                return null;
            }

            // 数据长度
            byte dataLength = data[offset++];
            System.out.println("极值数据长度: " + (dataLength & 0xFF) + " 字节");

            // 电池电压最高值 (2字节, 单位: 0.01V)
            int maxVoltage = ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
            offset += 2;
            extremeData.setMaxVoltage(maxVoltage / 100.0); // 转换为V

            // 电池电压最高所在子系统号 (1字节)
            extremeData.setMaxVoltageSubsystemId(data[offset++] & 0xFF);

            // 电池电压最高所在电芯号 (1字节)
            extremeData.setMaxVoltageCellId(data[offset++] & 0xFF);

            // 电池电压最低值 (2字节, 单位: 0.01V)
            int minVoltage = ((data[offset] & 0xFF) << 8) | (data[offset + 1] & 0xFF);
            offset += 2;
            extremeData.setMinVoltage(minVoltage / 100.0); // 转换为V

            // 电池电压最低所在子系统号 (1字节)
            extremeData.setMinVoltageSubsystemId(data[offset++] & 0xFF);

            // 电池电压最低所在电芯号 (1字节)
            extremeData.setMinVoltageCellId(data[offset++] & 0xFF);

            // 电池温度最高值 (1字节, 偏移量40°C, 单位: 1°C)
            int maxTemperature = (data[offset++] & 0xFF) - 40;
            extremeData.setMaxTemperature(maxTemperature);

            // 电池温度最高所在子系统号 (1字节)
            extremeData.setMaxTemperatureSubsystemId(data[offset++] & 0xFF);

            // 电池温度最高所在探针号 (1字节)
            extremeData.setMaxTemperatureProbeId(data[offset++] & 0xFF);

            // 电池温度最低值 (1字节, 偏移量40°C, 单位: 1°C)
            int minTemperature = (data[offset++] & 0xFF) - 40;
            extremeData.setMinTemperature(minTemperature);

            // 电池温度最低所在子系统号 (1字节)
            extremeData.setMinTemperatureSubsystemId(data[offset++] & 0xFF);

            // 电池温度最低所在探针号 (1字节)
            extremeData.setMinTemperatureProbeId(data[offset++] & 0xFF);

            return extremeData;

        } catch (Exception e) {
            System.err.println("解析极值数据时发生错误: " + e.getMessage());
            return null;
        }
    }

    /**
     * 从完整的数据单元中查找并解析极值数据
     */
    public static ExtremeData findAndParseExtremeData(byte[] dataUnit) {
        if (dataUnit == null || dataUnit.length == 0) {
            return null;
        }

        int offset = 0;
        while (offset < dataUnit.length) {
            byte dataType = dataUnit[offset];

            if (dataType == 0x06) {
                // 找到极值数据
                System.out.println("找到极值数据，位置: " + offset);
                return parseExtremeData(dataUnit, offset);
            } else {
                // 跳过其他数据类型
                offset++; // 跳过数据类型
                if (offset < dataUnit.length) {
                    byte length = dataUnit[offset];
                    offset += 1 + (length & 0xFF); // 跳过长度字节和数据内容
                }
            }
        }

        System.out.println("未找到极值数据");
        return null;
    }

    /**
     * 极值数据实体类
     */
    public static class ExtremeData {
        private double maxVoltage;          // 最高电压 (V)
        private int maxVoltageSubsystemId;  // 最高电压子系统号
        private int maxVoltageCellId;       // 最高电压电芯号
        private double minVoltage;          // 最低电压 (V)
        private int minVoltageSubsystemId;  // 最低电压子系统号
        private int minVoltageCellId;       // 最低电压电芯号
        private int maxTemperature;         // 最高温度 (°C)
        private int maxTemperatureSubsystemId; // 最高温度子系统号
        private int maxTemperatureProbeId;  // 最高温度探针号
        private int minTemperature;         // 最低温度 (°C)
        private int minTemperatureSubsystemId; // 最低温度子系统号
        private int minTemperatureProbeId;  // 最低温度探针号

        // Getter和Setter方法
        public double getMaxVoltage() { return maxVoltage; }
        public void setMaxVoltage(double maxVoltage) { this.maxVoltage = maxVoltage; }

        public int getMaxVoltageSubsystemId() { return maxVoltageSubsystemId; }
        public void setMaxVoltageSubsystemId(int maxVoltageSubsystemId) { this.maxVoltageSubsystemId = maxVoltageSubsystemId; }

        public int getMaxVoltageCellId() { return maxVoltageCellId; }
        public void setMaxVoltageCellId(int maxVoltageCellId) { this.maxVoltageCellId = maxVoltageCellId; }

        public double getMinVoltage() { return minVoltage; }
        public void setMinVoltage(double minVoltage) { this.minVoltage = minVoltage; }

        public int getMinVoltageSubsystemId() { return minVoltageSubsystemId; }
        public void setMinVoltageSubsystemId(int minVoltageSubsystemId) { this.minVoltageSubsystemId = minVoltageSubsystemId; }

        public int getMinVoltageCellId() { return minVoltageCellId; }
        public void setMinVoltageCellId(int minVoltageCellId) { this.minVoltageCellId = minVoltageCellId; }

        public int getMaxTemperature() { return maxTemperature; }
        public void setMaxTemperature(int maxTemperature) { this.maxTemperature = maxTemperature; }

        public int getMaxTemperatureSubsystemId() { return maxTemperatureSubsystemId; }
        public void setMaxTemperatureSubsystemId(int maxTemperatureSubsystemId) { this.maxTemperatureSubsystemId = maxTemperatureSubsystemId; }

        public int getMaxTemperatureProbeId() { return maxTemperatureProbeId; }
        public void setMaxTemperatureProbeId(int maxTemperatureProbeId) { this.maxTemperatureProbeId = maxTemperatureProbeId; }

        public int getMinTemperature() { return minTemperature; }
        public void setMinTemperature(int minTemperature) { this.minTemperature = minTemperature; }

        public int getMinTemperatureSubsystemId() { return minTemperatureSubsystemId; }
        public void setMinTemperatureSubsystemId(int minTemperatureSubsystemId) { this.minTemperatureSubsystemId = minTemperatureSubsystemId; }

        public int getMinTemperatureProbeId() { return minTemperatureProbeId; }
        public void setMinTemperatureProbeId(int minTemperatureProbeId) { this.minTemperatureProbeId = minTemperatureProbeId; }

        @Override
        public String toString() {
            return String.format(
                    "极值数据:\n" +
                            "电压 - 最高: %.2fV (子系统%d, 电芯%d)\n" +
                            "电压 - 最低: %.2fV (子系统%d, 电芯%d)\n" +
                            "温度 - 最高: %d°C (子系统%d, 探针%d)\n" +
                            "温度 - 最低: %d°C (子系统%d, 探针%d)",
                    maxVoltage, maxVoltageSubsystemId, maxVoltageCellId,
                    minVoltage, minVoltageSubsystemId, minVoltageCellId,
                    maxTemperature, maxTemperatureSubsystemId, maxTemperatureProbeId,
                    minTemperature, minTemperatureSubsystemId, minTemperatureProbeId
            );
        }
    }

    /**
     * 测试方法
     */
    public static void main(String[] args) {
        // 模拟极值数据 (16进制)
        // 06 0C 0F A0 01 01 0C 80 02 02 3C 01 01 28 02 02
        // 解释:
        // 06 - 数据类型(极值数据)
        // 0C - 数据长度(12字节)
        // 0F A0 - 最高电压: 4000 (40.00V)
        // 01 - 最高电压子系统号: 1
        // 01 - 最高电压电芯号: 1
        // 0C 80 - 最低电压: 3200 (32.00V)
        // 02 - 最低电压子系统号: 2
        // 02 - 最低电压电芯号: 2
        // 3C - 最高温度: 60 (60-40=20°C)
        // 01 - 最高温度子系统号: 1
        // 01 - 最高温度探针号: 1
        // 28 - 最低温度: 40 (40-40=0°C)
        // 02 - 最低温度子系统号: 2
        // 02 - 最低温度探针号: 2

        byte[] testExtremeData = {
                (byte) 0x06,                   // 数据类型
                (byte) 0x0C,                   // 数据长度
                (byte) 0x0F, (byte) 0xA0,     // 最高电压
                (byte) 0x01,                   // 最高电压子系统号
                (byte) 0x01,                   // 最高电压电芯号
                (byte) 0x0C, (byte) 0x80,     // 最低电压
                (byte) 0x02,                   // 最低电压子系统号
                (byte) 0x02,                   // 最低电压电芯号
                (byte) 0x3C,                   // 最高温度
                (byte) 0x01,                   // 最高温度子系统号
                (byte) 0x01,                   // 最高温度探针号
                (byte) 0x28,                   // 最低温度
                (byte) 0x02,                   // 最低温度子系统号
                (byte) 0x02                    // 最低温度探针号
        };

        ExtremeData result = parseExtremeData(testExtremeData, 0);
        if (result != null) {
            System.out.println(result.toString());
        }
    }
}
