#include "httpserver.h"
#include "index.h"
#include "dashboard.h"
#include "../PowerManger.h"
#include "mongoose.h"
#include <iostream>
#include "json/json.h"
#include <sys/resource.h>
#include "data.h"
#include "logpage.h"

using json = Json::Value;

// WebSocket事件处理函数
void HttpServer::handleWebSocketEvent(struct mg_connection* c, int ev, void* ev_data, void* fn_data) {
    HttpServer* server = static_cast<HttpServer*>(fn_data);
    
    if (ev == MG_EV_WS_OPEN) {
        // WebSocket连接成功建立
        std::lock_guard<std::mutex> lock(server->ws_connections_mutex_);
        server->ws_connections_.push_back(c);
        LOG_F(INFO, "WebSocket connection established: id=%lu fd=%d", c->id, c->fd);
    } else if (ev == MG_EV_CLOSE || ev == MG_EV_ERROR) {
        // 连接关闭或错误
        std::lock_guard<std::mutex> lock(server->ws_connections_mutex_);
        auto it = std::find(server->ws_connections_.begin(), server->ws_connections_.end(), c);
        if (it != server->ws_connections_.end()) {
            if (ev == MG_EV_ERROR) {
                struct mg_http_message *hm = (struct mg_http_message *) ev_data;
                if (errno != 0) {
                    LOG_F(ERROR, "WebSocket error: id=%lu fd=%d, errno=%d", 
                         c->id, c->fd, errno);
                    // 打印socket错误信息
                    char buf[256];
                    strerror_r(errno, buf, sizeof(buf));
                    LOG_F(ERROR, "Socket error: %s", buf);
                } else {
                    LOG_F(ERROR, "WebSocket connection closed abnormally: id=%lu fd=%d", 
                         c->id, c->fd);
                }
            } else {
                LOG_F(INFO, "WebSocket closed: id=%lu fd=%d", c->id, c->fd);
            }
            server->ws_connections_.erase(it);
            
            // 检查系统资源限制
            static int fd_limit_checked = 0;
            if (!fd_limit_checked) {
                fd_limit_checked = 1;
                struct rlimit lim;
                if (getrlimit(RLIMIT_NOFILE, &lim) == 0) {
                    LOG_F(INFO, "File descriptor limits: soft=%lu hard=%lu",
                         lim.rlim_cur, lim.rlim_max);
                }
            }
        }
    } else if (ev == MG_EV_WS_MSG) {
        // WebSocket消息处理
        struct mg_ws_message *wm = (struct mg_ws_message *) ev_data;
        std::string msg(wm->data.buf, wm->data.len);
        handleLogRequest(c, msg);
    } else if (ev == MG_EV_HTTP_MSG) {
        // HTTP请求处理
        struct mg_http_message *hm = (struct mg_http_message *) ev_data;
        if (mg_match(hm->uri, mg_str("/ws"), NULL)) {
            // 升级到WebSocket连接
            LOG_F(INFO, "Upgrading to WebSocket: id=%lu fd=%d", c->id, c->fd);
            mg_ws_upgrade(c, hm, nullptr);
            LOG_F(INFO, "WebSocket upgrade completed: id=%lu fd=%d", c->id, c->fd);
        } else if (mg_match(hm->uri, mg_str("/dashboard"), NULL)) {
            // 返回仪表盘HTML
            mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n", DASHBOARD_HTML.c_str());
        } else if (mg_match(hm->uri, mg_str("/data"), NULL)) {
            // 返回数据页面HTML
            mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n", DATA_HTML.c_str());
        } else if (mg_match(hm->uri, mg_str("/logs"), NULL)) {
            // 返回日志页面HTML
            mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n", LOG_PAGE_HTML.c_str());
        } else if (mg_match(hm->uri, mg_str("/control"), NULL)) {
            // 处理断路器控制请求
            if (mg_strcmp(hm->method, mg_str("POST")) == 0) {
                // 解析JSON请求
                char *device_type = mg_json_get_str(hm->body, "$.device_type");
                char *device_id = mg_json_get_str(hm->body, "$.device_id"); 
                char *action = mg_json_get_str(hm->body, "$.action");

                bool success = true;
                std::string device_type_str = device_type? std::string(device_type) : "";
                std::string device_id_str = device_id ? std::string(device_id) : "";
                std::string action_str = action ? std::string(action) : "";
                if (device_type && device_id && action) {
                    //TODO: 处理断路器控制逻辑
                    LOG_F(INFO, "Received control request: device_type=%s, device_id=%s, action=%s ,from Net DashBoard id=%lu fd=%d",
                        device_type, device_id, action, c->id, c->fd);
                    char opt = (action_str == "open") ? 0 : 1;
                    if(device_type_str == "meter_bus")
                    {
                        if (device_id_str == "battery_meter")
                        {
                            success = m_lowerCommManager->operate_LV_lithiumBatteryGroupInstrumentCircuit_Breaker(opt);
                        } else if (device_id_str == "bow_low_dist")
                        {
                            success = m_lowerCommManager->operate_LV_bowLowVoltageDistributionBoxCircuit_Breaker(opt);
                        } else if (device_id_str == "unit4_dc48v"){
                            success = m_lowerCommManager->operate_LV_unit4Dc48V_Breaker(opt);
                        } else if (device_id_str == "dc_c1"){
                            success = m_lowerCommManager->operate_LV_dcC1Panel_Breaker(opt);
                        } else if(device_id_str == "reserve1"){
                            success = m_lowerCommManager->operate_LV_reservedCircuit1_Breaker(opt);
                        } else if(device_id_str == "reserve2"){
                            success = m_lowerCommManager->operate_LV_reservedCircuit2_Breaker(opt);
                        } else if(device_id_str == "emergency_battery2"){
                            success = m_lowerCommManager->operate_LV_mergencyLithiumBatteryGroup2Circuit_Breaker(opt);
                        }
                    }
                    else if (device_type_str == "bow_high_vol")
                    { 
                        if (device_id_str == "bow_ft1_3") {
                            success = m_lowerCommManager->operate_HVA_bowFTDevice123Circuit_Breaker(opt);
                        } else if (device_id_str == "opening_mechanism") {
                            success = m_lowerCommManager->operate_HVA_actuatorCircuit_Breaker(opt);
                        } else if (device_id_str == "mast_steering") {
                            success = m_lowerCommManager->operate_HVA_mastSteeringGearControlBoxCircuit_Breaker(opt);
                        } else if (device_id_str == "xcz") {
                            success = m_lowerCommManager->operate_HVA_xczCircuit_Breaker(opt);
                        } else if (device_id_str == "bow_rudder") {
                            success = m_lowerCommManager->operate_HVA_bowRudderControlBoxCircuit_Breaker(opt);
                        } else if (device_id_str == "water_cover") {
                            success = m_lowerCommManager->operate_HVA_openWaterCoverStartCylinderCircuit_Breaker(opt);
                        }
                    } else if (device_type_str == "high_vol_bus")
                    {
                        if (device_id_str == "fuel_cell") {
                            success = m_lowerCommManager->operate_HV_fuelCellCircuit_Breaker(opt);
                        } else if (device_id_str == "power_battery") {
                            success = m_lowerCommManager->operate_HV_powerLithiumBattery_Breaker(opt);
                        } else if (device_id_str == "propulsion_motor") {
                            success = m_lowerCommManager->operate_HV_propulsionMotor_Breaker(opt);
                        } else if (device_id_str == "battery_meter") {
                            success = m_lowerCommManager->operate_HV_lithiumBatteryMeter_Breaker(opt);
                        } else if (device_id_str == "dcdc5") {
                            success = m_lowerCommManager->operate_HV_dcDc5Module_Breaker(opt);
                        } else if (device_id_str == "bow_distribution") {
                            success = m_lowerCommManager->operate_HV_bowHighVoltageBox_Breaker(opt);
                        } else if (device_id_str == "stern_ft45") {
                            success = m_lowerCommManager->operate_HV_sternFt45_Breaker(opt);
                        } else if (device_id_str == "stern_rudder1") {
                            success = m_lowerCommManager->operate_HV_sternRudder1_Breaker(opt);
                        } else if (device_id_str == "stern_rudder2") {
                            success = m_lowerCommManager->operate_HV_sternRudder2_Breaker(opt);
                        } else if (device_id_str == "fb_reserve") {
                            success = m_lowerCommManager->operate_HV_fbReserved_Breaker(opt);
                        } else if (device_id_str == "tyz_reserve") {
                            success = m_lowerCommManager->operate_HV_tyzReserved_Breaker(opt);
                        } else if (device_id_str == "reserve") {
                            success = m_lowerCommManager->operate_HV_reserved_Breaker(opt);
                        } else if (device_id_str == "dcdc5_start") {
                            success = m_lowerCommManager->operate_HV_dcDc5_Breaker(opt);
                        } else if (device_id_str == "cooling_system") {
                            success = m_lowerCommManager->operate_HV_coolingSystem_Breaker(opt);
                        }
                    } else if (device_type_str == "bow_low_vol")
                    {
                        if (device_id_str == "unit1") {
                            success = m_lowerCommManager->operate_LVA_unit1Circuit_Breaker(opt);
                        } else if (device_id_str == "unit2") {
                            success = m_lowerCommManager->operate_LVA_unit2Circuit_Breaker(opt);
                        } else if (device_id_str == "unit3") {
                            success = m_lowerCommManager->operate_LVA_unit3Circuit_Breaker(opt);
                        } else if (device_id_str == "unit5") {
                            success = m_lowerCommManager->operate_LVA_unit5Circuit_Breaker(opt);
                        } else if (device_id_str == "bow_pz") {
                            success = m_lowerCommManager->operate_LVA_bowPZDeviceCircuit_Breaker(opt);
                        } else if (device_id_str == "reserve1") {
                            success = m_lowerCommManager->operate_LVA_reservedCircuit1_Breaker(opt);
                        } else if (device_id_str == "reserve2") {
                            success = m_lowerCommManager->operate_LVA_reservedCircuit2_Breaker(opt);
                        } else if (device_id_str == "emergency_battery1") {
                            success = m_lowerCommManager->operate_LVA_mergencyLithiumBatteryGroup1Circuit_Breaker(opt);
                        }
                    }
                    const char *message = success ? "操作成功" : "操作失败";
                    // 返回JSON响应
                    mg_http_reply(c, 200, "Content-Type: application/json\r\n",
                                 "{\"success\": %s, \"message\": \"%s\"}",
                                 success ? "true" : "false", message);
                } else {
                    mg_http_reply(c, 400, "Content-Type: text/plain\r\n", "Invalid request");
                }
                // 释放分配的内存
                if (device_type) free(device_type);
                if (device_id) free(device_id);
                if (action) free(action);
            } else {
                mg_http_reply(c, 405, "Content-Type: text/plain\r\n", "Method Not Allowed");
            }
        } else {
            // 返回主页HTML
            mg_http_reply(c, 200, "Content-Type: text/html; charset=utf-8\r\n", INDEX_HTML.c_str());
        }
    }
}

