#include <protod_bus.h>
#include <control_bus.h>
#include <dev_bus.h>
#include <event_bus.h>
#include <alarm_bus.h>
#include <generic_bus.h>
#include <nng/nng.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <time.h>

static volatile int g_running = 1;
static char *g_bus_name = "protod";  // protod, control, dev, event, alarm
static int g_monitor_all = 0;  // 是否监听所有总线

// 总线启动控制宏 - 用于测试时选择性启动总线
#define ENABLE_PROTOD_BUS   1
#define ENABLE_CONTROL_BUS  1
#define ENABLE_DEV_BUS      1
#define ENABLE_EVENT_BUS    1
#define ENABLE_ALARM_BUS    1
#define ENABLE_GENERIC_BUS  0

typedef enum {
    BUS_TYPE_INVALID = -1,
    BUS_TYPE_PROTOD = 0,
    BUS_TYPE_CONTROL,
    BUS_TYPE_DEV,
    BUS_TYPE_EVENT,
    BUS_TYPE_ALARM,
    BUS_TYPE_GENERIC,
    BUS_TYPE_MAX
} bus_type_t;

// 信号处理函数
void signal_handler(int signo) {
    (void)signo;
    printf("\nReceived signal, shutting down...\n");
    g_running = 0;
}

void print_usage(const char *prog_name) {
    printf("Usage: %s [bus_name]\n", prog_name);
    printf("  bus_name: protod (default), control, dev, event, alarm, generic, all\n");
    printf("  -h, --help: Show this help message\n");
}

// 打印时间戳
void print_timestamp(void) {
    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    char time_str[64];
    strftime(time_str, sizeof(time_str), "%Y-%m-%d %H:%M:%S", tm_info);
    printf("[%s] ", time_str);
}

// 打印消息头信息
void print_message_header(const msg_header_t *header) {
    print_timestamp();
    printf("%s->%s 0x%04X Seq:%u Len:%u\n",
           header->src == PROTOD ? "PROTOD" :
           header->src == EMSD ? "EMSD" :
           header->src == CONFIG ? "CONFIG" :
           header->src == NORTHD ? "NORTHD" :
           header->src == PROCDATA ? "PROCDATA" :
           header->src == ALARMD ? "ALARMD" :
           header->src == EVENTD ? "EVENTD" :
           header->src == DEVICE_MANAGER ? "DEVICE_MGR" : "UNKNOWN",
           header->dst == BROADCAST ? "BROADCAST" :
           header->dst == PROTOD ? "PROTOD" :
           header->dst == EMSD ? "EMSD" :
           header->dst == CONFIG ? "CONFIG" :
           header->dst == NORTHD ? "NORTHD" :
           header->dst == PROCDATA ? "PROCDATA" :
           header->dst == ALARMD ? "ALARMD" :
           header->dst == EVENTD ? "EVENTD" :
           header->dst == DEVICE_MANAGER ? "DEVICE_MGR" : "UNKNOWN",
           header->cmd, header->seq, header->len);
}

// 处理 PROTOD_BUS_MSG
void handle_protod_bus_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const protod_bus_msg_t *msg = (const protod_bus_msg_t *)body;

    char time_str[32];
    time_t timestamp = msg->timestamp / 1000;
    struct tm *tm_info = localtime(&timestamp);
    strftime(time_str, sizeof(time_str), "%H:%M:%S", tm_info);

    if (msg->data_type == DATA_TYPE_INT) {
        printf("  PROTOD: %s = %d [%s]\n", msg->point_name, msg->data.int_data, time_str);
    } else {
        printf("  PROTOD: %s = %.4f [%s]\n", msg->point_name, msg->data.float_data, time_str);
    }
}

// 处理 LOGLEVEL 消息
void handle_loglevel_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const loglevel_bus_msg_t *msg = (const loglevel_bus_msg_t *)body;
    printf("  LOGLEVEL: %d\n", msg->loglevel);
}

