#include "service_debugset.h"
#include "format_utils.h"
#include "data_manager.h"
#include "data/data_debugset.h"
#include <time.h>
#include <sys/time.h>
#include <stdio.h>

#define DEBUGSET_SHOW_RIGHT_VALUE_X     340  // 右侧数值显示X位置
#define DEBUGSET_SHOW_RIGHT_UNIT_X      440  // 单位显示X位置

// ==================== 内部辅助函数 ====================

/**
 * @brief 验证密码范围（从data层动态获取范围）
 */
static bool is_valid_password(uint16_t password)
{
    uint16_t min, max, default_val;
    if (!data_mgr_get_password_config(&min, &max, &default_val)) {
        return false;  // 获取配置失败
    }
    return (password >= min && password <= max);
}

/**
 * @brief 验证背光时间范围（从data层动态获取范围）
 */
static bool is_valid_backlight_time(uint32_t time)
{
    uint32_t min, max;
    if (!data_mgr_get_backlight_config(&min, &max, NULL)) {
        return false;  // 获取配置失败
    }
    return (time >= min && time <= max);
}

/**
 * @brief 验证时间有效性
 */
static bool is_valid_datetime(const datetime_value_t *datetime)
{
    if (datetime == NULL) return false;
    if (datetime->year < 2000 || datetime->year > 2099) return false;
    if (datetime->month < 1 || datetime->month > 12) return false;
    if (datetime->day < 1 || datetime->day > 31) return false;
    if (datetime->hour > 23) return false;
    if (datetime->minute > 59) return false;
    if (datetime->second > 59) return false;
    return true;
}

/**
 * @brief 获取状态信息项的数值选项类型
 * @param item_idx 状态信息项索引
 * @return 数值选项类型
 */
static uint8_t get_status_numeric_opt(uint8_t item_idx)
{
    // 状态信息项的数值选项类型映射
    switch (item_idx)
    {
        case 0: // 开入量自检
        case 1: // 开出量自检
        case 2: // ADC自检
            return OPT_ERRSTATE;  // OK/Error
        case 3: // 运行状态
            return OPT_RUNSTATE;  // 停止/运行/故障
        case 4: // 本次运行时间
        case 5: // 累计运行时长
            return OPT_TIME_HM;   // XhYm格式
        default:
            return OPT_SUBNON;    // 普通数值
    }
}

/**
 * @brief 将分钟数格式化为XhYm格式
 * @param minutes 分钟数
 * @param buf 输出缓冲区
 * @param buf_size 缓冲区大小
 */
static void format_minutes_to_hm(uint32_t minutes, char* buf, size_t buf_size)
{
    if (buf == NULL || buf_size == 0)
    {
        return;
    }
    
    uint32_t hours = minutes / 60;
    uint32_t mins = minutes % 60;
    
    if (hours > 0)
    {
        // 大于等于60分钟，显示XhYm格式
        snprintf(buf, buf_size, "%u h %u m", hours, mins);
    }
    else
    {
        // 不足60分钟，显示Ym格式
        snprintf(buf, buf_size, "%u m", mins);
    }
}

/**
 * @brief 创建设厂调试页面UI数据
 * @param ctx           页面上下文
 * @param menu_sel_idx  选中菜单索引 (0=状态信息, 1=系统设置)
 * @param item_sel_idx  菜单内选中项索引
 * @param config        输出配置结构体
 * @param is_verified   是否通过密码验证
 */
