// 伪代码
void process_data(uint8_t* data, int len) {
    int i = 0;
    if (data[i] == 0xAA) {
        i++;
        if (data[i] == 0x55) {
            i++;
            uint8_t cmd = data[i];
            i++;
            uint8_t data_len = data[i];
            i++;
            // ...一堆嵌套的 if-else...
        }
    }
}

typedef enum {
    STATE_HEADER1,      // 等待包头1 (0xAA)
    STATE_HEADER2,      // 等待包头2 (0x55)
    STATE_CMD,          // 等待命令字
    STATE_LEN,          // 等待数据长度
    STATE_DATA,         // 接收数据
    STATE_CHECKSUM      // 等待校验和
} ParserState;

static ParserState current_state = STATE_HEADER1; // 初始状态

#define PACKET_HEADER_1         0xAA
#define PACKET_HEADER_2         0x55
#define CMD_SET_LED             0x01
#define CMD_QUERY_LED           0x02
#define CMD_RESPONSE_LED        0x82

/**
 * @brief 蓝牙数据处理任务，调用状态机解析器
 */
void BT_Task()
{
    uint8_t temp_buffer[BT_PROCESS_BUFFER_SIZE]; // 用于临时存储从环形缓冲区读取的数据
    rt_size_t read_len;

    // 从环形缓冲区中读取数据
    read_len = rt_ringbuffer_get(&uart3_rx_ringbuffer, temp_buffer, BT_PROCESS_BUFFER_SIZE);

    if (read_len > 0)
    {
        // 逐个字节地送入解析器
        for (rt_size_t i = 0; i < read_len; i++)
        {
            parse_byte(temp_buffer[i]);
        }
    }
}

void parse_byte(uint8_t byte)
{
    switch (current_state)
    {
        // 状态1: 等待 0xAA
        case STATE_HEADER1:
            if (byte == 0xAA) {
                current_state = STATE_HEADER2; // 收到，进入下一状态
            }
            break;

        // 状态2: 等待 0x55
        case STATE_HEADER2:
            if (byte == 0x55) {
                current_state = STATE_CMD; // 收到，进入下一状态
            } else {
                current_state = STATE_HEADER1; // 错误，重置回初始状态
            }
            break;

        // 状态3: 接收命令
        case STATE_CMD:
            packet.cmd = byte;
            current_state = STATE_LEN;
            break;
        // 状态4: 接收长度
        case STATE_WAIT_LEN:
            packet_len = byte;
            if (packet_len > 0)
            {
                data_index = 0;
                parser_state = STATE_WAIT_DATA;
            }
            else // 如果数据长度为0
            {
                parser_state = STATE_WAIT_CHECKSUM;
            }
            break;
        // 状态5: 接收数据
        case STATE_WAIT_DATA:
            packet_buffer[data_index++] = byte;
            if (data_index >= packet_len)
            {
                parser_state = STATE_WAIT_CHECKSUM;
            }
            break;
        // 状态6: 校验和验证
        case STATE_WAIT_CHECKSUM:
        {
            uint8_t checksum = 0;
            checksum += packet_cmd;
            checksum += packet_len;
            for (int i = 0; i < packet_len; i++)
            {
                checksum += packet_buffer[i];
            }

            if (checksum == byte) // 校验成功
            {
                // 一个完整的数据包接收并校验成功！
                handle_packet();
            }
            else
            {
                // 校验失败，可以在此打印错误信息
                my_printf(&huart1, "Checksum error!\n");
            }
            // 无论成功与否，都重置状态机，准备接收下一个包
            parser_state = STATE_WAIT_HEADER_1;
            break;

    }
}

void handle_packet(void)
{
    switch (packet_cmd)
    {
        case CMD_SET_LED:
        {
            uint8_t led_status_data = packet_buffer[0]; // 数据在packet_buffer的第一个字节
            set_led_status(led_status_data); // 调用LED控制函数
            
            // 可以在这里回显调试信息
            my_printf(&huart1, "CMD_SET_LED received, status: 0x%02X\n", led_status_data);
            
            break;
        }

        case CMD_QUERY_LED:
        {
            uint8_t current_led_status = get_led_status(); // 获取当前LED状态
            send_response_packet(CMD_RESPONSE_LED, &current_led_status, 1); // 将状态打包回复
            
            // 调试信息
            my_printf(&huart1, "CMD_QUERY_LED received, responding with status: 0x%02X\n",current_led_status);
            break;
        }
        
        default:
            my_printf(&huart1, "Unknown CMD: 0x%02X\n", packet_cmd);
            break;
    }
}