/*
 * ESP8266 WiFi模块驱动（支持HTTP加密传输）
 * 版本：v2.0 - 加密方案C
 * 修改：
 * 1. 添加HTTP POST请求支持
 * 2. 添加加密数据传输
 * 3. 保留原有TCP兼容接口
 */

#include "esp8266.h"
#include "Serial.h"
#include "Delay.h"
#include "Debug.h"
#include "Crypto.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>  // ← 添加atoi函数声明

// 外部配置（在main.c中定义）
extern const char* WIFI_SSID;
extern const char* WIFI_PASSWORD;
extern const char* HTTP_SERVER_IP;
extern const char* HTTP_SERVER_PORT;
extern const char* HTTP_API_TOKEN;
extern uint8_t g_server_connected;

/* --- 私有辅助函数 --- */
static void ESP8266_SendCmd(const char* cmd) {
    Serial_SendString(cmd);
    Serial_SendString("\r\n");
}

static uint8_t ESP8266_WaitForAck(const char* ack, uint32_t timeout) {
    uint32_t time_start = Get_Time_ms();
    uint32_t time_elapsed;
    Serial_ClearRxBuffer();

    DEBUG_PRINT("[ESP8266] Waiting for: %s (timeout: %dms)\r\n", ack, timeout);

    while(1) {
        time_elapsed = Get_Time_ms() - time_start;
        if (time_elapsed > timeout) {
            DEBUG_PRINT("[ESP8266] Timeout after %dms\r\n", time_elapsed);
            break;
        }

        char* response = Serial_GetRxBuffer();
        if (response && strstr(response, ack) != NULL) {
            DEBUG_OK("[ESP8266] Received expected response");
            return ESP8266_SUCCESS;
        }

        Delay_ms(10);
    }

    DEBUG_PRINT("[ESP8266] Failed! Response: %s\r\n", Serial_GetRxBuffer());
    return ESP8266_FAIL;
}

static uint8_t IsLeapYear(uint16_t year)
{
    return ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) ? 1 : 0;
}

static uint8_t DaysInMonth(uint16_t year, uint8_t month)
{
    static const uint8_t days_table[12] = {31,28,31,30,31,30,31,31,30,31,30,31};
    if (month == 2 && IsLeapYear(year)) return 29;
    return days_table[month - 1];
}

static void EpochToDateTimeUTC8(uint32_t epoch_seconds, ESP8266_DateTime* datetime)
{
    // 转为北京时间（UTC+8）
    uint32_t total = epoch_seconds + 8U * 3600U;
    uint32_t days = total / 86400U;
    uint32_t sec_of_day = total % 86400U;

    datetime->hour = sec_of_day / 3600U;
    datetime->minute = (sec_of_day % 3600U) / 60U;
    datetime->second = sec_of_day % 60U;

    datetime->year = 1970;
    while (1) {
        uint16_t ydays = IsLeapYear(datetime->year) ? 366 : 365;
        if (days < ydays) break;
        days -= ydays;
        datetime->year++;
    }

    datetime->month = 1;
    while (1) {
        uint8_t mdays = DaysInMonth(datetime->year, datetime->month);
        if (days < mdays) break;
        days -= mdays;
        datetime->month++;
    }

    datetime->day = (uint8_t)(days + 1U);
}

static uint8_t ESP8266_CopyDecryptedBody(char* response,
                                         char* body_start,
                                         uint16_t body_len,
                                         char* response_buffer,
                                         uint16_t buffer_size)
{
    uint8_t encrypted = 0;
    char saved_char;
    uint32_t plain_len;

    if (strstr(response, "X-Encrypted: AES128-CBC") != NULL) {
        encrypted = 1;
    }

    if (!encrypted) {
        if (body_len >= buffer_size) {
            body_len = buffer_size - 1;
        }
        strncpy(response_buffer, body_start, body_len);
        response_buffer[body_len] = '\0';
        return ESP8266_SUCCESS;
    }

    saved_char = body_start[body_len];
    body_start[body_len] = '\0';
    plain_len = Crypto_DecryptJSON(body_start, response_buffer, buffer_size);
    body_start[body_len] = saved_char;

    if (plain_len == 0) {
        DEBUG_ERROR("[ESP8266] Failed to decrypt encrypted HTTP response");
        return ESP8266_FAIL;
    }

    return ESP8266_SUCCESS;
}

/* --- 公共接口函数实现 --- */