static void debugset_create_show_ui_data(PageCtx *ctx, u8 menu_sel_idx, u8 item_sel_idx, GeneralListPageConfig_t *config, bool is_verified)
{
    u8 i = 0;
    char ca_buf[20] = {0};
    PageInfo info;  // 分页信息结构体
    uint16_t menu_len = 0;
    uint16_t items_len = 0;

    if (config == NULL)
    {
        GeneralListPageConfig_t default_config = {0};
        config = &default_config;
    }

    // 设置路径文本
    strcpy(config->path_text, Disp_path_opt[0]); // /主菜单/"
    strcat(config->path_text, MainManu_dis[6]);  // 出厂调试

    // 根据选择获取菜单和项长度（从data层动态获取）
    menu_len = debugset_service_get_menu_len();
    items_len = debugset_service_get_items_len(menu_sel_idx);

    // 配置左侧菜单 (2个菜单: 状态信息和系统设置)
    calculate_page_info_default(menu_sel_idx, menu_len, &info);
    config->left_menu_count = info.current_page_items;

    for (i = 0; i < config->left_menu_count; i++)
    {
        int leftidx = i + DEFAULT_LEFT_MENU_INDEX * (info.current_page - 1);
        if (leftidx < menu_len)
        {
            // 从data_debugset获取菜单名称，避免硬编码字符串
            const char* menu_name = data_mgr_get_debugset_menu_name(leftidx);
            if (menu_name != NULL)
            {
                strcpy(config->left_menu[i].text, menu_name);
            }

            if (leftidx == menu_sel_idx)
            {
                config->left_menu[i].color = LV_COLOR_RED;
            }
            else
            {
                config->left_menu[i].color = Default_HZ_color;
            }
        }
    }

    // 配置滑块
    config->slider_size = items_len;
    config->slider_value = item_sel_idx;

    // 计算右侧数据区域的分页
    calculate_page_info_default(item_sel_idx, items_len, &info);
    config->total_page = info.total_pages;
    config->current_page = info.current_page;
    config->right_data_count = info.current_page_items;

    // 处理特殊情况: 未通过密码验证时显示系统设置,
    // 显示密码输入界面而不是实际设置
    if (menu_sel_idx == DEBUGSET_MENU_SYSTEM_SET && !is_verified)
    {
        for (i = 0; i < config->right_data_count; i++)
        {
            int dataidx = i + DEFAULT_RIGHT_DATA_ITEM_COUNT * (info.current_page - 1);

            // 使用默认位置
            config->right_data[i].value_posx = DEBUGSET_SHOW_RIGHT_VALUE_X;
            config->right_data[i].unit_posx = DEBUGSET_SHOW_RIGHT_UNIT_X;

            // 密码输入只有一个项
            if (dataidx == 0)
            {
                strcpy(config->right_data[i].name, DEBUGSET_STR_SYS_PARAM_SET);
                config->right_data[i].name_color = Default_HZ_color;

                // 密码字段显示为空或星号
                strcpy(config->right_data[i].value, DEBUGSET_STR_EMPTY);
                config->right_data[i].value_color = (item_sel_idx == dataidx &&
                    ctx->cursor_state.cursor_pos == CURSOR_RIGHT_DATA) ? LV_COLOR_RED : Default_HZ_color;

                strcpy(config->right_data[i].unit, DEBUGSET_STR_EMPTY);
            }
        }
    }
    else
    {
        // 根据菜单选择显示实际数据
        if (menu_sel_idx == DEBUGSET_MENU_STATUS_INFO)
        {
            // 状态信息: 从data_debugset获取数据
            for (i = 0; i < config->right_data_count; i++)
            {
                int dataidx = i + DEFAULT_RIGHT_DATA_ITEM_COUNT * (info.current_page - 1);

                // 使用默认位置
                config->right_data[i].value_posx = DEBUGSET_SHOW_RIGHT_VALUE_X;
                config->right_data[i].unit_posx = DEBUGSET_SHOW_RIGHT_UNIT_X;

                if (dataidx < items_len)
                {
                    // 从data_debugset获取名称
                    const char* name = data_mgr_get_debugset_status_name(dataidx);
                    if (name != NULL)
                    {
                        strcpy(config->right_data[i].name, name);
                    }
                    config->right_data[i].name_color = Default_HZ_color;

                    // 获取数值选项类型
                    uint8_t numeric_opt = get_status_numeric_opt(dataidx);
                    float value = data_mgr_get_debugset_status_value(dataidx);

                    // 根据数值选项类型格式化数值
                    switch (numeric_opt)
                    {
                        case OPT_ERRSTATE:
                            // 错误状态: OK/Error
                            if ((uint32_t)value == 1)
                                strcpy(ca_buf, DEBUGSET_STR_ERRSTATE_OK);
                            else
                                strcpy(ca_buf, DEBUGSET_STR_ERRSTATE_ERROR);
                            break;

                        case OPT_RUNSTATE:
                            // 运行状态: 停止/运行/故障
                            if ((uint32_t)value < 3)
                            {
                                // 使用常量定义的运行状态字符串
                                const char* run_states[] = {
                                    DEBUGSET_STR_RUNSTATE_STOP,
                                    DEBUGSET_STR_RUNSTATE_RUN,
                                    DEBUGSET_STR_RUNSTATE_FAULT
                                };
                                strcpy(ca_buf, run_states[(uint32_t)value]);
                            }
                            else
                                strcpy(ca_buf, DEBUGSET_STR_RUNSTATE_STOP);
                            break;

                        case OPT_TIME_HM:
                            // 时间格式: XhYm (如 2h30m 或 45m)
                            format_minutes_to_hm((uint32_t)value, ca_buf, sizeof(ca_buf));
                            break;

                        default:
                            // 带小数点的数值
                            format_float_to_string(0, value, ca_buf, sizeof(ca_buf));
                            break;
                    }
                    
                    strncpy(config->right_data[i].value, ca_buf, strlen(ca_buf));

                    // 从data_debugset获取单位
                    const char* unit = data_mgr_get_debugset_status_unit(dataidx);
                    if (unit != NULL)
                    {
                        strncpy(config->right_data[i].unit, unit, strlen(unit));
                    }

                    // 根据选择设置颜色
                    if (item_sel_idx == dataidx && ctx->cursor_state.cursor_pos == CURSOR_RIGHT_DATA)
                    {
                        config->right_data[i].name_color = LV_COLOR_RED;
                        config->right_data[i].value_color = LV_COLOR_RED;
                    }
                    else
                    {
                        config->right_data[i].name_color = Default_HZ_color;
                        config->right_data[i].value_color = Default_HZ_color;
                    }
                }
            }
        }
        else if (menu_sel_idx == DEBUGSET_MENU_SYSTEM_SET)
        {
            // 系统设置: 从data_debugset获取数据
            for (i = 0; i < config->right_data_count; i++)
            {
                int dataidx = i + DEFAULT_RIGHT_DATA_ITEM_COUNT * (info.current_page - 1);

                // 使用默认位置
                config->right_data[i].value_posx = DEBUGSET_SHOW_RIGHT_VALUE_X;
                config->right_data[i].unit_posx = DEBUGSET_SHOW_RIGHT_UNIT_X;

                if (dataidx < items_len)
                {
                    // 从data_debugset获取名称
                    const char* name = data_mgr_get_debugset_system_name(dataidx);
                    if (name != NULL)
                    {
                        strcpy(config->right_data[i].name, name);
                    }
                    config->right_data[i].name_color = Default_HZ_color;

                    // 系统设置菜单中，仅背光时间设置显示数值，其他选项不显示值
                    if (dataidx == SYSSET_ITEM_BACKLIGHT)
                    {
                        // 获取数值和配置
                        float value = data_mgr_get_debugset_system_value(dataidx);
                        uint8_t point = data_debugset_get_system_point(dataidx);

                        // 格式化数值
                        format_float_to_string(point, value, ca_buf, sizeof(ca_buf));
                        strncpy(config->right_data[i].value, ca_buf, strlen(ca_buf));

                        // 从data_debugset获取单位
                        const char* unit = data_mgr_get_debugset_system_unit(dataidx);
                        if (unit != NULL)
                        {
                            strncpy(config->right_data[i].unit, unit, strlen(unit));
                        }
                    }
                    else
                    {
                        // 不显示值和单位，仅显示选项名称
                        strcpy(config->right_data[i].value, DEBUGSET_STR_EMPTY);
                        strcpy(config->right_data[i].unit, DEBUGSET_STR_EMPTY);
                    }

                    // 根据选择设置颜色（所有选项统一处理选中高亮效果）
                    if (item_sel_idx == dataidx && ctx->cursor_state.cursor_pos == CURSOR_RIGHT_DATA)
                    {
                        config->right_data[i].name_color = LV_COLOR_RED;
                        config->right_data[i].value_color = LV_COLOR_RED;
                    }
                    else
                    {
                        config->right_data[i].name_color = Default_HZ_color;
                        config->right_data[i].value_color = Default_HZ_color;
                    }
                }
            }
        }
    }
}