// 处理 ALARM 消息
void handle_alarm_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const alarm_bus_report_msg_t *msg = (const alarm_bus_report_msg_t *)body;
    printf("  ALARM REPORT: code=%d, reason=%d, severity=%d, status=%d\n",
           msg->alarm_code, msg->reason_code, msg->severity, msg->status);
    printf("    tag=%s, entity=%s, additional=%s\n",
           msg->tag, msg->entity, msg->additional);
    printf("    raise_time=%llu, recovery_time=%llu\n",
           (unsigned long long)msg->raise_time, (unsigned long long)msg->recovery_time);
}

// 处理 ALARM TAG 消息
void handle_alarm_tag_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const alarm_bus_tag_report_msg_t *msg = (const alarm_bus_tag_report_msg_t *)body;
    printf("  ALARM TAG REPORT: code=%d, reason=%d, severity=%d, status=%d\n",
           msg->report.alarm_code, msg->report.reason_code, msg->report.severity, msg->report.status);
    printf("    tag_name=%s, type=%s, vendor=%s, model=%s\n",
           msg->tag_name, msg->type, msg->vendor, msg->model);
    printf("    entity=%s, additional=%s\n",
           msg->report.entity, msg->report.additional);
}

// 处理 ALARM REGISTER 消息
void handle_alarm_register_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const alarm_bus_register_msg_t *msg = (const alarm_bus_register_msg_t *)body;
    printf("  ALARM REGISTER: code=%d, reason=%d, severity=%d\n",
           msg->alarm_code, msg->reason_code, msg->severity);
    printf("    tag=%s, type=%s, vendor=%s, model=%s\n",
           msg->tag, msg->type, msg->vendor, msg->model);
}

// 处理 ALARM QUERY 消息
void handle_alarm_query_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const alarm_bus_query_msg_t *msg = (const alarm_bus_query_msg_t *)body;
    printf("  ALARM QUERY: module_id=%d, alarm_id=%d\n",
           msg->module_id, msg->alarm_id);
}

// 处理 CONTROL 总线的 INTERFACE_MSG
void handle_control_interface_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const procdata_interface_msg_t *msg = (const procdata_interface_msg_t *)body;
    printf("  CONTROL: opcode=%d, resp_status=%d, dev=%s\n",
           msg->opcode, msg->resp_status, msg->dev_tag_name);
}

// 处理 DEV 总线的 CONFIG_DEV_MSG
void handle_dev_config_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const config_dev_msg_t *msg = (const config_dev_msg_t *)body;
    printf("  DEV: opcode=%d (0x%04X), resp_status=%d\n",
           msg->opcode, msg->opcode, msg->resp_status);

    switch (msg->opcode) {
        case CMD_SET_IPADDR:
            printf("    CMD_SET_IPADDR: proto=%d, dest_sn=%s, ip=%s, netmask=%s, gw=%s\n",
                   msg->data.ip.proto,
                   msg->data.ip.dest_sn,
                   msg->data.ip.ip_addr,
                   msg->data.ip.net_mask,
                   msg->data.ip.gateway);
            break;

        case CMD_SET_METER_DATA:
            printf("    CMD_SET_METER_DATA\n");
            break;

        case CMD_SET_SHARING_DATA:
        case CMD_GET_SHARING_DATA:
            printf("    CMD_SET/GET_SHARING_DATA: sn=%s, capacity=%d, power=%d, fire=%d, meter=%.2f\n",
                   msg->data.sharing_data.sn,
                   msg->data.sharing_data.capacity,
                   msg->data.sharing_data.power,
                   msg->data.sharing_data.fire,
                   msg->data.sharing_data.meter_data);
            break;

        case CMD_RELOAD_LC_LIST:
            printf("    CMD_RELOAD_LC_LIST\n");
            break;

        case CMD_CONFIG_RESPONSE:
            printf("    CMD_CONFIG_RESPONSE\n");
            break;

        default:
            printf("    Unknown opcode: %d (0x%04X)\n", msg->opcode, msg->opcode);
            break;
    }
}

// 处理 EVENT 总线的事件报告消息
void handle_event_report_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const event_bus_msg_t *msg = (const event_bus_msg_t *)body;
    printf("  EVENT: code=%d, functionCode=%d, period=%d\n",
           msg->eventCode, msg->functionCode, msg->period);
    printf("    eventInfo: %s\n", msg->eventInfo);
    printf("    eventCategory: %s\n", msg->eventCategory);
    printf("    event: %s\n", msg->event);
    printf("    operator: %s\n", msg->operator);
    printf("    operate_obj: %s\n", msg->operate_obj);
    if (strlen(msg->addDescr) > 0) {
        printf("    addDescr: %s\n", msg->addDescr);
    }
}

