#include "data_debugset.h"
#include "data_real_time.h"
#include <sys/sysinfo.h>
#include <sys/time.h>
#include <time.h>
#include "head.h"
#include "bsp_boardcheck.h"

/* ==================================================================================================================== */
/* 配置索引定义 - 对应s_system_items数组的索引 */
/* ==================================================================================================================== */

typedef enum {
    CFG_IDX_FACTORY_RESET = 0,   // 恢复出厂设置
    CFG_IDX_CLEAR_HISTORY,       // 清除历史记录
    CFG_IDX_CLEAR_ENERGY,        // 电度清除
    CFG_IDX_DATETIME,            // 系统时间设置
    CFG_IDX_PASSWORD,            // 密码设置
    CFG_IDX_CALIBRATION,         // 系数校准
    CFG_IDX_BACKLIGHT,           // 背光时间设置
    CFG_IDX_MAX
} config_index_t;

/* ==================================================================================================================== */
/* 状态信息项索引定义 - 对应s_status_items数组的索引 */
/* ==================================================================================================================== */

typedef enum {
    STATUS_IDX_DI_SELFTEST = 0,  // 开入量自检
    STATUS_IDX_DO_SELFTEST,      // 开出量自检
    STATUS_IDX_ADC_SELFTEST,     // ADC自检
    STATUS_IDX_RUN_STATE,        // 运行状态
    STATUS_IDX_RUN_TIME_CUR,     // 本次运行时间
    STATUS_IDX_RUN_TIME_TOTAL,   // 累计运行时长
    STATUS_IDX_RAM_REMAIN,       // 内存剩余
    STATUS_IDX_FLASH_REMAIN,     // Flash剩余
    STATUS_IDX_MAX
} status_index_t;

/* ==================================================================================================================== */
/* 常量定义 - 集中管理所有魔法数字 */
/* ==================================================================================================================== */

// 缓存超时时间（毫秒）
#define CACHE_TIMEOUT_MS                    2000

// 状态自检默认值
#define STATUS_SELFTEST_OK_DEFAULT          1.0f    // 自检正常默认值
#define STATUS_SELFTEST_MIN                 1       // 自检最小值
#define STATUS_SELFTEST_MAX                 1       // 自检最大值

// 运行状态默认值
#define STATUS_RUN_STATE_MIN                0       // 运行状态最小值
#define STATUS_RUN_STATE_MAX                1       // 运行状态最大值
#define STATUS_RUN_STATE_DEFAULT            1.0f    // 运行状态默认值

// 运行时间默认值（分钟）
#define STATUS_RUN_TIME_MIN                 0       // 运行时间最小值
#define STATUS_RUN_TIME_MAX                 65535   // 运行时间最大值
#define STATUS_RUN_TIME_CUR_DEFAULT         1500.0f // 本次运行时间默认值
#define STATUS_RUN_TIME_TOTAL_DEFAULT       100.0f  // 累计运行时间默认值

// 内存/Flash剩余默认值
#define STATUS_STORAGE_MIN                  0       // 存储最小值
#define STATUS_STORAGE_MAX                  65535   // 存储最大值
#define STATUS_RAM_REMAIN_DEFAULT           100.0f  // 内存剩余默认值(%)
#define STATUS_FLASH_REMAIN_DEFAULT         90.0f   // Flash剩余默认值(%)

// 系统设置默认值
#define SYSSET_SWITCH_MIN                   1       // 开关类型最小值
#define SYSSET_SWITCH_MAX                   1       // 开关类型最大值
#define SYSSET_SWITCH_DEFAULT               1.0f    // 开关类型默认值

// 密码设置配置
#define PASSWORD_MIN                        0       // 密码最小值
#define PASSWORD_MAX                        9999    // 密码最大值
#define PASSWORD_DEFAULT                    0.0f    // 密码默认值

// 背光时间配置
#define BACKLIGHT_UNIT                      "s"     // 背光时间单位
#define BACKLIGHT_MIN                       0       // 背光时间最小值(秒)
#define BACKLIGHT_MAX                       65536   // 背光时间最大值(秒)
#define BACKLIGHT_DEFAULT                   180.0f  // 背光时间默认值(秒)