/**
 * @brief 获取出厂调试页面UI显示数据
 * @param ctx           页面上下文
 * @param menu_sel_idx  选中菜单索引 (0=状态信息, 1=系统设置)
 * @param item_sel_idx  菜单内选中项索引
 * @param config        输出配置结构体
 * @param is_verified   是否通过密码验证
 */
void debugset_service_get_show_ui_data(PageCtx *ctx, u8 menu_sel_idx, u8 item_sel_idx, GeneralListPageConfig_t *config, bool is_verified)
{
    // 刷新数据（从系统获取最新数据）
    data_mgr_refresh_debugset_data();
    
    debugset_create_show_ui_data(ctx, menu_sel_idx, item_sel_idx, config, is_verified);
}

/**
 * @brief 获取出厂调试页面菜单总数
 * @return 菜单数量（从data层动态获取）
 */
uint16_t debugset_service_get_menu_len(void)
{
    return (uint16_t)data_mgr_get_debugset_menu_count();
}

/**
 * @brief 获取指定菜单的项数
 * @param menu_sel_idx  菜单索引
 * @return 指定菜单的项数
 */
uint16_t debugset_service_get_items_len(u8 menu_sel_idx)
{
    return data_mgr_get_debugset_items_len(menu_sel_idx);
}

// ==================== 系统设置数据处理接口 ====================