uint8_t ESP8266_Setup(void)
{
    ESP8266_SendCmd("+++");
    Delay_ms(500);

    ESP8266_SendCmd("AT");
    if (!ESP8266_WaitForAck("OK", 1000)) return ESP8266_FAIL;

    ESP8266_SendCmd("AT+CWMODE=1");
    if (!ESP8266_WaitForAck("OK", 2000)) return ESP8266_FAIL;

    // 先关闭可能存在的连接（避免 "link is builded" 错误）
    ESP8266_SendCmd("AT+CIPCLOSE");
    Delay_ms(500);  // 等待连接关闭

    // 设置单连接模式
    ESP8266_SendCmd("AT+CIPMUX=0");
    ESP8266_WaitForAck("OK", 1000);

    return ESP8266_SUCCESS;
}

uint8_t ESP8266_ConnectWiFi(const char* ssid, const char* password)
{
    char cmd_buffer[128];

    sprintf(cmd_buffer, "AT+CWJAP=\"%s\",\"%s\"", ssid, password);
    ESP8266_SendCmd(cmd_buffer);

    return ESP8266_WaitForAck("WIFI GOT IP", 15000);
}

/**
 * @brief 连接到HTTP服务器（新增）
 */
uint8_t ESP8266_ConnectHTTPServer(const char* ip, const char* port)
{
    char cmd_buffer[100];
    uint32_t start_time;

    DEBUG_PRINT("[ESP8266] Connecting to HTTP server %s:%s\r\n", ip, port);

    // 先断开之前的连接
    ESP8266_SendCmd("AT+CIPCLOSE");
    Delay_ms(500);

    // 建立TCP连接
    sprintf(cmd_buffer, "AT+CIPSTART=\"TCP\",\"%s\",%s", ip, port);
    Serial_ClearRxBuffer();
    ESP8266_SendCmd(cmd_buffer);

    // 等待连接成功
    start_time = Get_Time_ms();

    while(Get_Time_ms() - start_time < 10000) {
        char* response = Serial_GetRxBuffer();

        if (strstr(response, "CONNECT") != NULL || strstr(response, "ALREADY") != NULL) {
            DEBUG_OK("[ESP8266] HTTP server connected");
            Delay_ms(500);
            return ESP8266_SUCCESS;
        }

        if (strstr(response, "ERROR") != NULL || strstr(response, "CLOSED") != NULL) {
            DEBUG_ERROR("[ESP8266] Connection failed");
            break;
        }

        Delay_ms(100);
    }

    DEBUG_ERROR("[ESP8266] Connection timeout");
    return ESP8266_FAIL;
}

/**
 * @brief 发送加密数据（HTTP POST请求）
 */