// 时间转换常量
#define RTC_YEAR_BASE                       2000    // RTC年份基准值
#define MS_PER_SECOND                       1000    // 每秒毫秒数

// 百分比计算常量
#define PERCENT_DIVISOR                     100     // 百分比除数
#define PERCENT_MAX_VALID                   100     // 百分比最大值

/* ==================================================================================================================== */
/* 数据结构定义 - 整合配置和运行时数据 */
/* ==================================================================================================================== */

typedef struct {
    const char *name;
    const char *unit;
    uint32_t    min;
    uint32_t    max;
    uint8_t     point;
    uint8_t     numeric_opt;
    float       curr_value;
    float       bak_value;
} debugset_item_t;

/* ==================================================================================================================== */
/* 状态信息数据定义 */
/* ==================================================================================================================== */

static debugset_item_t s_status_items[] = {
    // 名称               单位  最小值              最大值              小数位  选项类型        当前值                      备份值
    {"开入量自检      ", " ",  STATUS_SELFTEST_MIN, STATUS_SELFTEST_MAX, 0,      OPT_ERRSTATE,   STATUS_SELFTEST_OK_DEFAULT, STATUS_SELFTEST_OK_DEFAULT},
    {"开出量自检      ", " ",  STATUS_SELFTEST_MIN, STATUS_SELFTEST_MAX, 0,      OPT_ERRSTATE,   STATUS_SELFTEST_OK_DEFAULT, STATUS_SELFTEST_OK_DEFAULT},
    {"ADC  自检       ", " ",  STATUS_SELFTEST_MIN, STATUS_SELFTEST_MAX, 0,      OPT_ERRSTATE,   STATUS_SELFTEST_OK_DEFAULT, STATUS_SELFTEST_OK_DEFAULT},
    {"运行状态        ", " ",  STATUS_RUN_STATE_MIN, STATUS_RUN_STATE_MAX, 0,     OPT_RUNSTATE,   STATUS_RUN_STATE_DEFAULT,   STATUS_RUN_STATE_DEFAULT},
    {"本次运行时间    ", " ",  STATUS_RUN_TIME_MIN, STATUS_RUN_TIME_MAX, 0,      OPT_SUBNON,     0.0f,                       0.0f},
    {"累计运行时长    ", " ",  STATUS_RUN_TIME_MIN, STATUS_RUN_TIME_MAX, 0,      OPT_SUBNON,     0.0f,                       0.0f},
    {"内存剩余        ", "%",  STATUS_STORAGE_MIN,  STATUS_STORAGE_MAX,  0,      OPT_SUBNON,     STATUS_RAM_REMAIN_DEFAULT,  STATUS_RAM_REMAIN_DEFAULT},
    {"Flash剩余       ", "%",  STATUS_STORAGE_MIN,  STATUS_STORAGE_MAX,  0,      OPT_SUBNON,     STATUS_FLASH_REMAIN_DEFAULT, STATUS_FLASH_REMAIN_DEFAULT},
};

static const uint8_t s_status_count = sizeof(s_status_items) / sizeof(s_status_items[0]);

/* ==================================================================================================================== */
/* 系统设置数据定义 - 密码和背光配置直接从此数组获取 */
/* ==================================================================================================================== */