// 处理 GENERIC 总线的自定义消息
void handle_generic_custom_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const generic_custom_msg_t *msg = (const generic_custom_msg_t *)body;
    printf("  GENERIC CUSTOM: msg_type=%u, seq=%u\n", msg->msg_type, msg->seq);
    printf("    data: %s\n", msg->data);
}

// 处理 GENERIC 总线的调试消息
void handle_generic_debug_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const generic_debug_msg_t *msg = (const generic_debug_msg_t *)body;
    printf("  GENERIC DEBUG: level=%d, module=%s\n", msg->level, msg->module);
    printf("    message: %s\n", msg->message);
}

// 处理 GENERIC 总线的测试消息
void handle_generic_test_msg(const msg_header_t *header, const void *body) {
    (void)header;
    const generic_test_msg_t *msg = (const generic_test_msg_t *)body;
    char time_str[32];
    time_t timestamp = msg->timestamp;
    struct tm *tm_info = localtime(&timestamp);
    strftime(time_str, sizeof(time_str), "%H:%M:%S", tm_info);
    printf("  GENERIC TEST: counter=%d, test_string=%s, time=%s\n",
           msg->counter, msg->test_string, time_str);
}

// PROTOD 总线消息处理器
void handle_protod_bus_message(msg_ser_handle handle, const msg_header_t *header, const void *body, void *user_data) {
    (void)handle;
    (void)user_data;

    print_message_header(header);

    protod_bus_cmd_t cmd = (protod_bus_cmd_t)header->cmd;

    switch (cmd) {
        case PROTOD_BUS_CMD_PROTOD_MSG:
            handle_protod_bus_msg(header, body);
            break;

        case PROTOD_BUS_CMD_LOGLEVEL:
            handle_loglevel_msg(header, body);
            break;

        case PROTOD_BUS_CMD_INTERFACE_MSG:
        
            printf("  INTERFACE: %u bytes\n", header->len);
            break;

        default:
            printf("  UNKNOWN: %u bytes\n", header->len);
            break;
    }
}

// CONTROL 总线消息处理器
void handle_control_bus_message(msg_ser_handle handle, const msg_header_t *header, const void *body, void *user_data) {
    (void)handle;
    (void)user_data;

    print_message_header(header);

    control_bus_cmd_t cmd = (control_bus_cmd_t)header->cmd;

    switch (cmd) {
        case CONTROL_BUS_CMD_INTERFACE_MSG:
            handle_control_interface_msg(header, body);
            break;

        default:
            printf("  UNKNOWN: %u bytes\n", header->len);
            break;
    }
}

// DEV 总线消息处理器
void handle_dev_bus_message(msg_ser_handle handle, const msg_header_t *header, const void *body, void *user_data) {
    (void)handle;
    (void)user_data;

    print_message_header(header);

    dev_bus_cmd_t cmd = (dev_bus_cmd_t)header->cmd;

    switch (cmd) {
        case DEV_BUS_CMD_CONFIG_DEV_MSG:
            handle_dev_config_msg(header, body);
            break;

        default:
            printf("  UNKNOWN: %u bytes\n", header->len);
            break;
    }
}

// EVENT 总线消息处理器
void handle_event_bus_message(msg_ser_handle handle, const msg_header_t *header, const void *body, void *user_data) {
    (void)handle;
    (void)user_data;

    print_message_header(header);

    event_bus_cmd_t cmd = (event_bus_cmd_t)header->cmd;

    switch (cmd) {
        case EVENT_BUS_CMD_EVENT_REPORT:
            handle_event_report_msg(header, body);
            break;

        case EVENT_BUS_CMD_EVENT_QUERY:
            printf("  EVENT_QUERY: %u bytes\n", header->len);
            break;

        case EVENT_BUS_CMD_EVENT_ACK:
            printf("  EVENT_ACK: %u bytes\n", header->len);
            break;

        default:
            printf("  UNKNOWN: %u bytes\n", header->len);
            break;
    }
}