uint8_t ESP8266_SendEncryptedData(const char* encrypted_data)
{
    char http_request[1024];
    char cmd_buffer[32];
    char response_body[192];
    uint32_t content_length = strlen(encrypted_data);
    char* response;
    uint8_t send_ok = 0;

    if (ESP8266_CheckConnection() != ESP8266_SUCCESS) {
        DEBUG_INFO("[ESP8266] HTTP connection not ready, reconnecting...");
        if (ESP8266_ConnectHTTPServer(HTTP_SERVER_IP, HTTP_SERVER_PORT) != ESP8266_SUCCESS) {
            DEBUG_ERROR("[ESP8266] Reconnect failed before POST");
            return ESP8266_FAIL;
        }
        g_server_connected = 1;
    }

    // 构建HTTP POST请求
    sprintf(http_request,
        "POST /api/v1/attendance/checkins HTTP/1.1\r\n"
        "Host: %s:%s\r\n"
        "Content-Type: application/octet-stream\r\n"
        "X-Api-Token: %s\r\n"
        "X-Encrypted: AES128-CBC\r\n"
        "X-Encrypted-Response: true\r\n"
        "Content-Length: %u\r\n"
        "Connection: close\r\n"
        "\r\n"
        "%s",
        HTTP_SERVER_IP,
        HTTP_SERVER_PORT,
        HTTP_API_TOKEN,
        content_length,
        encrypted_data
    );

    uint32_t request_len = strlen(http_request);

    DEBUG_PRINT("[ESP8266] Sending HTTP POST (%u bytes)\r\n", request_len);

    // 发送数据长度命令
    sprintf(cmd_buffer, "AT+CIPSEND=%u", request_len);
    Serial_ClearRxBuffer();
    ESP8266_SendCmd(cmd_buffer);

    // 等待 ">" 提示符
    uint32_t start_time = Get_Time_ms();

    while(Get_Time_ms() - start_time < 2000) {
        if (strstr(Serial_GetRxBuffer(), ">") != NULL) {
            DEBUG_INFO("[ESP8266] Ready to send");

            // 发送HTTP请求
            Serial_SendString(http_request);
            break;
        }
        Delay_ms(10);
    }

    if (Get_Time_ms() - start_time >= 2000 && strstr(Serial_GetRxBuffer(), ">") == NULL) {
        DEBUG_ERROR("[ESP8266] No '>' prompt");
        return ESP8266_FAIL;
    }

    start_time = Get_Time_ms();
    while(Get_Time_ms() - start_time < 8000) {
        response = Serial_GetRxBuffer();

        if (strstr(response, "SEND FAIL") != NULL || strstr(response, "ERROR") != NULL) {
            DEBUG_ERROR("[ESP8266] POST send failed");
            return ESP8266_FAIL;
        }

        if (strstr(response, "SEND OK") != NULL) {
            send_ok = 1;
        }

        if (send_ok && strstr(response, "HTTP/1.1 200") != NULL) {
            char* ipd_marker = strstr(response, "+IPD,");
            if (ipd_marker != NULL) {
                char* data_start = strchr(ipd_marker, ':');
                if (data_start != NULL) {
                    response = data_start + 1;
                }
            }

            char* body_start = strstr(response, "\r\n\r\n");
            if (body_start != NULL) {
                uint16_t body_len;
                body_start += 4;
                body_len = strlen(body_start);
                char* cl_str = strstr(response, "Content-Length:");
                if (cl_str != NULL) {
                    uint32_t post_content_length;
                    cl_str += 15;
                    while (*cl_str == ' ') cl_str++;
                    post_content_length = (uint32_t)atoi(cl_str);
                    if (post_content_length > 0 && body_len > post_content_length) {
                        body_len = (uint16_t)post_content_length;
                    }
                }

                char* closed_marker = strstr(body_start, "\r\nCLOSED");
                if (closed_marker != NULL) {
                    *closed_marker = '\0';
                    body_len = strlen(body_start);
                }
                closed_marker = strstr(body_start, "CLOSED");
                if (closed_marker != NULL) {
                    *closed_marker = '\0';
                    body_len = strlen(body_start);
                }

                if (ESP8266_CopyDecryptedBody(response, body_start, body_len,
                                              response_body, sizeof(response_body)) == ESP8266_SUCCESS
                    && strstr(response_body, "\"success\":true") != NULL) {
                    DEBUG_OK("[ESP8266] POST accepted by server");
                    return ESP8266_SUCCESS;
                }
            }
        }

        if (strstr(response, "HTTP/1.1 401") != NULL ||
            strstr(response, "HTTP/1.1 400") != NULL ||
            strstr(response, "HTTP/1.1 413") != NULL ||
            strstr(response, "HTTP/1.1 500") != NULL ||
            strstr(response, "\"success\":false") != NULL) {
            DEBUG_PRINT("[ESP8266] POST rejected: %s\r\n", response);
            return ESP8266_FAIL;
        }
        Delay_ms(10);
    }

    DEBUG_PRINT("[ESP8266] POST response timeout: %s\r\n", Serial_GetRxBuffer());
    return ESP8266_FAIL;
}