static debugset_item_t s_system_items[] = {
    // 名称               单位  最小值              最大值              小数位  选项类型        当前值                      备份值
    {"恢复出厂设置     ", " ",  SYSSET_SWITCH_MIN,   SYSSET_SWITCH_MAX,   0,      OPT_SUBNON,     SYSSET_SWITCH_DEFAULT,      SYSSET_SWITCH_DEFAULT},
    {"清除历史记录      ", " ",  SYSSET_SWITCH_MIN,   SYSSET_SWITCH_MAX,   0,      OPT_SUBNON,     SYSSET_SWITCH_DEFAULT,      SYSSET_SWITCH_DEFAULT},
    {"电度清除              ", " ",  SYSSET_SWITCH_MIN,   SYSSET_SWITCH_MAX,   0,      OPT_SUBNON,     SYSSET_SWITCH_DEFAULT,      SYSSET_SWITCH_DEFAULT},
    {"系统时间设置       ", " ",  SYSSET_SWITCH_MIN,   SYSSET_SWITCH_MAX,   0,      OPT_SUBNON,     SYSSET_SWITCH_DEFAULT,      SYSSET_SWITCH_DEFAULT},
    {"密码设置               ", " ",  PASSWORD_MIN,        PASSWORD_MAX,        0,      OPT_SUBNON,     PASSWORD_DEFAULT,           PASSWORD_DEFAULT},
    {"系数校准               ", " ",  SYSSET_SWITCH_MIN,   SYSSET_SWITCH_MAX,   0,      OPT_SUBNON,     SYSSET_SWITCH_DEFAULT,      SYSSET_SWITCH_DEFAULT},
    {"背光时间设置       ", BACKLIGHT_UNIT, BACKLIGHT_MIN, BACKLIGHT_MAX, 0,      OPT_SUBNON,     BACKLIGHT_DEFAULT,          BACKLIGHT_DEFAULT},
};

static const uint8_t s_system_count = sizeof(s_system_items) / sizeof(s_system_items[0]);

/* ==================================================================================================================== */
/* 兼容层数据 - 直接映射到t_datafixval_cfg结构 */
/* ==================================================================================================================== */

static t_datafixval_cfg s_status_compat[sizeof(s_status_items) / sizeof(s_status_items[0])];
static t_datafixval_cfg s_system_compat[sizeof(s_system_items) / sizeof(s_system_items[0])];

/* 工厂调试菜单总表 */
t_datafixval_cfg_total gst_debugset_val[] = {
    {s_status_compat, sizeof(s_status_items) / sizeof(s_status_items[0]), "状态信息  "},
    {s_system_compat, sizeof(s_system_items) / sizeof(s_system_items[0]), "系统设置  "},
};
const uint8_t guc_menu_debugset_num = sizeof(gst_debugset_val) / sizeof(gst_debugset_val[0]);

/* ==================================================================================================================== */
/* 内存缓存 */
/* ==================================================================================================================== */

static uint32_t s_ram_surplus_percent = 0;
static struct timeval s_last_check_time = {0};

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

static void update_compat_layer(void)
{
    uint8_t i;

    for (i = 0; i < s_status_count; i++) {
        s_status_compat[i].us_addr = i;
        s_status_compat[i].uc_type = RMT_GRP_CSSET;
        s_status_compat[i].f_val_set = s_status_items[i].curr_value;
        s_status_compat[i].f_val_bak = s_status_items[i].bak_value;
        s_status_compat[i].f_val_step = 1.0f;
    }

    for (i = 0; i < s_system_count; i++) {
        s_system_compat[i].us_addr = i;
        s_system_compat[i].uc_type = RMT_GRP_CSSET;
        s_system_compat[i].f_val_set = s_system_items[i].curr_value;
        s_system_compat[i].f_val_bak = s_system_items[i].bak_value;
        s_system_compat[i].f_val_step = 1.0f;
    }
}

static uint32_t get_ram_surpercent(void)
{
    struct sysinfo info;
    struct timeval current_time;
    uint32_t percent = 0;

    gettimeofday(&current_time, NULL);

    if (s_last_check_time.tv_sec != 0) {
        long elapsed_ms = (current_time.tv_sec - s_last_check_time.tv_sec) * 1000 +
                         (current_time.tv_usec - s_last_check_time.tv_usec) / 1000;
        if (elapsed_ms < CACHE_TIMEOUT_MS) {
            return s_ram_surplus_percent;
        }
    }

    if (sysinfo(&info) != 0) {
        return 0;
    }

    if (info.totalram > 0) {
        percent = (uint32_t)(((uint64_t)info.freeram * PERCENT_DIVISOR) / info.totalram);
    }

    if (percent > PERCENT_MAX_VALID) {
        log_str_time(LOG_ERR, "内存错误", 1, 1);
        percent = 0;
    }

    s_ram_surplus_percent = percent;
    s_last_check_time = current_time;

    return percent;
}

