/**
 * @file menu_test.c
 * @brief 菜单组件单元测试
 */
#include "menu.h"
#include "menu_port.h"
#include <stdio.h>
#include <stdlib.h>

/************************** 测试用例 **************************/

/**
 * @brief 测试菜单初始化和反初始化
 */
void test_menu_init_deinit(void)
{
    printf("Test menu_init_deinit...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 检查初始化状态
    if (!menu_is_initialized(ctx))
    {
        printf("FAILED: menu_is_initialized returned false\n");
        return;
    }
    
    // 反初始化菜单
    err = menu_deinit(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_deinit returned %d\n", err);
        return;
    }
    
    printf("PASSED\n");
}

/**
 * @brief 测试菜单节点注册
 */
void test_menu_register_node(void)
{
    printf("Test menu_register_node...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 注册菜单节点
    err = menu_register_node(ctx, 0, 1, "Main Menu", NULL, NULL);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_register_node returned %d\n", err);
        return;
    }
    
    // 注册子菜单节点
    err = menu_register_node(ctx, 1, 2, "Param Menu", NULL, NULL);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_register_node returned %d\n", err);
        return;
    }
    
    // 检查当前节点
    MenuNodeId current_node_id;
    err = menu_get_current_node(ctx, &current_node_id);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_get_current_node returned %d\n", err);
        return;
    }
    
    if (current_node_id != 1)
    {
        printf("FAILED: current_node_id is %d, expected 1\n", current_node_id);
        return;
    }
    
    // 反初始化菜单
    menu_deinit(ctx);
    
    printf("PASSED\n");
}

/**
 * @brief 测试批量注册菜单节点
 */
void test_menu_register_nodes(void)
{
    printf("Test menu_register_nodes...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 定义菜单节点配置
    MenuNodeConfig nodes[] = {
        {1, 0, "Main Menu", NULL, NULL},
        {2, 1, "Param Menu", NULL, NULL},
        {3, 1, "Info Menu", NULL, NULL},
        {4, 2, "Temp Param", NULL, NULL}
    };
    
    // 批量注册菜单节点
    err = menu_register_nodes(ctx, nodes, sizeof(nodes) / sizeof(nodes[0]));
    if (err != MENU_OK)
    {
        printf("FAILED: menu_register_nodes returned %d\n", err);
        return;
    }
    
    // 反初始化菜单
    menu_deinit(ctx);
    
    printf("PASSED\n");
}

/**
 * @brief 测试事件处理
 */
void test_menu_event(void)
{
    printf("Test menu_event...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 注册菜单节点
    err = menu_register_node(ctx, 0, 1, "Main Menu", NULL, NULL);
    err = menu_register_node(ctx, 1, 2, "Menu 1", NULL, NULL);
    err = menu_register_node(ctx, 1, 3, "Menu 2", NULL, NULL);
    
    // 发送事件
    err = menu_post_event(ctx, MENU_EVENT_KEY_DOWN, 0, MENU_EVENT_PRIORITY_NORMAL);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_post_event returned %d\n", err);
        return;
    }
    
    // 处理事件
    menu_main_loop(ctx);
    
    // 检查当前节点
    MenuNodeId current_node_id;
    err = menu_get_current_node(ctx, &current_node_id);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_get_current_node returned %d\n", err);
        return;
    }
    
    // 反初始化菜单
    menu_deinit(ctx);
    
    printf("PASSED\n");
}

/**
 * @brief 测试内存监控
 */
void test_menu_mem_stats(void)
{
    printf("Test menu_mem_stats...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 注册菜单节点
    err = menu_register_node(ctx, 0, 1, "Main Menu", NULL, NULL);
    err = menu_register_node(ctx, 1, 2, "Menu 1", NULL, NULL);
    
    // 获取内存统计信息
    MenuMemStats stats;
    err = menu_get_mem_stats(ctx, &stats);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_get_mem_stats returned %d\n", err);
        return;
    }
    
    printf("PASSED (nodes: %d/%d, params: %d/%d, events: %d/%d)\n", 
           stats.used_nodes, stats.total_nodes, 
           stats.used_params, stats.total_params, 
           stats.event_queue_used, stats.event_queue_len);
    
    // 反初始化菜单
    menu_deinit(ctx);
}

/************************** 多语言支持测试 **************************/

/**
 * @brief 测试多语言功能
 */