uint8_t ESP8266_GetNetworkTime(ESP8266_DateTime* datetime)
{
    char response_buffer[256];
    char* epoch_ptr;
    uint32_t epoch_seconds = 0;
    uint8_t digit_count = 0;

    DEBUG_INFO("[ESP8266] Getting network time...");

    // 优先直接请求业务服务器时间接口
    // 期望响应: {"epoch":1700000000,"server_time":"2026-02-12 12:34:56"}
    if (ESP8266_HttpGet("/api/v1/system/time", response_buffer, sizeof(response_buffer)) != ESP8266_SUCCESS) {
        DEBUG_ERROR("[ESP8266] /api/v1/system/time request failed, try reconnect...");
        if (ESP8266_ConnectHTTPServer(HTTP_SERVER_IP, HTTP_SERVER_PORT) != ESP8266_SUCCESS) {
            DEBUG_ERROR("[ESP8266] Reconnect failed when getting time");
            return ESP8266_FAIL;
        }
        g_server_connected = 1;
        if (ESP8266_HttpGet("/api/v1/system/time", response_buffer, sizeof(response_buffer)) != ESP8266_SUCCESS) {
            DEBUG_ERROR("[ESP8266] /api/v1/system/time request failed after reconnect");
            return ESP8266_FAIL;
        }
    }

    epoch_ptr = strstr(response_buffer, "\"epoch\":");
    if (epoch_ptr == NULL) {
        DEBUG_ERROR("[ESP8266] /api/v1/system/time response missing epoch");
        DEBUG_PRINT("[ESP8266] Response: %s\r\n", response_buffer);
        return ESP8266_FAIL;
    }

    epoch_ptr += 8; // 跳过 "epoch":
    while (*epoch_ptr == ' ' || *epoch_ptr == '\"') epoch_ptr++;
    while (*epoch_ptr >= '0' && *epoch_ptr <= '9' && digit_count < 10) {
        epoch_seconds = epoch_seconds * 10U + (uint32_t)(*epoch_ptr - '0');
        epoch_ptr++;
        digit_count++;
    }
    if (digit_count < 9) {
        DEBUG_ERROR("[ESP8266] Invalid epoch value in /api/v1/system/time response");
        DEBUG_PRINT("[ESP8266] Response: %s\r\n", response_buffer);
        return ESP8266_FAIL;
    }

    EpochToDateTimeUTC8(epoch_seconds, datetime);
    DEBUG_PRINT("[ESP8266] Time(from server): %04d-%02d-%02d %02d:%02d:%02d\r\n",
               datetime->year, datetime->month, datetime->day,
               datetime->hour, datetime->minute, datetime->second);

    return ESP8266_SUCCESS;
}

uint8_t ESP8266_CheckConnection(void)
{
    char* response;

    Serial_ClearRxBuffer();
    ESP8266_SendCmd("AT+CIPSTATUS");
    Delay_ms(500);

    response = Serial_GetRxBuffer();

    if (strstr(response, "STATUS:3") != NULL) {
        DEBUG_INFO("[ESP8266] Connection OK (STATUS:3)");
        return ESP8266_SUCCESS;
    }

    if (strstr(response, "STATUS:4") != NULL) {
        DEBUG_ERROR("[ESP8266] Connection closed (STATUS:4)");
        return ESP8266_FAIL;
    }

    if (strstr(response, "STATUS:5") != NULL) {
        DEBUG_ERROR("[ESP8266] WiFi disconnected (STATUS:5)");
        return ESP8266_FAIL;
    }

    if (strstr(response, "STATUS:2") != NULL) {
        DEBUG_ERROR("[ESP8266] Not connected to server (STATUS:2)");
        return ESP8266_FAIL;
    }

    DEBUG_ERROR("[ESP8266] Unknown connection status");
    return ESP8266_FAIL;
}

/**
 * @brief 发送HTTP GET请求并接收响应
 */