static uint32_t get_run_status(void)
{
    return (uint32_t)STATUS_RUN_STATE_DEFAULT;
}

static uint32_t get_flash_surplus(void)
{
    return (uint32_t)STATUS_FLASH_REMAIN_DEFAULT;
}

static uint32_t get_time_backlight(void)
{
    // printf("%s: Getting backlight time : %d  ...\n", __FUNCTION__ , tRunPara.dLightTime);
    return tRunPara.dLightTime / SAM_FREQUENCY;
}

static uint32_t get_run_time_cur(void)
{
    return rsio_get_this_runtime() ; // 转换为分钟
}

static uint32_t get_run_time_total(void)
{
    return rsio_get_total_runtime() ; // 转换为分钟
}

// 板卡自检状态缓存
#define BOARD_MAX   3                                // 板卡数量：BOARD_DI, BOARD_AC, BOARD_DO
static uint8_t  s_board_status[BOARD_MAX] = {0};     // 状态缓存
static uint32_t s_board_last_tick = 0;              // 上次读取时间戳(毫秒)
#define BOARD_READ_INTERVAL_MS  2000                // 读取间隔2秒

// 获取当前系统时间戳(毫秒)
static uint32_t get_current_ms(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return (uint32_t)(tv.tv_sec * 1000 + tv.tv_usec / 1000);
}

/****************************************************************************
 * 作    者:
 * 修    改：
 * 名    称：get_board_selftest_status
 * 功    能：获取板卡自检状态（带2秒缓存）
 * 入口参数：board_type: 板卡类型 (BOARD_DI/BOARD_DO/BOARD_AC)
 * 出口参数：无
 * 返 回 值：1 - 自检正常, 0 - 自检异常或参数错误
 * 备    注：2秒内重复调用直接返回缓存值，避免高频访问bap_get_board_state
 ***************************************************************************/
static uint8_t get_board_selftest_status(uint8_t board_type)
{
    uint32_t current_tick = get_current_ms();
    
    // 超过2秒才重新读取
    if ((current_tick - s_board_last_tick) >= BOARD_READ_INTERVAL_MS) {
        s_board_status[BOARD_DI]  = (bap_get_board_state(BOARD_DI)  == 1) ? 1 : 0;
        s_board_status[BOARD_DO]  = (bap_get_board_state(BOARD_DO)  == 1) ? 1 : 0;
        s_board_status[BOARD_AC]  = (bap_get_board_state(BOARD_AC)  == 1) ? 1 : 0;
        s_board_last_tick = current_tick;
    }
    
    if (board_type < BOARD_MAX) {
        return s_board_status[board_type];
    }
    return 0;
}

/* ==================================================================================================================== */
/* 菜单名称获取接口 */
/* ==================================================================================================================== */

const char* data_debugset_get_menu_name(uint8_t menu_idx)
{
    if (menu_idx >= guc_menu_debugset_num) {
        return NULL;
    }
    return gst_debugset_val[menu_idx].des;
}

/* ==================================================================================================================== */
/* 状态信息数据获取接口 */
/* ==================================================================================================================== */

float data_debugset_get_status_value(uint8_t item_idx)
{
    if (item_idx >= s_status_count) {
        return 0.0f;
    }
    return s_status_items[item_idx].curr_value;
}

const char* data_debugset_get_status_name(uint8_t item_idx)
{
    if (item_idx >= s_status_count) {
        return NULL;
    }
    return s_status_items[item_idx].name;
}

const char* data_debugset_get_status_unit(uint8_t item_idx)
{
    if (item_idx >= s_status_count) {
        return "";
    }
    return s_status_items[item_idx].unit;
}

uint8_t data_debugset_get_status_item_count(void)
{
    return s_status_count;
}

/* ==================================================================================================================== */
/* 系统设置数据获取接口 */
/* ==================================================================================================================== */

float data_debugset_get_system_value(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return 0.0f;
    }
    return s_system_items[item_idx].curr_value;
}

const char* data_debugset_get_system_name(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return NULL;
    }
    return s_system_items[item_idx].name;
}

const char* data_debugset_get_system_unit(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return "";
    }
    return s_system_items[item_idx].unit;
}