// ALARM 总线消息处理器
void handle_alarm_bus_message(msg_ser_handle handle, const msg_header_t *header, const void *body, void *user_data) {
    (void)handle;
    (void)user_data;

    print_message_header(header);

    alarm_bus_cmd_t cmd = (alarm_bus_cmd_t)header->cmd;

    switch (cmd) {
        case ALARM_BUS_CMD_REGISTER:
            handle_alarm_register_msg(header, body);
            break;

        case ALARM_BUS_CMD_REPORT:
            handle_alarm_msg(header, body);
            break;

        case ALARM_BUS_CMD_TAG_REPORT:
            handle_alarm_tag_msg(header, body);
            break;

        case ALARM_BUS_CMD_QUERY:
            handle_alarm_query_msg(header, body);
            break;

        default:
            printf("  UNKNOWN: %u bytes\n", header->len);
            break;
    }
}

// GENERIC 总线消息处理器
void handle_generic_bus_message(msg_ser_handle handle, const msg_header_t *header, const void *body, void *user_data) {
    (void)handle;
    (void)user_data;

    print_message_header(header);

    generic_bus_cmd_t cmd = (generic_bus_cmd_t)header->cmd;

    switch (cmd) {
        case GENERIC_BUS_CMD_CUSTOM_MSG:
            handle_generic_custom_msg(header, body);
            break;

        case GENERIC_BUS_CMD_DEBUG_MSG:
            handle_generic_debug_msg(header, body);
            break;

        case GENERIC_BUS_CMD_TEST_MSG:
            handle_generic_test_msg(header, body);
            break;

        default:
            printf("  UNKNOWN: %u bytes\n", header->len);
            break;
    }
}

int main(int argc, char *argv[]) {
    // 解析命令行参数
    if (argc > 2) {
        print_usage(argv[0]);
        return 1;
    }

    // 检查 help 参数
    if (argc == 2 && (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0)) {
        print_usage(argv[0]);
        return 0;
    }

    // 解析总线类型
    bus_type_t bus_type = BUS_TYPE_PROTOD;
    if (argc == 2) {
        if (strcmp(argv[1], "protod") == 0) {
            bus_type = BUS_TYPE_PROTOD;
            g_bus_name = "protod";
        } else if (strcmp(argv[1], "control") == 0) {
            bus_type = BUS_TYPE_CONTROL;
            g_bus_name = "control";
        } else if (strcmp(argv[1], "dev") == 0) {
            bus_type = BUS_TYPE_DEV;
            g_bus_name = "dev";
        } else if (strcmp(argv[1], "event") == 0) {
            bus_type = BUS_TYPE_EVENT;
            g_bus_name = "event";
        } else if (strcmp(argv[1], "alarm") == 0) {
            bus_type = BUS_TYPE_ALARM;
            g_bus_name = "alarm";
        } else if (strcmp(argv[1], "generic") == 0) {
            bus_type = BUS_TYPE_GENERIC;
            g_bus_name = "generic";
        } else if (strcmp(argv[1], "all") == 0) {
            g_monitor_all = 1;
            g_bus_name = "all";
        } else {
            printf("Invalid bus_name: %s\n", argv[1]);
            print_usage(argv[0]);
            return 1;
        }
    }

    if (g_monitor_all) {
        printf("=== Bus Monitor (ALL BUSES) ===\n");
        printf("Listening to all bus messages...\n\n");
    } else {
        const char *bus_display_name = bus_type == BUS_TYPE_PROTOD ? "PROTOD" :
                                     bus_type == BUS_TYPE_CONTROL ? "CONTROL" :
                                     bus_type == BUS_TYPE_DEV ? "DEV" :
                                     bus_type == BUS_TYPE_EVENT ? "EVENT" :
                                     bus_type == BUS_TYPE_ALARM ? "ALARM" : "GENERIC";
        printf("=== Bus Monitor (%s) ===\n", bus_display_name);
        printf("Listening to %s bus messages...\n\n", g_bus_name);
    }

    // 注册信号处理
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);

    int ret;

    if (g_monitor_all) {
        // 初始化所有总线
        printf("Initializing all buses...\n");

#if ENABLE_PROTOD_BUS
        // PROTOD 总线
        ret = protod_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize protod_bus: %d\n", ret);
        } else {
            protod_bus_register_handler(PROTOD_BUS_CMD_PROTOD_MSG, handle_protod_bus_message, NULL);
            protod_bus_register_handler(PROTOD_BUS_CMD_LOGLEVEL, handle_protod_bus_message, NULL);
            protod_bus_register_handler(PROTOD_BUS_CMD_INTERFACE_MSG, handle_protod_bus_message, NULL);
        }