uint8_t ESP8266_HttpGet(const char* path, char* response_buffer, uint16_t buffer_size)
{
    char http_request[320];
    char cmd_buffer[32];
    uint8_t request_sent = 0;

    DEBUG_PRINT("[ESP8266] HTTP GET: %s\r\n", path);

    if (response_buffer != NULL && buffer_size > 0) {
        response_buffer[0] = '\0';
    }

    if (ESP8266_CheckConnection() != ESP8266_SUCCESS) {
        DEBUG_INFO("[ESP8266] HTTP connection not ready, reconnecting...");
        if (ESP8266_ConnectHTTPServer(HTTP_SERVER_IP, HTTP_SERVER_PORT) != ESP8266_SUCCESS) {
            DEBUG_ERROR("[ESP8266] Reconnect failed before GET");
            return ESP8266_FAIL;
        }
        g_server_connected = 1;
    }

    // 构建HTTP GET请求
    sprintf(http_request,
        "GET %s HTTP/1.1\r\n"
        "Host: %s:%s\r\n"
        "X-Api-Token: %s\r\n"
        "X-Encrypted-Response: true\r\n"
        "Connection: close\r\n"
        "\r\n",
        path,
        HTTP_SERVER_IP,
        HTTP_SERVER_PORT,
        HTTP_API_TOKEN
    );

    uint32_t request_len = strlen(http_request);

    // 发送数据长度命令
    sprintf(cmd_buffer, "AT+CIPSEND=%u", request_len);
    Serial_ClearRxBuffer();
    ESP8266_SendCmd(cmd_buffer);

    // 等待 ">" 提示符
    uint32_t start_time = Get_Time_ms();

    while(Get_Time_ms() - start_time < 2000) {
        if (strstr(Serial_GetRxBuffer(), ">") != NULL) {
            DEBUG_INFO("[ESP8266] Ready to send GET request");

            // 发送HTTP GET请求
            Serial_SendString(http_request);
            request_sent = 1;
            break;
        }
        Delay_ms(10);
    }

    if (!request_sent) {
        DEBUG_ERROR("[ESP8266] No '>' prompt for GET request");
        return ESP8266_FAIL;
    }

    // 等待接收完整响应（最多8秒）
    start_time = Get_Time_ms();
    uint8_t found_header = 0;
    uint32_t content_length = 0;

    while(Get_Time_ms() - start_time < 8000) {
        char* response = Serial_GetRxBuffer();

        // 1. 处理+IPD前缀（ESP8266格式：+IPD,长度:数据）
        char* ipd_marker = strstr(response, "+IPD,");
        if (ipd_marker != NULL) {
            // 跳过 "+IPD," 找到实际数据
            char* data_start = strchr(ipd_marker, ':');
            if (data_start != NULL) {
                data_start++; // 跳过 ':'
                response = data_start; // 从这里开始才是HTTP响应
            }
        }

        // 2. 查找HTTP响应体（JSON数据在\r\n\r\n之后）
        char* body_start = strstr(response, "\r\n\r\n");
        if (body_start != NULL) {
            body_start += 4; // 跳过 \r\n\r\n

            // 3. 如果还没提取Content-Length，尝试提取
            if (!found_header) {
                char* cl_str = strstr(response, "Content-Length:");
                if (cl_str != NULL) {
                    cl_str += 15; // 跳过 "Content-Length:"
                    while (*cl_str == ' ') cl_str++;
                    content_length = atoi(cl_str);
                    DEBUG_PRINT("[ESP8266] Content-Length: %u\r\n", content_length);
                    found_header = 1;
                }
            }

            // 4. 检查是否接收完整（比较实际长度和Content-Length）
            uint16_t body_len = strlen(body_start);

            // 移除末尾的 "CLOSED" "OK" 等ESP8266附加信息
            char* closed_marker = strstr(body_start, "\r\nCLOSED");
            if (closed_marker != NULL) {
                *closed_marker = '\0';
                body_len = strlen(body_start);
            }
            // 同时处理没有\r\n的情况
            closed_marker = strstr(body_start, "CLOSED");
            if (closed_marker != NULL) {
                *closed_marker = '\0';
                body_len = strlen(body_start);
            }
            // 移除末尾的OK
            char* ok_marker = strstr(body_start, "\r\nOK");
            if (ok_marker != NULL) {
                *ok_marker = '\0';
                body_len = strlen(body_start);
            }

            // 5. 如果服务端给了Content-Length，必须收完整；否则才使用超时兜底
            if ((found_header && body_len >= content_length) ||
                (!found_header && Get_Time_ms() - start_time > 3000 && body_len > 0)) {
                if (found_header && body_len > content_length) {
                    body_len = (uint16_t)content_length;
                }
                if (ESP8266_CopyDecryptedBody(response, body_start, body_len, response_buffer, buffer_size) != ESP8266_SUCCESS) {
                    return ESP8266_FAIL;
                }

                DEBUG_PRINT("[ESP8266] Received response (%d bytes)\r\n", strlen(response_buffer));
                DEBUG_PRINT("[ESP8266] Response: %s\r\n", response_buffer);
                return ESP8266_SUCCESS;
            }
        }

        Delay_ms(100);
    }

    DEBUG_ERROR("[ESP8266] No valid HTTP response or timeout");
    return ESP8266_FAIL;
}

/**
 * @brief 查询学生在指定时段是否已签到（服务器端查重）
 * @param student_id 学号
 * @param slot_start 时段开始时间（格式"HH:MM"）
 * @param slot_end 时段结束时间（格式"HH:MM"）
 * @retval 1 表示已签到（重复）, 0 表示未签到
 */