uint32_t data_debugset_get_system_min(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return 0;
    }
    return s_system_items[item_idx].min;
}

uint32_t data_debugset_get_system_max(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return 0;
    }
    return s_system_items[item_idx].max;
}

uint8_t data_debugset_get_system_point(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return 0;
    }
    return s_system_items[item_idx].point;
}

uint8_t data_debugset_get_system_numeric_opt(uint8_t item_idx)
{
    if (item_idx >= s_system_count) {
        return 0;
    }
    return s_system_items[item_idx].numeric_opt;
}

uint8_t data_debugset_get_system_item_count(void)
{
    return s_system_count;
}

//TODO 考虑后续是否删除
bool data_debugset_is_system_switch_type(uint8_t item_idx)
{
    // 前三个设置项已改为确认对话框模式，不再是开关类型
    (void)item_idx;
    return false;
}

bool data_debugset_is_system_number_type(uint8_t item_idx)
{
    return (item_idx == CFG_IDX_BACKLIGHT);
}

/* ==================================================================================================================== */
/* 系统设置功能函数 */
/* ==================================================================================================================== */

/**
 * @brief 执行恢复出厂设置功能
 * @return true-成功, false-失败
 */
bool data_debugset_execute_factory_reset(void)
{
    // TODO: 实现 恢复出厂设置 功能逻辑
    init_default_equip_set(1);
    log_str_time(LOG_OPERATE, "液晶屏恢复出厂设置", 0, 0);
    printf("%s: Executing factory reset...\n", __FUNCTION__);
    return true;
}

/**
 * @brief 执行清除历史记录功能
 * @return true-成功, false-失败
 */
bool data_debugset_execute_clear_history(void)
{
    // TODO: 实现 清除历史记录 功能逻辑

    // 1. 清除操作记录
    soe_clear_opt();
    soe_record_opt(EV_CLEAR_OPE, 0);

    // 2. 清除事件记录
    soe_clear_ev();
    soe_record_opt(EV_CLEAR_SOE, 0);
    
    printf("%s: Clearing history records...\n", __FUNCTION__);
    return true;
}

/**
 * @brief 执行电度清除功能
 * @return true-成功, false-失败
 */
bool data_debugset_execute_clear_energy(void)
{
    // TODO: 实现 电度清除 功能逻辑
    // 1. 清除正向有功电度
    // 2. 清除反向有功电度
    // 3. 清除正向无功电度
    // 4. 清除反向无功电度
    printf("%s: Clearing energy data...\n", __FUNCTION__);
    return true;
}

/**
 * @brief 设置系统时间
 * @param year 年 (2000-2099)
 * @param month 月 (1-12)
 * @param day 日 (1-31)
 * @param hour 时 (0-23)
 * @param min 分 (0-59)
 * @param sec 秒 (0-59)
 * @return true-成功, false-失败
 */
bool data_debugset_set_datetime(uint16_t year, uint8_t month, uint8_t day,
                                 uint8_t hour, uint8_t min, uint8_t sec)
{
    struct rtc_time_t t_rtc;

    // 验证时间参数有效性
    if (year < 2000 || year > 2099) {
        printf("%s: Invalid year: %d\n", __FUNCTION__, year);
        return false;
    }
    if (month < 1 || month > 12) {
        printf("%s: Invalid month: %d\n", __FUNCTION__, month);
        return false;
    }
    if (day < 1 || day > 31) {
        printf("%s: Invalid day: %d\n", __FUNCTION__, day);
        return false;
    }
    if (hour > 23) {
        printf("%s: Invalid hour: %d\n", __FUNCTION__, hour);
        return false;
    }
    if (min > 59) {
        printf("%s: Invalid minute: %d\n", __FUNCTION__, min);
        return false;
    }
    if (sec > 59) {
        printf("%s: Invalid second: %d\n", __FUNCTION__, sec);
        return false;
    }

    // 填充rtc_time_t结构
    t_rtc.year = year - RTC_YEAR_BASE;  // 转换为以2000年为起点的年份(0-99)
    t_rtc.month = month;                 // 1-12
    t_rtc.day = day;                     // 1-31
    t_rtc.hour = hour;                   // 0-23
    t_rtc.min = min;                     // 0-59
    t_rtc.ms = sec * MS_PER_SECOND;      // 秒转换为毫秒(0-59000)

    printf("%s: Setting datetime to %04d-%02d-%02d %02d:%02d:%02d\n", __FUNCTION__,
           year, month, day, hour, min, sec);

    // 设置系统时间
    if (sys_time_set(&t_rtc) != 0) {
        printf("%s: Failed to set system time\n", __FUNCTION__);
        return false;
    }

    printf("%s: System time set successfully\n", __FUNCTION__);
    return true;
}