#endif

#if ENABLE_CONTROL_BUS
        // CONTROL 总线
        ret = control_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize control_bus: %d\n", ret);
        } else {
            control_bus_register_handler(CONTROL_BUS_CMD_INTERFACE_MSG, handle_control_bus_message, NULL);
        }
#endif

#if ENABLE_DEV_BUS
        // DEV 总线
        ret = dev_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize dev_bus: %d\n", ret);
        } else {
            dev_bus_register_handler(DEV_BUS_CMD_CONFIG_DEV_MSG, handle_dev_bus_message, NULL);
        }
#endif

#if ENABLE_EVENT_BUS
        // EVENT 总线
        ret = event_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize event_bus: %d\n", ret);
        } else {
            event_bus_register_handler(EVENT_BUS_CMD_EVENT_REPORT, handle_event_bus_message, NULL);
            event_bus_register_handler(EVENT_BUS_CMD_EVENT_QUERY, handle_event_bus_message, NULL);
            event_bus_register_handler(EVENT_BUS_CMD_EVENT_ACK, handle_event_bus_message, NULL);
        }
#endif

#if ENABLE_ALARM_BUS
        // ALARM 总线
        ret = alarm_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize alarm_bus: %d\n", ret);
        } else {
            alarm_bus_register_handler(ALARM_BUS_CMD_REGISTER, handle_alarm_bus_message, NULL);
            alarm_bus_register_handler(ALARM_BUS_CMD_REPORT, handle_alarm_bus_message, NULL);
            alarm_bus_register_handler(ALARM_BUS_CMD_TAG_REPORT, handle_alarm_bus_message, NULL);
            alarm_bus_register_handler(ALARM_BUS_CMD_QUERY, handle_alarm_bus_message, NULL);
        }
#endif

#if ENABLE_GENERIC_BUS
        // GENERIC 总线
        ret = generic_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize generic_bus: %d\n", ret);
        } else {
            generic_bus_register_handler(GENERIC_BUS_CMD_CUSTOM_MSG, handle_generic_bus_message, NULL);
            generic_bus_register_handler(GENERIC_BUS_CMD_DEBUG_MSG, handle_generic_bus_message, NULL);
            generic_bus_register_handler(GENERIC_BUS_CMD_TEST_MSG, handle_generic_bus_message, NULL);
        }