uint8_t ESP8266_CheckDuplicate(const char* student_id, const char* slot_start, const char* slot_end)
{
    char path[128];
    char response_buffer[256];

    // 构建查询路径
    sprintf(path, "/api/v1/attendance/duplicates?student_id=%s&slot_start=%s&slot_end=%s",
            student_id, slot_start, slot_end);

    DEBUG_PRINT("[ESP8266] Checking duplicate: %s\r\n", path);

    // 先检查连接状态，如果断开则重连
    if (ESP8266_CheckConnection() != ESP8266_SUCCESS) {
        DEBUG_INFO("[ESP8266] Connection lost, reconnecting...");
        extern const char* HTTP_SERVER_IP;
        extern const char* HTTP_SERVER_PORT;
        if (ESP8266_ConnectHTTPServer(HTTP_SERVER_IP, HTTP_SERVER_PORT) != ESP8266_SUCCESS) {
            DEBUG_ERROR("[ESP8266] Reconnect failed");
            return 0;  // 连接失败，默认允许签到
        }
        Delay_ms(200);  // 等待连接稳定
    }

    // 发送HTTP GET请求
    if (ESP8266_HttpGet(path, response_buffer, sizeof(response_buffer)) == ESP8266_SUCCESS) {
        // 解析响应，查找 "duplicate":true
        if (strstr(response_buffer, "\"duplicate\":true") != NULL) {
            DEBUG_INFO("[ESP8266] Duplicate found on server!");
            return 1;  // 已签到
        } else {
            DEBUG_INFO("[ESP8266] No duplicate found");
            return 0;  // 未签到
        }
    }

    DEBUG_ERROR("[ESP8266] Failed to check duplicate, assuming not duplicate");
    return 0;  // 查询失败时默认为未签到，允许本地签到
}

/**
 * @brief 下载今日已签到学生列表（开机时调用）
 * @param slot_start 时段开始时间（格式"HH:MM"）
 * @param slot_end 时段结束时间（格式"HH:MM"）
 * @param student_ids 输出：学号数组（逗号分隔的字符串）
 * @param buffer_size 缓冲区大小
 * @retval 成功下载的学号数量
 */
uint8_t ESP8266_DownloadTodayRecords(const char* slot_start, const char* slot_end, char* student_ids, uint16_t buffer_size)
{
    char path[128];
    char response_buffer[512];

    // 构建查询路径
    sprintf(path, "/api/v1/attendance/today?slot_start=%s&slot_end=%s", slot_start, slot_end);

    DEBUG_PRINT("[ESP8266] Downloading today's records: %s\r\n", path);

    // 先检查连接状态，如果断开则重连
    if (ESP8266_CheckConnection() != ESP8266_SUCCESS) {
        DEBUG_INFO("[ESP8266] Connection lost, reconnecting before download...");
        extern const char* HTTP_SERVER_IP;
        extern const char* HTTP_SERVER_PORT;
        if (ESP8266_ConnectHTTPServer(HTTP_SERVER_IP, HTTP_SERVER_PORT) != ESP8266_SUCCESS) {
            DEBUG_ERROR("[ESP8266] Reconnect failed");
            return 0;
        }
        Delay_ms(300);  // 等待连接稳定
    }

    // 发送HTTP GET请求
    if (ESP8266_HttpGet(path, response_buffer, sizeof(response_buffer)) != ESP8266_SUCCESS) {
        DEBUG_ERROR("[ESP8266] Failed to download today's records");
        return 0;
    }

    // 解析响应，提取学号列表
    // 格式: {"date":"2026-02-07","records":["1","2","3"]}
    char* records_start = strstr(response_buffer, "\"records\":[");
    if (records_start == NULL) {
        DEBUG_ERROR("[ESP8266] Invalid response format");
        return 0;
    }

    records_start += 11;  // 跳过 "records":[
    char* records_end = strchr(records_start, ']');
    if (records_end == NULL) {
        DEBUG_ERROR("[ESP8266] Invalid response format");
        return 0;
    }

    // 复制学号列表到输出缓冲区
    uint16_t len = records_end - records_start;
    if (len >= buffer_size) len = buffer_size - 1;

    strncpy(student_ids, records_start, len);
    student_ids[len] = '\0';

    // 统计学号数量（空列表返回0）
    uint8_t count = 0;
    if (len > 2) {  // 至少有一个学号 "x"
        count = 1;
        for (uint16_t i = 0; i < len; i++) {
            if (student_ids[i] == ',') count++;
        }
    }

    DEBUG_PRINT("[ESP8266] Downloaded %d records: %s\r\n", count, student_ids);
    return count;
}