/**
 * @brief 设置系统密码
 * @param password 密码 (0-9999)
 * @return true-成功, false-失败
 */
bool data_debugset_set_password(uint16_t password)
{
    // TODO: 实现 设置系统密码 功能逻辑
    // 1. 验证密码范围
    // 2. 保存密码到非易失性存储器
    Password_opt[2].value = password;
    //printf("%s: Setting password to %04d\n", __FUNCTION__, password);
    printf("%s: Setting password \n", __FUNCTION__);
    return true;
}

/**
 * @brief 执行系数校准
 * @return true-成功, false-失败
 */
bool data_debugset_execute_calibration(void)
{
    // TODO: 实现 系数校准 功能逻辑
    // 1. 执行ADC校准
    // 2. 执行电压系数校准
    // 3. 执行电流系数校准
    int ret;
    ret = sw_auto_adjust(-1);
    if (ret == 0)
    {
        log_str_time(LOG_OPERATE, "交流校准成功", 0, 0);
        printf("%s: 交流校准成功...\n", __FUNCTION__);
    }
    else
    {
        log_str_time(LOG_OPERATE, "交流校准失败", 0, 0);
        printf("%s: 交流校准失败...\n", __FUNCTION__);
    }
    
    return true;
}

/**
 * @brief 设置背光时间
 * @param time 背光时间 (秒)
 * @return true-成功, false-失败
 */
bool data_debugset_set_backlight_time(uint32_t time)
{
    // TODO: 实现 设置背光时间 功能逻辑
    // 1. 验证时间范围
    // 2. 保存背光时间配置
    // 3. 应用新的背光时间
    printf("%s: Setting backlight time to %lu seconds\n", __FUNCTION__, time);
    
    // 更新本地缓存值
    if (time <= s_system_items[CFG_IDX_BACKLIGHT].max) {
        s_system_items[CFG_IDX_BACKLIGHT].curr_value = (float)time;
        s_system_items[CFG_IDX_BACKLIGHT].bak_value = (float)time;
        update_compat_layer();
        return true;
    }
    return false;
}

/* ==================================================================================================================== */
/* 数据更新接口 */
/* ==================================================================================================================== */

void data_debugset_update_from_system(uint8_t _uc_type, const SET_VALUE *_pt_val)
{
    (void)_uc_type;
    (void)_pt_val;

    // 更新状态信息项 - 使用枚举索引替代硬编码数字
    // 从bsp_boardcheck.c的bap_get_board_state函数获取板卡自检状态
    // BOARD_DI(0): 开入量板卡, BOARD_DO(2): 开出量板卡, BOARD_AC(1): ADC/交流板卡
    s_status_items[STATUS_IDX_DI_SELFTEST].curr_value    = (float)get_board_selftest_status(BOARD_DI);
    s_status_items[STATUS_IDX_DO_SELFTEST].curr_value    = (float)get_board_selftest_status(BOARD_DO);
    s_status_items[STATUS_IDX_ADC_SELFTEST].curr_value   = (float)get_board_selftest_status(BOARD_AC);
    s_status_items[STATUS_IDX_RUN_STATE].curr_value      = (float)get_run_status();
    s_status_items[STATUS_IDX_RUN_TIME_CUR].curr_value   = (float)get_run_time_cur();
    s_status_items[STATUS_IDX_RUN_TIME_TOTAL].curr_value = (float)get_run_time_total();
    s_status_items[STATUS_IDX_RAM_REMAIN].curr_value     = (float)get_ram_surpercent();
    s_status_items[STATUS_IDX_FLASH_REMAIN].curr_value   = (float)get_flash_surplus();

    // 读取背光时间 - 使用配置索引
    s_system_items[CFG_IDX_BACKLIGHT].curr_value = (float)get_time_backlight();

    update_compat_layer();
}