/**
 * @brief 执行恢复出厂设置
 */
sysset_op_result_t debugset_service_factory_reset(void)
{
    printf("%s: Executing factory reset...\n", __FUNCTION__);

    // 通过data_mgr统一接口执行操作
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_FACTORY_RESET, NULL)) {
        printf("%s: Factory reset completed\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 执行清除历史记录
 */
sysset_op_result_t debugset_service_clear_history(void)
{
    printf("%s: Clearing history records...\n", __FUNCTION__);
    
    // 通过data_mgr统一接口执行操作
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_CLEAR_HISTORY, NULL)) {
        printf("%s: History records cleared\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 执行电度清除
 */
sysset_op_result_t debugset_service_clear_energy(void)
{
    printf("%s: Clearing energy data...\n", __FUNCTION__);
    
    // 通过data_mgr统一接口执行操作
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_CLEAR_ENERGY, NULL)) {
        printf("%s: Energy data cleared\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 获取当前系统时间
 */
sysset_op_result_t debugset_service_get_datetime(datetime_value_t *datetime)
{
    if (datetime == NULL) {
        return SYSSET_OP_INVALID_PARAM;
    }
    
    // 获取系统当前时间
    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    
    if (tm_info != NULL) {
        datetime->year = tm_info->tm_year + 1900;
        datetime->month = tm_info->tm_mon + 1;
        datetime->day = tm_info->tm_mday;
        datetime->hour = tm_info->tm_hour;
        datetime->minute = tm_info->tm_min;
        datetime->second = tm_info->tm_sec;
        return SYSSET_OP_SUCCESS;
    }
    
    // 如果获取系统时间失败，从data层获取默认值
    uint8_t month, day, hour, min, sec;
    if (data_mgr_get_datetime_default(&datetime->year, &month, &day, &hour, &min, &sec)) {
        datetime->month = month;
        datetime->day = day;
        datetime->hour = hour;
        datetime->minute = min;
        datetime->second = sec;
    } else {
        // fallback默认值
        datetime->year = 2024;
        datetime->month = 1;
        datetime->day = 1;
        datetime->hour = 0;
        datetime->minute = 0;
        datetime->second = 0;
    }
    
    return SYSSET_OP_SUCCESS;
}

/**
 * @brief 设置系统时间
 */
sysset_op_result_t debugset_service_set_datetime(const datetime_value_t *datetime)
{
    if (!is_valid_datetime(datetime)) {
        printf("%s: Invalid datetime parameters\n", __FUNCTION__);
        return SYSSET_OP_INVALID_PARAM;
    }
    
    printf("%s: Setting datetime to %04d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
           datetime->year, datetime->month, datetime->day,
           datetime->hour, datetime->minute, datetime->second);
    
    // 通过data_mgr统一接口执行操作
    // 将UI层的datetime_value_t转换为数据层的data_datetime_t
    data_datetime_t dt = {
        .year   = datetime->year,
        .month  = datetime->month,
        .day    = datetime->day,
        .hour   = datetime->hour,
        .minute = datetime->minute,
        .second = datetime->second
    };
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_DATETIME, &dt)) {
        printf("%s: Datetime set successfully\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 获取当前系统密码
 */
uint16_t debugset_service_get_password(void)
{
    // 从data层获取密码值
    return (uint16_t)data_mgr_get_debugset_system_value(SYSSET_ITEM_PASSWORD);
}

/**
 * @brief 设置系统密码
 */
sysset_op_result_t debugset_service_set_password(uint16_t password)
{
    uint16_t min, max;
    
    if (!is_valid_password(password)) {
        if (data_mgr_get_password_config(&min, &max, NULL)) {
            printf("%s: Invalid password range (%d-%d)\n", __FUNCTION__, min, max);
        } else {
            printf("%s: Invalid password range\n", __FUNCTION__);
        }
        return SYSSET_OP_INVALID_PARAM;
    }
    
    printf("%s: Setting password to %04d\n", __FUNCTION__, password);
    
    // 通过data_mgr统一接口执行操作
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_PASSWORD, &password)) {
        printf("%s: Password set successfully\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 执行系数校准
 */
sysset_op_result_t debugset_service_calibrate(void)
{
    printf("%s: Starting device calibration...\n", __FUNCTION__);
    
    // 通过data_mgr统一接口执行操作
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_CALIBRATION, NULL)) {
        printf("%s: Device calibration completed\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 获取背光时间
 */
uint32_t debugset_service_get_backlight_time(void)
{
    // 从data_debugset获取背光时间
    return (uint32_t)data_mgr_get_debugset_system_value(SYSSET_ITEM_BACKLIGHT);
}

/**
 * @brief 设置背光时间
 */
sysset_op_result_t debugset_service_set_backlight_time(uint32_t time)
{
    uint32_t min, max;
    
    if (!is_valid_backlight_time(time)) {
        if (data_mgr_get_backlight_config(&min, &max, NULL)) {
            printf("%s: Invalid backlight time range (%d-%d)\n", __FUNCTION__, min, max);
        } else {
            printf("%s: Invalid backlight time range\n", __FUNCTION__);
        }
        return SYSSET_OP_INVALID_PARAM;
    }
    
    printf("%s: Setting backlight time to %lu\n", __FUNCTION__, time);
    
    // 通过data_mgr统一接口执行操作
    if (data_mgr_execute_sysset_operation(SYSSET_ITEM_BACKLIGHT, &time)) {
        printf("%s: Backlight time set successfully\n", __FUNCTION__);
        return SYSSET_OP_SUCCESS;
    }
    
    return SYSSET_OP_FAILED;
}

/**
 * @brief 获取系统设置项的当前值
 */
sysset_op_result_t debugset_service_get_item_value(u8 item_idx, uint32_t *value)
{
    if (value == NULL || item_idx >= data_mgr_get_debugset_items_len(DEBUGSET_MENU_SYSTEM_SET)) {
        return SYSSET_OP_INVALID_PARAM;
    }
    
    // 从data_debugset获取值
    *value = (uint32_t)data_mgr_get_debugset_system_value(item_idx);
    
    return SYSSET_OP_SUCCESS;
}

/**
 * @brief 设置系统设置项的值
 * @note 该函数保留用于兼容，实际设置操作通过各专门函数完成
 */
sysset_op_result_t debugset_service_set_item_value(u8 item_idx, uint32_t value)
{
    (void)item_idx;
    (void)value;
    
    // 该模块的值无需保存，直接返回成功
    return SYSSET_OP_SUCCESS;
}

/**
 * @brief 检查设置项是否为开关类型（退出/投入）
 */
bool debugset_service_is_switch_type(u8 item_idx)
{
    return data_mgr_is_debugset_system_switch_type(item_idx);
}

/**
 * @brief 检查设置项是否为数值类型
 */
bool debugset_service_is_number_type(u8 item_idx)
{
    return data_mgr_is_debugset_system_number_type(item_idx);
}

/**
 * @brief 获取设置项的配置信息
 */
sysset_op_result_t debugset_service_get_item_config(u8 item_idx, const char **title, uint32_t *min, uint32_t *max)
{
    if (title == NULL || min == NULL || max == NULL || item_idx >= data_mgr_get_debugset_items_len(DEBUGSET_MENU_SYSTEM_SET)) {
        return SYSSET_OP_INVALID_PARAM;
    }
    
    // 从data_debugset获取名称
    *title = data_mgr_get_debugset_system_name(item_idx);
    
    // 从data_debugset获取配置参数
    uint8_t point, numeric_opt;
    if (!data_mgr_get_debugset_system_config(item_idx, min, max, &point, &numeric_opt)) {
        return SYSSET_OP_FAILED;
    }
    
    return SYSSET_OP_SUCCESS;
}

// ==================== UI数据组装接口实现 ====================
// 注意：所有选项数据已从service层迁移至data层统一管理
// 数据流向：data_debugset.c -> data_manager.c -> service_debugset.c
// 如需修改选项内容，请修改 data_debugset.c 中的静态数据定义

/**
 * @brief 获取开关类型选项列表
 * @note 通过data_manager从data层获取选项数据
 */
sysset_op_result_t debugset_service_get_switch_options(const UiSetOption **options, uint8_t *count)
{
    if (options == NULL || count == NULL) {
        return SYSSET_OP_INVALID_PARAM;
    }

    // 从data层直接获取选项数据（类型转换：SET_LIST和UiSetOption结构兼容）
    if (!data_debugset_get_switch_options((const SET_LIST **)options, count)) {
        return SYSSET_OP_FAILED;
    }

    return SYSSET_OP_SUCCESS;
}

/**
 * @brief 创建设置项的UI配置
 * @param item_idx 设置项索引
 * @param set_opt 输出配置结构体
 * @return 操作结果
 * @note 此函数将UI数据组装逻辑从app层迁移到service层，符合分层架构设计
 */
sysset_op_result_t debugset_service_create_ui_config(u8 item_idx, UiSetValueOptDef *set_opt)
{
    if (set_opt == NULL || item_idx >= data_mgr_get_debugset_items_len(DEBUGSET_MENU_SYSTEM_SET)) {
        return SYSSET_OP_INVALID_PARAM;
    }

    const char *title = NULL;
    uint32_t min_val = 0, max_val = 0;
    uint32_t curr_val = 0;
    sysset_op_result_t result;

    // 获取设置项配置
    result = debugset_service_get_item_config(item_idx, &title, &min_val, &max_val);
    if (result != SYSSET_OP_SUCCESS) {
        return result;
    }

    result = debugset_service_get_item_value(item_idx, &curr_val);
    if (result != SYSSET_OP_SUCCESS) {
        return result;
    }

    memset(set_opt, 0, sizeof(UiSetValueOptDef));
    set_opt->title = title;
    set_opt->curr_value = (float)curr_val;
    set_opt->max_value = (float)max_val;
    set_opt->min_value = (float)min_val;
    set_opt->step = 1.0f;
    set_opt->decimal_digit = 0;
    set_opt->unit = "";

    // 根据设置项类型配置
    if (debugset_service_is_switch_type(item_idx))
    {
        // 开关类型（退出/投入）- 从data层获取选项数据
        set_opt->set_str = DEBUGSET_STR_SET_SELECT;
        set_opt->type = UISETOPT_TYPE_LIST;
        // 通过data_manager获取选项列表指针和数量（类型转换：SET_LIST和UiSetOption结构兼容）
        data_debugset_get_switch_options((const SET_LIST **)&set_opt->opt_list, &set_opt->opt_list_num);
    }
    else if (item_idx == SYSSET_ITEM_PASSWORD)
    {
        // 密码设置 - 从data层获取范围
        uint16_t pwd_min, pwd_max;
        set_opt->set_str = DEBUGSET_STR_SET_VALUE;
        set_opt->type = UISETOPT_TYPE_NUMBER;
        if (data_mgr_get_password_config(&pwd_min, &pwd_max, NULL)) {
            set_opt->max_value = (float)pwd_max;
            set_opt->min_value = (float)pwd_min;
        }
    }
    else
    {
        // 数值类型（背光时间等）
        set_opt->set_str = DEBUGSET_STR_SET_VALUE;
        set_opt->type = UISETOPT_TYPE_NUMBER;
    }

    return SYSSET_OP_SUCCESS;
}