HttpServer::HttpServer(int port) : port_(port), running_(false) {
    mg_mgr_init(&mgr_);
}

HttpServer::~HttpServer() {
    stop();
    mg_mgr_free(&mgr_);
}

bool HttpServer::serverThreadCB(void* pParam) {
    HttpServer* pThis = static_cast<HttpServer*>(pParam);
    return pThis->serverThreadFunc();
}

bool HttpServer::serverThreadFunc() {
    while(running_) {
        mg_mgr_poll(&mgr_, 1000);
        
        // 定期推送系统数据
        static uint64_t last_push_time = 0;
        static uint64_t last_log_check_time = 0;
        uint64_t now = mg_millis();
        
        if (now - last_push_time > 1000) { // 每秒推送一次
            last_push_time = now;
            pushSystemData();
        }
        
        if (now - last_log_check_time > 500) { // 每500ms检查一次日志
            last_log_check_time = now;
            monitorLogFile();
        }
    }
    return true;
}

void HttpServer::pushSystemData() {
    if (!m_systemData) return;
    // 序列化系统数据为JSON
    json j;
    //燃料电池系统参数
    j["fc_mode"] = Json::Value(m_systemData->fc_mode); // 燃料电池系统运行模式：00H-无效, 01H-调试, 02H-自动, 03H-补给
    j["fc_status"] = Json::Value(m_systemData->fc_status); // 燃料电池状态：00H-无效, 01H-初始化, ..., 0DH-维护完成
    j["fc_fault_level"] = Json::Value(m_systemData->fc_fault_level);

    //功率和时间参数
    j["output_power_limit"] = Json::Value(m_systemData->output_power_limit); // 系统输出功率限制值，单位：W
    j["total_generation_time"] = Json::Value(m_systemData->total_generation_time); // 系统累计发电时间，单位：0.1小时
    j["total_generation_power"] = Json::Value(m_systemData->total_generation_power); // 系统累计发电功率，单位：W

    //燃料电池故障信息
    j["fc_fault_level_1"] = Json::Value(m_systemData->fc_fault_level_1);
    j["fc_fault_level_2"] = Json::Value(m_systemData->fc_fault_level_2);
    j["fc_fault_level_3"] = Json::Value(m_systemData->fc_fault_level_3);
    j["fc_fault_level_4"] = Json::Value(m_systemData->fc_fault_level_4);

    //燃料容量
    j["hydrogen_capacity"] = Json::Value(m_systemData->hydrogen_capacity);  // 储氢罐剩余容量百分比，单位：%
    j["liquid_oxygen_capacity"] = Json::Value(m_systemData->liquid_oxygen_capacity); // 液氧罐剩余容量百分比，单位：%

    //温度压力参数
    j["palladium_temp"] = Json::Value(m_systemData->palladium_temp); // 钯膜最高温度，单位：℃
    j["main_pipe_pressure"] = Json::Value(m_systemData->main_pipe_pressure); // 主水路压力，单位：0.01kPa
    j["aux_pipe_pressure"] = Json::Value(m_systemData->aux_pipe_pressure); // 辅水路压力，单位：0.01kPa

    //舱室环境参数
    j["cabin_pressure1"] = Json::Value(m_systemData->cabin_pressure1); // 舱室1压力，单位：0.01kPa
    j["cabin_pressure2"] = Json::Value(m_systemData->cabin_pressure2); // 舱室2压力，单位：0.01kPa
    j["cabin_temp1"] = Json::Value(m_systemData->cabin_temp1); // 舱室1温度，单位：0.01℃
    j["cabin_temp2"] = Json::Value(m_systemData->cabin_temp2); // 舱室2温度，单位：0.01℃
    j["cabin_humidity1"] = Json::Value(m_systemData->cabin_humidity1); // 舱室1湿度，单位：0.01%RH
    j["cabin_humidity2"] = Json::Value(m_systemData->cabin_humidity2); // 舱室2湿度，单位：0.01%RH

    //火焰探测器
    j["flame_detector1"] = Json::Value(m_systemData->flame_detector1); // 火焰探测器1状态：00H-无效, 01H-报警, 02H-故障
    j["flame_detector2"] = Json::Value(m_systemData->flame_detector2); // 火焰探测器2状态：00H-无效, 01H-报警, 02H-故障

    //气体浓度
    j["h2_concentration1"] = Json::Value(m_systemData->h2_concentration1); // 舱室H2浓度1，单位：0.01% LEL
    j["h2_concentration2"] = Json::Value(m_systemData->h2_concentration2); // 舱室H2浓度2，单位：0.01% LEL
    j["h2_concentration3"] = Json::Value(m_systemData->h2_concentration3); // 舱室H2浓度3，单位：0.01% LEL
    j["o2_concentration1"] = Json::Value(m_systemData->o2_concentration1); // 舱室O2浓度1，单位：0.01% LEL
    j["o2_concentration2"] = Json::Value(m_systemData->o2_concentration2); // 舱室O2浓度2，单位：0.01% LEL
    j["ch3oh_concentration1"] = Json::Value(m_systemData->ch3oh_concentration1); // 舱室甲醇气体浓度1，单位：0.01% LEL
    j["ch3oh_concentration2"] = Json::Value(m_systemData->ch3oh_concentration2); // 舱室甲醇气体浓度2，单位：0.01% LEL

    //保留字段  
    j["cabin_ox_concentration"] = Json::Value(m_systemData->cabin_ox_concentration); // 仪表舱内氧气浓度，单位：0.1%
    j["cabin_temperature"] = Json::Value(m_systemData->cabin_temperature); // 仪表舱内温度，单位：0.1℃
    j["cabin_humidity"] = Json::Value(m_systemData->cabin_humidity); // 仪表舱内湿度，单位：0.1%RH
    j["cabin_pressure"] = Json::Value(m_systemData->cabin_pressure); // 仪表舱内大气压，单位：0.2kPa

    //动力舱参数      
    j["power_cabin_ox_concentration"] = Json::Value(m_systemData->power_cabin_ox_concentration); // 动力舱内氧气浓度，单位：0.1%
    j["power_cabin_temperature"] = Json::Value(m_systemData->power_cabin_temperature); // 动力舱内温度，单位：0.1℃
    j["power_cabin_humidity"] = Json::Value(m_systemData->power_cabin_humidity); // 动力舱内湿度，单位：0.1%RH
    j["power_cabin_pressure"] = Json::Value(m_systemData->power_cabin_pressure); // 动力舱内大气压，单位：0.2kPa

    //电池报警标志
    // uint8_t dyn_alarm_flag[6];               // 动力锂电池报警标志
    // uint8_t ins_alarm_flag[6];               // 仪表锂电池报警标志
    j["dyn_alarm_flag1"] = Json::Value(m_systemData->dyn_alarm_flag[0]);
    j["dyn_alarm_flag2"] = Json::Value(m_systemData->dyn_alarm_flag[1]);
    j["dyn_alarm_flag3"] = Json::Value(m_systemData->dyn_alarm_flag[2]);
    j["dyn_alarm_flag4"] = Json::Value(m_systemData->dyn_alarm_flag[3]);
    j["dyn_alarm_flag5"] = Json::Value(m_systemData->dyn_alarm_flag[4]);
    j["dyn_alarm_flag6"] = Json::Value(m_systemData->dyn_alarm_flag[5]);

    j["ins_alarm_flag1"] = Json::Value(m_systemData->ins_alarm_flag[0]);
    j["ins_alarm_flag2"] = Json::Value(m_systemData->ins_alarm_flag[1]);
    j["ins_alarm_flag3"] = Json::Value(m_systemData->ins_alarm_flag[2]);
    j["ins_alarm_flag4"] = Json::Value(m_systemData->ins_alarm_flag[3]);
    j["ins_alarm_flag5"] = Json::Value(m_systemData->ins_alarm_flag[4]);
    j["ins_alarm_flag6"] = Json::Value(m_systemData->ins_alarm_flag[5]);

    //继电器状态 
    j["ins_relay_status1"] = Json::Value(m_systemData->ins_relay_status1); // 仪表电池继电器状态
    j["ins_relay_status2"] = Json::Value(m_systemData->ins_relay_status2); // 仪表电池预充继电器和负极继电器状态
    j["dyn_relay_status1"] = Json::Value(m_systemData->dyn_relay_status1); // 动力电池正极与充电继电器状态
    j["dyn_relay_status2"] = Json::Value(m_systemData->dyn_relay_status2); // 动力电池预充与负极继电器状态

    //电池功率参数
    j["ins_max_discharge_power"] = Json::Value(m_systemData->ins_max_discharge_power); // 仪表电池最大允许放电功率，单位：0.05kW
    j["dyn_max_discharge_power"] = Json::Value(m_systemData->dyn_max_discharge_power); // 动力电池最大允许放电功率，单位：0.05kW

    //电池SOC
    j["ins_soc"] = Json::Value(m_systemData->ins_soc); // 仪表电池SOC，单位：0.1%
    j["dyn_soc"] = Json::Value(m_systemData->dyn_soc); // 动力电池SOC，单位：0.1%

    //电池能量
    j["ins_total_energy"] = Json::Value(m_systemData->ins_total_energy); // 仪表电池能量，单位：0.01kWh
    j["dyn_total_energy"] = Json::Value(m_systemData->dyn_total_energy); // 动力电池能量，单位：0.01kWh

    //电池输入功率
    j["ins_power_input"] = Json::Value(m_systemData->ins_power_input);
    j["dyn_power_input"] = Json::Value(m_systemData->dyn_power_input);
    
    //电池电压电流           
    j["ins_voltage_link"] = Json::Value(m_systemData->ins_voltage_link); // 仪表电池LINK端电压，单位：0.01V
    j["ins_voltage_pack"] = Json::Value(m_systemData->ins_voltage_pack); // 仪表电池PACK端电压，单位：0.01V
    j["ins_current"] = Json::Value(m_systemData->ins_current); // 仪表电池电流，单位：0.01A
    j["ins_resistance_pos"] = Json::Value(m_systemData->ins_resistance_pos); // 仪表电池正极绝缘电阻，单位：kΩ
    j["ins_resistance_neg"] = Json::Value(m_systemData->ins_resistance_neg); // 仪表电池负极绝缘电阻，单位：kΩ
    j["dyn_voltage_link"] = Json::Value(m_systemData->dyn_voltage_link); // 动力电池LINK端电压，单位：0.01V
    j["dyn_voltage_pack"] = Json::Value(m_systemData->dyn_voltage_pack); // 动力电池PACK端电压，单位：0.01V
    j["dyn_current"] = Json::Value(m_systemData->dyn_current); // 动力电池电流，单位：0.05A
    j["dyn_resistance_pos"] = Json::Value(m_systemData->dyn_resistance_pos); // 动力电池正极绝缘电阻，单位：kΩ
    j["dyn_resistance_neg"] = Json::Value(m_systemData->dyn_resistance_neg); // 动力电池负极绝缘电阻，单位：kΩ


    //紧急状态
    j["ins_emergency_status"] = Json::Value(m_systemData->ins_emergency_status); // 紧急状态：00H-无紧急, 01H-紧急
    j["dyn_emergency_status"] = Json::Value(m_systemData->dyn_emergency_status); // 紧急状态：00H-无紧急, 01H-紧急
           
    j["ins_soc_threshold1"] = Json::Value(m_systemData->ins_soc_threshold1); // 仪表电池1 SOC门限
    j["ins_soc_threshold2"] = Json::Value(m_systemData->ins_soc_threshold2); // 仪表电池2 SOC门限
    j["ins_soc_threshold3"] = Json::Value(m_systemData->ins_soc_threshold3); // 仪表电池3 SOC门限
    j["dyn_soc_threshold1"] = Json::Value(m_systemData->dyn_soc_threshold1); // 动力电池1 SOC门限
    j["dyn_soc_threshold2"] = Json::Value(m_systemData->dyn_soc_threshold2); // 动力电池2 SOC门限
    j["dyn_soc_threshold3"] = Json::Value(m_systemData->dyn_soc_threshold3); // 动力电池3 SOC门限
    j["ins_power_limit1"] = Json::Value(m_systemData->ins_power_limit1); // 仪表电池1功率限制值
    j["ins_power_limit2"] = Json::Value(m_systemData->ins_power_limit2); // 仪表电池2功率限制值
    j["dyn_power_limit1"] = Json::Value(m_systemData->dyn_power_limit1); // 动力电池1功率限制值
    j["dyn_power_limit2"] = Json::Value(m_systemData->dyn_power_limit2); // 动力电池2功率限制值

    //设备在线状态
    j["device_online"]["device_online_flag1"] = Json::Value(m_systemData->device_online_flag1);
    j["device_online"]["device_online_flag2"] = Json::Value(m_systemData->device_online_flag2);

    j["device_online_status"]["ins_online_state"] = Json::Value(m_systemData->device_online_status.ins_online_state);  // 仪表锂电在线标志位
    j["device_online_status"]["dyn_online_state"] = Json::Value(m_systemData->device_online_status.dyn_online_state);  // 动力锂电在线标志位
    j["device_online_status"]["fuel_online_state"] = Json::Value(m_systemData->device_online_status.fuel_online_state);  // 燃电锂电在线标志位
    j["device_online_status"]["high_voltage_online_state"] = Json::Value(m_systemData->device_online_status.high_voltage_online_state);  // 高压配电板在线标志位
    j["device_online_status"]["low_voltage_online_state"] = Json::Value(m_systemData->device_online_status.low_voltage_online_state);  // 低压配电板在线标志位
    j["device_online_status"]["composite_online_state"] = Json::Value(m_systemData->device_online_status.composite_online_state);  // 复合管控主机在线标志位
    j["device_online_status"]["composite_backup_online_state"] = Json::Value(m_systemData->device_online_status.composite_backup_online_state);  // 复合管控备机在线标志位
    // cout << j << endl;
    //通信状态
    //ccu状态
    j["comm_state"]["ccu_status"]["isTimeout"] = Json::Value(m_systemData->device_common_status.ccu_status.isTimeout);
    j["comm_state"]["ccu_status"]["lastUpdateTime"] = Json::Value(m_systemData->device_common_status.ccu_status.lastUpdateTime);
    
    //高压配电状态
    j["comm_state"]["dis_hv_c1"]["isTimeout"] = Json::Value(m_systemData->device_common_status.dis_hv_c1.isTimeout);
    j["comm_state"]["dis_hv_c1"]["lastUpdateTime"] = Json::Value(m_systemData->device_common_status.dis_hv_c1.lastUpdateTime);
    j["comm_state"]["dis_hv_c2"]["isTimeout"] = Json::Value(m_systemData->device_common_status.dis_hv_c2.isTimeout);
    j["comm_state"]["dis_hv_c2"]["lastUpdateTime"] = Json::Value(m_systemData->device_common_status.dis_hv_c2.lastUpdateTime);
    
    //低压配电状态
    j["comm_state"]["dis_lv_c1"]["isTimeout"] = Json::Value(m_systemData->device_common_status.dis_lv_c1.isTimeout);
    j["comm_state"]["dis_lv_c1"]["lastUpdateTime"] = Json::Value(m_systemData->device_common_status.dis_lv_c1.lastUpdateTime);
    j["comm_state"]["dis_lv_c2"]["isTimeout"] = Json::Value(m_systemData->device_common_status.dis_lv_c2.isTimeout);
    j["comm_state"]["dis_lv_c2"]["lastUpdateTime"] = Json::Value(m_systemData->device_common_status.dis_lv_c2.lastUpdateTime);

    //复合管控器心跳计算器
    j["heartbeat"] = Json::Value(m_systemData->heartbeat);
    //=============================================================================================================
    //配电器状态
    //动力母线状态
    j["power_bus_status"]["fuelCellCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.fuelCellCircuitBreaker); // 燃料电池断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["powerLithiumBatteryCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.powerLithiumBatteryCircuitBreaker); // 动力锂电池断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["propulsionMotorCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.propulsionMotorCircuitBreaker); // 推进电机断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["lithiumBatteryGroupInstrumentCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.lithiumBatteryGroupInstrumentCircuitBreaker); // 锂电池组仪表断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["dcDc5ModuleCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.dcDc5ModuleCircuitBreaker); // DC/DC5模块断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["bowHighVoltageDistributionBoxCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.bowHighVoltageDistributionBoxCircuitBreaker); // 艏部高压配电箱断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["sternFTDevice45CircuitBreaker"] = Json::Value(m_systemData->power_bus_status.sternFTDevice45CircuitBreaker); // 艉部FT装置4/5断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["sternRudderSwitch1CircuitBreaker"] = Json::Value(m_systemData->power_bus_status.sternRudderSwitch1CircuitBreaker); // 艉舵开关1断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["sternRudderSwitch2CircuitBreaker"] = Json::Value(m_systemData->power_bus_status.sternRudderSwitch2CircuitBreaker); // 艉舵开关2断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["fbReservedCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.fbReservedCircuitBreaker); // FB预留断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["tyzReservedCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.tyzReservedCircuitBreaker); // TYZ预留断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["reservedCircuitBreaker"] = Json::Value(m_systemData->power_bus_status.reservedCircuitBreaker); // 预留断路器状态: 0-断开 1-闭合 2-故障
    j["power_bus_status"]["dcDcModuleStatus"] = Json::Value(m_systemData->power_bus_status.dcDcModuleStatus); // DC/DC5模块状态: 0-未运行 1-运行 2-过温关机 3-输出过流 4-输出过压 5-输出欠压 6-输入过压 7-输入欠压 8-输出短路 9-内部故障
    j["power_bus_status"]["coolingSystemStatus"] = Json::Value(m_systemData->power_bus_status.coolingSystemStatus); // 冷却系统状态: 0-未运行 1-运行 2-冷却泵1故障 3-冷却泵2故障 4-冷却水泄露
    j["power_bus_status"]["powerBusInsulationStatus"] = Json::Value(m_systemData->power_bus_status.powerBusInsulationStatus); // 动力母排绝缘状态: 0-正常 1-绝缘低
    j["power_bus_status"]["aBusInsulationStatus"] = Json::Value(m_systemData->power_bus_status.aBusInsulationStatus); // A汇流排绝缘状态: 0-正常 1-绝缘低
    j["power_bus_status"]["meterPowerLossSignal"] = Json::Value(m_systemData->power_bus_status.meterPowerLossSignal); // 仪表电源状态: 0-正常 1-故障
    j["power_bus_status"]["emergencyPowerLossSignal"] = Json::Value(m_systemData->power_bus_status.emergencyPowerLossSignal); // 应急电源状态: 0-正常 1-故障
    j["power_bus_status"]["dcDcTemperature"] = Json::Value(m_systemData->power_bus_status.dcDcTemperature); // DC/DC模块温度
    j["power_bus_status"]["powerBusVoltage"] = Json::Value(m_systemData->power_bus_status.powerBusVoltage); // 动力汇流排电压
    j["power_bus_status"]["dcDc5ModuleCurrent"] = Json::Value(m_systemData->power_bus_status.dcDc5ModuleCurrent); // DC/DC5模块电流
    j["power_bus_status"]["powerBusCurrent"] = Json::Value(m_systemData->power_bus_status.powerBusCurrent); // 动力汇流排电流
    j["power_bus_status"]["busbarAVoltage"] = Json::Value(m_systemData->power_bus_status.busbarAVoltage); // A汇流排电压
    j["power_bus_status"]["propulsionMotorControlBoxCurrent"] = Json::Value(m_systemData->power_bus_status.propulsionMotorControlBoxCurrent); // 推进电机控制箱电流
    j["power_bus_status"]["busbarACurrent"] = Json::Value(m_systemData->power_bus_status.busbarACurrent); // A汇流排电流
    j["power_bus_status"]["lithiumBatteryGroupMeterCurrent"] = Json::Value(m_systemData->power_bus_status.lithiumBatteryGroupMeterCurrent); // 锂电池组(仪表)电流
    j["power_bus_status"]["bowHighVoltageDistributionBoxCurrent"] = Json::Value(m_systemData->power_bus_status.bowHighVoltageDistributionBoxCurrent); // 艏部高压配电箱电流
    j["power_bus_status"]["sternFTDevice45Current"] = Json::Value(m_systemData->power_bus_status.sternFTDevice45Current); // 艉部FT装置4/5电流
    j["power_bus_status"]["tyzReservedSwitchCurrent"] = Json::Value(m_systemData->power_bus_status.tyzReservedSwitchCurrent); // TYZ预留开关电流
    j["power_bus_status"]["sternRudderSwitch1Current"] = Json::Value(m_systemData->power_bus_status.sternRudderSwitch1Current); // 艉舵开关1电流
    j["power_bus_status"]["reservedCurrent1"] = Json::Value(m_systemData->power_bus_status.reservedCurrent1); // 预留电流1
    j["power_bus_status"]["sternRudderSwitch2Current"] = Json::Value(m_systemData->power_bus_status.sternRudderSwitch2Current); // 艉舵开关2电流
    j["power_bus_status"]["reservedCurrent2"] = Json::Value(m_systemData->power_bus_status.reservedCurrent2); // 预留电流2
    j["power_bus_status"]["fbReservedSwitchCurrent"] = Json::Value(m_systemData->power_bus_status.fbReservedSwitchCurrent); // FB预留电流
    j["power_bus_status"]["reservedCurrent3"] = Json::Value(m_systemData->power_bus_status.reservedCurrent3); // 预留电流3
    j["power_bus_status"]["coolWaterPressure"] = Json::Value(m_systemData->power_bus_status.coolWaterPressure); // 冷却水压力

    //动力母线A状态
    j["power_a_bus_status"]["bowFTDevice123CircuitBreaker"] = Json::Value(m_systemData->power_a_bus_status.bowFTDevice123CircuitBreaker); // 艏部FT装置1/2/3断路器状态: 0-断开 1-闭合 2-故障
    j["power_a_bus_status"]["actuatorCircuitBreaker"] = Json::Value(m_systemData->power_a_bus_status.actuatorCircuitBreaker); // 启闭机构断路器状态: 0-断开 1-闭合 2-故障
    j["power_a_bus_status"]["mastSteeringGearControlBoxCircuitBreaker"] = Json::Value(m_systemData->power_a_bus_status.mastSteeringGearControlBoxCircuitBreaker); // 桅杆舵机控制箱断路器状态: 0-断开 1-闭合 2-故障
    j["power_a_bus_status"]["xczCircuitBreaker"] = Json::Value(m_systemData->power_a_bus_status.xczCircuitBreaker); // XCZ断路器状态: 0-断开 1-闭合 2-故障
    j["power_a_bus_status"]["bowRudderControlBoxCircuitBreaker"] = Json::Value(m_systemData->power_a_bus_status.bowRudderControlBoxCircuitBreaker); // 艏舵控制箱断路器状态: 0-断开 1-闭合 2-故障
    j["power_a_bus_status"]["openWaterCoverStartCylinderCircuitBreaker"] = Json::Value(m_systemData->power_a_bus_status.openWaterCoverStartCylinderCircuitBreaker); // 敞水盖启动电缸断路器状态: 0-断开 1-闭合 2-故障
    j["power_a_bus_status"]["instrumentPowerFailureSignal"] = Json::Value(m_systemData->power_a_bus_status.instrumentPowerFailureSignal); // 仪表电源失电信号: 0-正常 1-故障
    j["power_a_bus_status"]["emergencyPowerFailureSignal"] = Json::Value(m_systemData->power_a_bus_status.emergencyPowerFailureSignal); // 应急电源失电信号: 0-正常 1-故障
    j["power_a_bus_status"]["waterIngressionAlarm"] = Json::Value(m_systemData->power_a_bus_status.waterIngressionAlarm); // 浸水报警: 0-无 1-有
    j["power_a_bus_status"]["busbarBVoltage"] = Json::Value(m_systemData->power_a_bus_status.busbarBVoltage); // 汇流排B电压
    j["power_a_bus_status"]["busbarBCurrent"] = Json::Value(m_systemData->power_a_bus_status.busbarBCurrent); // 汇流排B电流
    j["power_a_bus_status"]["bowFTDevice123Current"] = Json::Value(m_systemData->power_a_bus_status.bowFTDevice123Current); // 艏部FT装置1/2/3电流
    j["power_a_bus_status"]["actuatorCurrent"] = Json::Value(m_systemData->power_a_bus_status.actuatorCurrent); // 启闭机构电流
    j["power_a_bus_status"]["mastSteeringGearControlBoxCurrent"] = Json::Value(m_systemData->power_a_bus_status.mastSteeringGearControlBoxCurrent); // 桅杆舵机控制箱电流
    j["power_a_bus_status"]["xczCurrent"] = Json::Value(m_systemData->power_a_bus_status.xczCurrent); // XCZ电流
    j["power_a_bus_status"]["bowRudderControlBoxCurrent"] = Json::Value(m_systemData->power_a_bus_status.bowRudderControlBoxCurrent); // 艏舵控制箱电流
    j["power_a_bus_status"]["openWaterCoverStartCylinderCurrent"] = Json::Value(m_systemData->power_a_bus_status.openWaterCoverStartCylinderCurrent); // 敞水盖启动电缸电流

    //仪表主母线状态
    j["instrument_main_bus_status"]["lithiumBatteryGroupInstrumentCircuitBreaker"] = Json::Value(m_systemData->instrument_main_bus_status.lithiumBatteryGroupInstrumentCircuitBreaker); // 锂电池组(仪表)断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["bowLowVoltageDistributionBoxCircuitBreaker"] = Json::Value(m_systemData->instrument_main_bus_status.bowLowVoltageDistributionBoxCircuitBreaker); // 艏部低压配电箱断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["unit4InstrumentDC48VCircuitBreaker"] = Json::Value(m_systemData->instrument_main_bus_status.unit4InstrumentDC48VCircuitBreaker); // UNIT4仪表DC48V断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["dcC1DCDistributionPanelCircuitBreaker"] = Json::Value(m_systemData->instrument_main_bus_status.dcC1DCDistributionPanelCircuitBreaker); // DC-C1直流配电板断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["reservedCircuitBreaker1"] = Json::Value(m_systemData->instrument_main_bus_status.reservedCircuitBreaker1); // 预留断路器1状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["reservedCircuitBreaker2"] = Json::Value(m_systemData->instrument_main_bus_status.reservedCircuitBreaker2); // 预留断路器2状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["emergencyLithiumBatteryGroup2CircuitBreaker"] = Json::Value(m_systemData->instrument_main_bus_status.emergencyLithiumBatteryGroup2CircuitBreaker); // 应急锂电池组2断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_main_bus_status"]["instrumentPowerFailureSignal"] = Json::Value(m_systemData->instrument_main_bus_status.instrumentPowerFailureSignal); // 仪表电源失电信号: 0-正常 1-故障
    j["instrument_main_bus_status"]["emergencyPowerFailureSignal"] = Json::Value(m_systemData->instrument_main_bus_status.emergencyPowerFailureSignal); // 应急电源失电信号: 0-正常 1-故障
    j["instrument_main_bus_status"]["instrumentBusbarInsulationLow"] = Json::Value(m_systemData->instrument_main_bus_status.instrumentBusbarInsulationLow); // 仪表汇流排绝缘低: 0-正常 1-绝缘低
    j["instrument_main_bus_status"]["instrumentBusbarVoltage"] = Json::Value(m_systemData->instrument_main_bus_status.instrumentBusbarVoltage); // 仪表母排电压
    j["instrument_main_bus_status"]["bowLowVoltageDistributionBoxCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.bowLowVoltageDistributionBoxCurrent); // 艏部低压配电箱电流
    j["instrument_main_bus_status"]["dcC1InstrumentDC48VCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.dcC1InstrumentDC48VCurrent); // DC-C1(直流配电板1)仪表DC48V电流
    j["instrument_main_bus_status"]["reservedCurrent1"] = Json::Value(m_systemData->instrument_main_bus_status.reservedCurrent1); // 预留电流1
    j["instrument_main_bus_status"]["emergencyLithiumBatteryGroup2Current"] = Json::Value(m_systemData->instrument_main_bus_status.emergencyLithiumBatteryGroup2Current); // 应急锂电池组2电流
    j["instrument_main_bus_status"]["lithiumBatteryGroupInstrumentCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.lithiumBatteryGroupInstrumentCurrent); // 锂电池组(仪表)电流
    j["instrument_main_bus_status"]["unit4InstrumentDC48VCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.unit4InstrumentDC48VCurrent); // UNIT4仪表DC48V电流
    j["instrument_main_bus_status"]["reservedCurrent2"] = Json::Value(m_systemData->instrument_main_bus_status.reservedCurrent2); // 预留电流2
    j["instrument_main_bus_status"]["emergency2BusbarVoltage"] = Json::Value(m_systemData->instrument_main_bus_status.emergency2BusbarVoltage); // 应急2汇流排电压
    j["instrument_main_bus_status"]["compositeEnergyManagementSystemEmergencyDC48VCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.compositeEnergyManagementSystemEmergencyDC48VCurrent); // 复合能源管控系统应急DC48V电流
    j["instrument_main_bus_status"]["fuelCellSecuritySystemEmergencyDC48VCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.fuelCellSecuritySystemEmergencyDC48VCurrent); // 燃料电池安全系统应急DC48V电流
    j["instrument_main_bus_status"]["plcControlPowerCurrent"] = Json::Value(m_systemData->instrument_main_bus_status.plcControlPowerCurrent); // PLC控制电源电流

    //仪表母线状态
    j["instrument_bus_status"]["unit1CircuitBreaker"] = Json::Value(m_systemData->instrument_bus_status.unit1CircuitBreaker); // UNIT1断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["unit2CircuitBreaker"] = Json::Value(m_systemData->instrument_bus_status.unit2CircuitBreaker); // UNIT2断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["unit3CircuitBreaker"] = Json::Value(m_systemData->instrument_bus_status.unit3CircuitBreaker); // UNIT3断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["unit5CircuitBreaker"] = Json::Value(m_systemData->instrument_bus_status.unit5CircuitBreaker); // UNIT5断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["bowPZDeviceCircuitBreaker"] = Json::Value(m_systemData->instrument_bus_status.bowPZDeviceCircuitBreaker); // 艏部PZ装置断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["reservedCircuitBreaker1"] = Json::Value(m_systemData->instrument_bus_status.reservedCircuitBreaker1); // 预留断路器1状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["reservedCircuitBreaker2"] = Json::Value(m_systemData->instrument_bus_status.reservedCircuitBreaker2); // 预留断路器2状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["emergencyLithiumBatteryGroup1CircuitBreaker"] = Json::Value(m_systemData->instrument_bus_status.emergencyLithiumBatteryGroup1CircuitBreaker); // 应急锂电池组1断路器状态: 0-断开 1-闭合 2-故障
    j["instrument_bus_status"]["powerFailureSignal"] = Json::Value(m_systemData->instrument_bus_status.powerFailureSignal); // 仪表电源失电信号: 0-正常 1-故障
    j["instrument_bus_status"]["emergencyPowerFailureSignal"] = Json::Value(m_systemData->instrument_bus_status.emergencyPowerFailureSignal); // 应急电源失电信号: 0-正常 1-故障
    j["instrument_bus_status"]["waterIngressionAlarm"] = Json::Value(m_systemData->instrument_bus_status.waterIngressionAlarm); // 浸水报警: 0-无 1-有
    j["instrument_bus_status"]["instrumentBusbarVoltage"] = Json::Value(m_systemData->instrument_bus_status.instrumentBusbarVoltage); // 仪表母排电压
    j["instrument_bus_status"]["instrumentBusbarCurrent"] = Json::Value(m_systemData->instrument_bus_status.instrumentBusbarCurrent); // 仪表母排电流
    j["instrument_bus_status"]["unit1Current"] = Json::Value(m_systemData->instrument_bus_status.unit1Current); // UNIT1电流
    j["instrument_bus_status"]["unit2Current"] = Json::Value(m_systemData->instrument_bus_status.unit2Current); // UNIT2电流
    j["instrument_bus_status"]["unit3Current"] = Json::Value(m_systemData->instrument_bus_status.unit3Current); // UNIT3电流
    j["instrument_bus_status"]["unit5Current"] = Json::Value(m_systemData->instrument_bus_status.unit5Current); // UNIT5电流
    j["instrument_bus_status"]["bowPZDeviceCurrent"] = Json::Value(m_systemData->instrument_bus_status.bowPZDeviceCurrent); // 艏部PZ装置电流
    j["instrument_bus_status"]["emergencyLithiumBatteryGroup1Current"] = Json::Value(m_systemData->instrument_bus_status.emergencyLithiumBatteryGroup1Current); // 应急锂电池组1电流
    j["instrument_bus_status"]["emergency1BusbarVoltage"] = Json::Value(m_systemData->instrument_bus_status.emergency1BusbarVoltage); // 应急1汇流排电压


    //MOOSDB数据
    j["moosdb"]["appFreq"] = Json::Value(m_powerManger->GetPublicAppFreq()); 
    j["moosdb"]["commFreq"] = Json::Value(m_powerManger->GetPublicCommsFreq()); 
    j["moosdb"]["startTime"] = Json::Value(m_powerManger->GetPublicAppStartTime()); 
    j["moosdb"]["cpuLoad"] = Json::Value(m_powerManger->GetPublicCPULoad());
    j["moosdb"]["timeSinceIterate"] = Json::Value(m_powerManger->GetPublicTimeSinceIterate());
    j["moosdb"]["lastIterateTime"] = Json::Value(m_powerManger->GetPublicLastIterateTime());
    // 时间戳
    j["timestamp"] = Json::Value((Json::UInt64)(std::chrono::duration_cast<std::chrono::milliseconds>(
        std::chrono::system_clock::now().time_since_epoch()).count()));
    
    Json::StreamWriterBuilder builder;
    std::string msg = Json::writeString(builder, j);
    
    // 发送给所有WebSocket客户端
    std::lock_guard<std::mutex> lock(ws_connections_mutex_);
    for (auto c : ws_connections_) {
        mg_ws_send(c, msg.c_str(), msg.size(), WEBSOCKET_OP_TEXT);
    }
}

void HttpServer::start() {
    if (running_) return;
    
    std::string addr = "http://0.0.0.0:" + std::to_string(port_);
    mg_http_listen(&mgr_, addr.c_str(), [](mg_connection *c, int ev, void *ev_data) {
        HttpServer* server = static_cast<HttpServer*>(c->fn_data);
        if (server) {
            server->handleWebSocketEvent(c, ev, ev_data, c->fn_data);
        }
    }, this);
    
    running_ = true;
    m_ServerThread.Initialise(serverThreadCB, this);
    m_ServerThread.Start();
    
    std::cout << "HTTP server started on " << addr << std::endl;
    LOG_F(INFO, "HTTP server started on %s", addr.c_str());
}

void HttpServer::stop() {
    if (!running_) return;
    
    running_ = false;
    m_ServerThread.Stop();
    
    // 关闭所有WebSocket连接
    std::lock_guard<std::mutex> lock(ws_connections_mutex_);
    for (auto c : ws_connections_) {
        mg_ws_send(c, "", 0, WEBSOCKET_OP_CLOSE);
    }
    ws_connections_.clear();
    
    std::cout << "HTTP server stopped" << std::endl;
}

bool HttpServer::isRunning() const {
    return running_;
}

void HttpServer::handleLogRequest(struct mg_connection* c, const std::string& msg) {
    try {
        Json::Value json;
        Json::CharReaderBuilder builder;
        std::unique_ptr<Json::CharReader> reader(builder.newCharReader());
        const char* msg_cstr = msg.c_str();
        std::string errors;
        
        if (!reader->parse(msg_cstr, msg_cstr + msg.size(), &json, &errors)) {
            LOG_F(ERROR, "Failed to parse log request JSON: %s", errors.c_str());
            return;
        }

        std::string type = json["type"].asString();
        if (type == "get_logs") {
            int page = json["page"].asInt();
            int pageSize = json["pageSize"].asInt();
            std::string level = json["filter"]["level"].asString();
            std::string search = json["filter"]["search"].asString();
            bool reverse = json["reverse"].asBool(); // 新增参数，控制是否倒序显示

            auto logs = readLogFile(page, pageSize, level, search);
            
            Json::Value response;
            response["type"] = "log";
            response["page"] = page;
            response["pageSize"] = pageSize;
            response["total"] = logs.size(); // 返回总条数
            response["content"] = Json::arrayValue;
            
            if (reverse) {
                // 如果需要倒序，反转日志顺序
                for (auto it = logs.rbegin(); it != logs.rend(); ++it) {
                    response["content"].append(*it);
                }
            } else {
                // 否则按原顺序返回
                for (const auto& log : logs) {
                    response["content"].append(log);
                }
            }

            Json::StreamWriterBuilder builder;
            std::string responseStr = Json::writeString(builder, response);
            mg_ws_send(c, responseStr.c_str(), responseStr.size(), WEBSOCKET_OP_TEXT);
        }
    } catch (const std::exception& e) {
        LOG_F(ERROR, "Error handling log request: %s", e.what());
    }
}

std::vector<std::string> HttpServer::readLogFile(int page, int pageSize, const std::string& level, const std::string& search) {
    std::vector<std::string> logs;
    std::ifstream file(m_logFilePath);
    if (!file.is_open()) {
        LOG_F(ERROR, "Failed to open log file: %s", m_logFilePath.c_str());
        return logs;
    }

    // 获取文件大小
    file.seekg(0, std::ios::end);
    std::streampos fileSize = file.tellg();
    file.seekg(0, std::ios::beg);

    std::string line;
    std::vector<std::string> filteredLogs;

    // 读取并过滤所有行
    while (std::getline(file, line)) {
        // 过滤日志级别和搜索内容
        if ((level.empty() || level == "ALL" || line.find(level) != std::string::npos) &&
            (search.empty() || line.find(search) != std::string::npos)) {
            filteredLogs.push_back(line);
        }
    }

    // 计算总页数
    int totalLines = filteredLogs.size();
    
    // 如果没有内容，直接返回空
    if (totalLines == 0) {
        return logs;
    }

    // 计算当前页的起始和结束索引
    int start = std::max(0, totalLines - (page * pageSize));
    int end = std::max(0, totalLines - ((page - 1) * pageSize));

    // 返回当前页的日志（已经是倒序的）
    return std::vector<std::string>(filteredLogs.begin() + start, filteredLogs.begin() + end);
}

void HttpServer::monitorLogFile() {
    static std::streampos lastPos = 0;
    std::ifstream file(m_logFilePath);
    
    if (!file.is_open()) {
        LOG_F(ERROR, "Failed to open log file for monitoring: %s", m_logFilePath.c_str());
        return;
    }

    // 获取文件大小
    file.seekg(0, std::ios::end);
    std::streampos currentPos = file.tellg();

    // 如果文件大小没有变化，直接返回
    if (currentPos == lastPos) {
        return;
    }

    // 如果是第一次读取或文件被截断，从头开始读
    if (currentPos < lastPos) {
        lastPos = 0;
    }

    // 移动到上次读取的位置
    file.seekg(lastPos);

    std::string line;
    std::vector<std::string> newLogs;

    // 读取新的日志行
    while (std::getline(file, line)) {
        newLogs.push_back(line);
    }

    // 更新最后读取位置
    lastPos = currentPos;

    // 如果有新日志，推送给所有客户端
    if (!newLogs.empty()) {
        Json::Value json;
        json["type"] = "new_log";
        json["content"] = Json::arrayValue;
        
        // 只保留最新的100行
        size_t start = newLogs.size() > 100 ? newLogs.size() - 100 : 0;
        for (size_t i = start; i < newLogs.size(); ++i) {
            json["content"].append(newLogs[i]);
        }

        Json::StreamWriterBuilder builder;
        std::string msg = Json::writeString(builder, json);

        std::lock_guard<std::mutex> lock(ws_connections_mutex_);
        for (auto c : ws_connections_) {
            mg_ws_send(c, msg.c_str(), msg.size(), WEBSOCKET_OP_TEXT);
        }
    }
}