void data_debugset_refresh_data(void)
{
    data_debugset_update_from_system(0, NULL);
}

/* ==================================================================================================================== */
/* 选项数据定义 */
/* ==================================================================================================================== */

static const SET_LIST s_switch_options[] = {
    {"退出", 0},
    {"投入", 1}
};

static const SET_LIST s_run_state_options[] = {
    {"停止", 0},
    {"运行", 1},
    {"故障", 2}
};

static const SET_LIST s_err_state_options[] = {
    {"Error", 0},
    {"OK", 1}
};

/* ==================================================================================================================== */
/* 菜单和配置数据接口 - 直接从s_system_items数组获取配置 */
/* ==================================================================================================================== */

uint8_t data_debugset_get_menu_count(void)
{
    return guc_menu_debugset_num;
}

bool data_debugset_get_password_config(uint16_t *min, uint16_t *max, uint16_t *default_val)
{
    if (min == NULL || max == NULL || default_val == NULL) {
        return false;
    }

    // 直接从s_system_items数组获取密码配置
    *min = (uint16_t)s_system_items[CFG_IDX_PASSWORD].min;
    *max = (uint16_t)s_system_items[CFG_IDX_PASSWORD].max;
    *default_val = (uint16_t)s_system_items[CFG_IDX_PASSWORD].curr_value;

    return true;
}

bool data_debugset_get_backlight_config(uint32_t *min, uint32_t *max, uint32_t *default_val)
{
    if (min == NULL || max == NULL || default_val == NULL) {
        return false;
    }

    // 直接从s_system_items数组获取背光配置
    *min = s_system_items[CFG_IDX_BACKLIGHT].min;
    *max = s_system_items[CFG_IDX_BACKLIGHT].max;
    *default_val = (uint32_t)s_system_items[CFG_IDX_BACKLIGHT].curr_value;

    return true;
}

bool data_debugset_get_datetime_default(uint16_t *year, uint8_t *month, uint8_t *day,
                                         uint8_t *hour, uint8_t *min, uint8_t *sec)
{
    if (year == NULL || month == NULL || day == NULL ||
        hour == NULL || min == NULL || sec == NULL) {
        return false;
    }

    // 直接使用系统当前时间
    time_t now = time(NULL);
    struct tm *tm_info = localtime(&now);
    
    if (tm_info != NULL) {
        *year = tm_info->tm_year + 1900;
        *month = tm_info->tm_mon + 1;
        *day = tm_info->tm_mday;
        *hour = tm_info->tm_hour;
        *min = tm_info->tm_min;
        *sec = tm_info->tm_sec;
        return true;
    }

    // 备用：使用固定默认值（如果系统时间获取失败）
    *year = 2026;
    *month = 1;
    *day = 1;
    *hour = 0;
    *min = 0;
    *sec = 0;

    return true;
}

/* ==================================================================================================================== */
/* 选项数据接口 */
/* ==================================================================================================================== */

bool data_debugset_get_switch_options(const SET_LIST **options, uint8_t *count)
{
    if (options == NULL || count == NULL) {
        return false;
    }

    *options = s_switch_options;
    *count = sizeof(s_switch_options) / sizeof(s_switch_options[0]);
    return true;
}

bool data_debugset_get_run_state_options(const SET_LIST **options, uint8_t *count)
{
    if (options == NULL || count == NULL) {
        return false;
    }

    *options = s_run_state_options;
    *count = sizeof(s_run_state_options) / sizeof(s_run_state_options[0]);
    return true;
}

bool data_debugset_get_err_state_options(const SET_LIST **options, uint8_t *count)
{
    if (options == NULL || count == NULL) {
        return false;
    }

    *options = s_err_state_options;
    *count = sizeof(s_err_state_options) / sizeof(s_err_state_options[0]);
    return true;
}