#endif
    } else if (bus_type == BUS_TYPE_PROTOD) {
        // 初始化 protod_bus
        ret = protod_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize protod_bus: %d\n", ret);
            return 1;
        }
        // 注册所有消息类型的处理器
        protod_bus_register_handler(PROTOD_BUS_CMD_PROTOD_MSG, handle_protod_bus_message, NULL);
        protod_bus_register_handler(PROTOD_BUS_CMD_LOGLEVEL, handle_protod_bus_message, NULL);
        protod_bus_register_handler(PROTOD_BUS_CMD_INTERFACE_MSG, handle_protod_bus_message, NULL);
    } else if (bus_type == BUS_TYPE_CONTROL) {
        // 初始化 control_bus
        ret = control_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize control_bus: %d\n", ret);
            return 1;
        }
        // 注册所有消息类型的处理器
        control_bus_register_handler(CONTROL_BUS_CMD_INTERFACE_MSG, handle_control_bus_message, NULL);
    } else if (bus_type == BUS_TYPE_DEV) {
        // 初始化 dev_bus
        ret = dev_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize dev_bus: %d\n", ret);
            return 1;
        }
        // 注册所有消息类型的处理器
        dev_bus_register_handler(DEV_BUS_CMD_CONFIG_DEV_MSG, handle_dev_bus_message, NULL);
    } else if (bus_type == BUS_TYPE_EVENT) {
        // 初始化 event_bus
        ret = event_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize event_bus: %d\n", ret);
            return 1;
        }
        // 注册所有消息类型的处理器
        event_bus_register_handler(EVENT_BUS_CMD_EVENT_REPORT, handle_event_bus_message, NULL);
        event_bus_register_handler(EVENT_BUS_CMD_EVENT_QUERY, handle_event_bus_message, NULL);
        event_bus_register_handler(EVENT_BUS_CMD_EVENT_ACK, handle_event_bus_message, NULL);
    } else if (bus_type == BUS_TYPE_ALARM) {
        // 初始化 alarm_bus
        ret = alarm_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize alarm_bus: %d\n", ret);
            return 1;
        }
        // 注册所有消息类型的处理器
        alarm_bus_register_handler(ALARM_BUS_CMD_REGISTER, handle_alarm_bus_message, NULL);
        alarm_bus_register_handler(ALARM_BUS_CMD_REPORT, handle_alarm_bus_message, NULL);
        alarm_bus_register_handler(ALARM_BUS_CMD_TAG_REPORT, handle_alarm_bus_message, NULL);
        alarm_bus_register_handler(ALARM_BUS_CMD_QUERY, handle_alarm_bus_message, NULL);
    } else if (bus_type == BUS_TYPE_GENERIC) {
        // 初始化 generic_bus
        ret = generic_bus_init(BUS_MONITOR);
        if (ret != 0) {
            printf("Failed to initialize generic_bus: %d\n", ret);
            return 1;
        }
        // 注册所有消息类型的处理器
        generic_bus_register_handler(GENERIC_BUS_CMD_CUSTOM_MSG, handle_generic_bus_message, NULL);
        generic_bus_register_handler(GENERIC_BUS_CMD_DEBUG_MSG, handle_generic_bus_message, NULL);
        generic_bus_register_handler(GENERIC_BUS_CMD_TEST_MSG, handle_generic_bus_message, NULL);
    }

    printf("=== Waiting for messages ===\n");
    printf("Press Ctrl+C to exit\n\n");

    // 主循环
    while (g_running) {
        sleep(1);
    }

    // 清理
    if (g_monitor_all) {
        // 清理所有总线
        printf("Cleaning up all buses...\n");

#if ENABLE_PROTOD_BUS
        protod_bus_cleanup();
        printf("protod_bus_cleanup done\n");
#endif

#if ENABLE_CONTROL_BUS
        control_bus_cleanup();
        printf("control_bus_cleanup done\n");
#endif

#if ENABLE_DEV_BUS
        dev_bus_cleanup();
        printf("dev_bus_cleanup done\n");
#endif

#if ENABLE_EVENT_BUS
        event_bus_cleanup();
        printf("event_bus_cleanup done\n");
#endif

#if ENABLE_ALARM_BUS
        alarm_bus_cleanup();
        printf("alarm_bus_cleanup done\n");
#endif

#if ENABLE_GENERIC_BUS
        generic_bus_cleanup();
        printf("generic_bus_cleanup done\n");
#endif

        printf("All buses cleaned up\n");
    } else {
        // 清理单个总线
        if (bus_type == BUS_TYPE_PROTOD) {
            protod_bus_cleanup();
        } else if (bus_type == BUS_TYPE_CONTROL) {
            control_bus_cleanup();
        } else if (bus_type == BUS_TYPE_DEV) {
            dev_bus_cleanup();
        } else if (bus_type == BUS_TYPE_EVENT) {
            event_bus_cleanup();
        } else if (bus_type == BUS_TYPE_ALARM) {
            alarm_bus_cleanup();
        } else if (bus_type == BUS_TYPE_GENERIC) {
            generic_bus_cleanup();
        }
    }

    // 等待 libnng 内部线程完成清理
    printf("Waiting for libnng internal cleanup...\n");

    // 清理 libnng 库资源（只调用一次）
    nng_fini();

    printf("=== Bus Monitor Stopped ===\n");
    return 0;
}