void test_menu_lang(void)
{
    printf("Test menu_lang...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 注册语言字符串
    err = menu_lang_register_str(ctx, 1, 0, "中文菜单");
    err = menu_lang_register_str(ctx, 1, 1, "English Menu");
    err = menu_lang_register_str(ctx, 2, 0, "参数设置");
    err = menu_lang_register_str(ctx, 2, 1, "Param Settings");
    
    // 设置当前语言为中文
    err = menu_lang_set_current(ctx, 0);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_lang_set_current(0) returned %d\n", err);
        return;
    }
    
    // 检查当前语言
    uint8_t current_lang;
    err = menu_lang_get_current(ctx, &current_lang);
    if (err != MENU_OK || current_lang != 0)
    {
        printf("FAILED: menu_lang_get_current returned %d, expected 0\n", current_lang);
        return;
    }
    
    // 批量注册语言字符串测试
    MenuLangStr strs[] = {
        {3, 0, "系统信息"},
        {3, 1, "System Info"},
        {4, 0, "关于"},
        {4, 1, "About"}
    };
    
    err = menu_lang_register_strs(ctx, strs, sizeof(strs) / sizeof(strs[0]));
    if (err != MENU_OK)
    {
        printf("FAILED: menu_lang_register_strs returned %d\n", err);
        return;
    }
    
    // 动态加载语言包测试
    MenuLangStr new_pack[] = {
        {1, 2, "Español Menú"},
        {2, 2, "Ajustes de Parámetros"},
        {3, 2, "Información del Sistema"},
        {4, 2, "Acerca de"}
    };
    
    err = menu_lang_load_pack(ctx, 2, new_pack, sizeof(new_pack) / sizeof(new_pack[0]));
    if (err != MENU_OK)
    {
        printf("FAILED: menu_lang_load_pack returned %d\n", err);
        return;
    }
    
    // 切换到新语言
    err = menu_lang_set_current(ctx, 2);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_lang_set_current(2) returned %d\n", err);
        return;
    }
    
    // 反初始化菜单
    menu_deinit(ctx);
    
    printf("PASSED\n");
}

/************************** 参数管理测试 **************************/

/**
 * @brief 测试参数管理功能
 */
void test_menu_param(void)
{
    printf("Test menu_param...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 注册菜单节点
    err = menu_register_node(ctx, 0, 1, "Main Menu", NULL, NULL);
    
    // 注册参数
    err = menu_param_register(ctx, 1, 1, MENU_PARAM_TYPE_INT16, 0, 100, 50, 1.0f);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_param_register returned %d\n", err);
        return;
    }
    
    // 设置参数值
    err = menu_param_set_value(ctx, 1, 75.0f);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_param_set_value returned %d\n", err);
        return;
    }
    
    // 获取参数值
    float value;
    err = menu_param_get_value(ctx, 1, &value);
    if (err != MENU_OK || (int)value != 75)
    {
        printf("FAILED: menu_param_get_value returned %.1f, expected 75\n", value);
        return;
    }
    
    // 获取参数类型
    MenuParamType type;
    err = menu_param_get_type(ctx, 1, &type);
    if (err != MENU_OK || type != MENU_PARAM_TYPE_INT16)
    {
        printf("FAILED: menu_param_get_type returned %d, expected %d\n", type, MENU_PARAM_TYPE_INT16);
        return;
    }
    
    // 反初始化菜单
    menu_deinit(ctx);
    
    printf("PASSED\n");
}

/************************** 优先级事件测试 **************************/

/**
 * @brief 测试优先级事件处理
 */
void test_menu_priority_event(void)
{
    printf("Test menu_priority_event...");
    
    // 分配菜单上下文
    uint8_t menu_ctx_buf[menu_get_ctx_size()];
    MenuGlobalCtx* ctx = (MenuGlobalCtx*)menu_ctx_buf;
    
    // 初始化菜单
    MenuErrCode err = menu_init(ctx);
    if (err != MENU_OK)
    {
        printf("FAILED: menu_init returned %d\n", err);
        return;
    }
    
    // 注册菜单节点
    err = menu_register_node(ctx, 0, 1, "Main Menu", NULL, NULL);
    err = menu_register_node(ctx, 1, 2, "Menu 1", NULL, NULL);
    err = menu_register_node(ctx, 1, 3, "Menu 2", NULL, NULL);
    
    // 发送不同优先级的事件
    err = menu_post_event(ctx, MENU_EVENT_KEY_DOWN, 0, MENU_EVENT_PRIORITY_LOW);
    err = menu_post_event(ctx, MENU_EVENT_KEY_UP, 0, MENU_EVENT_PRIORITY_HIGH);
    err = menu_post_event(ctx, MENU_EVENT_KEY_ENTER, 0, MENU_EVENT_PRIORITY_NORMAL);
    
    // 处理事件
    menu_main_loop(ctx);
    
    // 反初始化菜单
    menu_deinit(ctx);
    
    printf("PASSED\n");
}

/************************** 主函数 **************************/

/**
 * @brief 测试主函数
 */
int main(void)
{
    printf("Menu Component Unit Tests\n");
    printf("=========================\n");
    
    // 测试菜单初始化和反初始化
    test_menu_init_deinit();
    
    // 测试菜单节点注册
    test_menu_register_node();
    
    // 测试批量注册菜单节点
    test_menu_register_nodes();
    
    // 测试事件处理
    test_menu_event();
    
    // 测试优先级事件处理
    test_menu_priority_event();
    
    // 测试内存监控
    test_menu_mem_stats();
    
    // 测试参数管理
#if MENU_CONFIG_ENABLE_PARAM
    test_menu_param();
#endif
    
    // 测试多语言支持
#if MENU_CONFIG_ENABLE_LANG
    test_menu_lang();
#endif
    
    printf("=========================\n");
    printf("All tests completed!\n");
    
    return 0;
}