#include "data_manager.h"
// #include "set.h"
#include "data_real_time.h"
#include "data_telemet_common.h"
// #include "switch.h"
#include "service/service_debugset.h"

const TSETTABLE* data_mgr_get_fixvaldes_struct(t_datafixval_cfg* p_cfg)
{
    // 安全检查：防止空指针（理论上不会发生）
    if (p_cfg == NULL)
    {
        return NULL;
    }

    // 2. 根据定值分组类型（uc_type），选择对应的描述表
    uint16_t addr = p_cfg->us_addr;
    uint8_t grp_type = p_cfg->uc_type; // 实际为 RMT_GRP_XXX 枚举值

    const TSETTABLE *p_table = NULL;
    int table_size = 0;

    switch (grp_type)
    {
        /* 公共定值表 */
        case RMT_GRP_PUSET:
            p_table = tPubSetTable;
            table_size = PUB_SET_NUMBER;
            break;

        /* 开关保护定值表 */
        case RMT_GRP_SWSET:
            p_table = tSwSetTable;
            table_size = SW_SET_NUMBER;
            break;

        /* 装置参数表 */
        case RMT_GRP_EQSET:
            p_table = tEquipParaTable;
            table_size = EQUIP_PARA_NUMBER;
            break;

        /* 内部定值表 */
        case RMT_GRP_CSSET:
            p_table = tCstSetTable;
            table_size = CSTSET_NUMBER;
            break;

        default:
            return NULL; // 无效的定值分组类型
    }

    // 3. 地址越界检查：确保 us_addr 在所选表的有效范围内
    if (addr >= (uint16_t)table_size)
    {
        return NULL;
    }

    // 4. 返回对应定值项的描述结构
    return &p_table[addr];
}


uint16_t data_mgr_get_module_cfg_total(DataModule module, t_datafixval_cfg_total **pp_cfg)
{
    /* 参数有效性检查 */
    if (module < MODULE_DEV_SET || module >= MODULE_END)
    {
        printf("%s: Invalid module %d\n", __FUNCTION__, module);
        if (pp_cfg != NULL) {
            *pp_cfg = NULL;
        }
        return 0;
    }

    /* 使用表驱动方式，提高代码可读性和维护性 */
    switch (module)
    {
    case MODULE_DEV_SET:
        *pp_cfg = gst_dev_set_val;
        return gst_dev_set_num;
        
    case MODULE_DEV_SET_SHOW:
        *pp_cfg = gst_usr_dev_set_val;
        return gst_usr_dev_set_val_num;
        
    case MODULE_DEV_FIX:
        *pp_cfg = gst_val;
        return guc_menu_fv_num;
        
    case MODULE_DEV_FIX_SHOW:
        *pp_cfg = gst_usr_fix_val;
        return gst_usr_fix_val_num;
        
    default:
        *pp_cfg = NULL;
        return 0;
    }
}



uint16_t data_mgr_get_menu_len_by_module(DataModule module)
{
    switch (module)
    {
    case MODULE_DEV_SET:
        return gst_dev_set_num;
        
    case MODULE_DEV_SET_SHOW:
        return gst_usr_dev_set_val_num;
        
    case MODULE_DEV_FIX:
        return guc_menu_fv_num;
        
    case MODULE_DEV_FIX_SHOW:
        return gst_usr_fix_val_num;
        
    default:
        return 0;
    }
}

/**
 * @brief  判断菜单功能是否投入
 * @param  module   模块类型（定值整定/定值查看）
 * @param  menu_id  菜单索引
 * @return data_bool_t     true: 投入; false: 未投入/无效
 * @date 2026-02-05
 */
data_bool_t data_mgr_is_menu_func_enabled(DataModule module, uint8_t menu_id)
{
    uint16_t menu_len = data_mgr_get_menu_len_by_module(module);
    const TSETSW *sw_set = NULL;

    if (menu_len == 0 || menu_id >= menu_len)
    {
        return false;
    }

    if (pRunSet == NULL)
    {
        return false;
    }

    sw_set = &pRunSet->tSwSet[0];

    switch (module)
    {
    case MODULE_DEV_FIX:
        switch (menu_id)
        {
        case FIX_MENU_CG:   // 常规保护
            return sw_set->btt_gnyb_cg;
        case FIX_MENU_CHZ:  // 重合闸
            return sw_set->btt_gnyb_zdchz;
        case FIX_MENU_FA:   // 常规FA
            return sw_set->btt_gnyb_fa;
        case FIX_MENU_DFA:  // 智能分布式
            return sw_set->btt_gnyb_dfa;
        case FIX_MENU_TQHZ: // 同期合闸
            return sw_set->btt_gnyb_tqhz;
        case FIX_MENU_ZDJL: // 自动解列
            return sw_set->btt_gnyb_zdjl;
        case FIX_MENU_XLDXGJ: // 线路告警
            return sw_set->btt_gnyb_xldxgj;
        case FIX_MENU_XDLD: // 小电流接地
            return sw_set->btt_gnyb_xdljd;
        case FIX_MENU_BTCD: // 传动开关
            return sw_set->btt_gnyb_btdcd;
        default:
            return true;
        }

    case MODULE_DEV_FIX_SHOW:
        switch (menu_id)
        {
        case FIX_SHOW_MENU_CG:   // 常规保护
            return sw_set->btt_gnyb_cg;
        case FIX_SHOW_MENU_CHZ:  // 重合闸
            return sw_set->btt_gnyb_zdchz;
        case FIX_SHOW_MENU_FA:   // 常规FA
            return sw_set->btt_gnyb_fa;
        case FIX_SHOW_MENU_DFA:  // 智能分布式
            return sw_set->btt_gnyb_dfa;
        case FIX_SHOW_MENU_TQHZ: // 同期合闸
            return sw_set->btt_gnyb_tqhz;
        case FIX_SHOW_MENU_ZDJL: // 自动解列
            return sw_set->btt_gnyb_zdjl;
        case FIX_SHOW_MENU_XDLD: // 小电流接地
            return sw_set->btt_gnyb_xdljd;
        case FIX_SHOW_MENU_XLDXGJ: // 线路告警
            return sw_set->btt_gnyb_xldxgj;
        case FIX_SHOW_MENU_BTCD: // 传动开关
            return sw_set->btt_gnyb_btdcd;
        default:
            return true;
        }

    default:
        return true;
    }
}

/**
 * @brief  获取数据数组长度
 * @param  module           模块
 * @param  menu_sel_idx     左侧选中ID
 * @return uint16_t 
 * @date 2026-01-29
 */
uint16_t data_mgr_get_items_len_by_module(DataModule module , u8 menu_sel_idx)
{
    const t_datafixval_cfg_total *p_cfg = NULL;
    data_mgr_get_module_cfg_total(module, &p_cfg);

    uint16_t itemsize = p_cfg[menu_sel_idx].us_val;

    return itemsize;
}


/**
 * @brief           从系统之中获取数据到菜单结构之中
 * @param[in/out]  {uint8_t} _uc_type 传进来的类型 0公共定值 1开关定值、2装置参数 3内部定值
 * @param[in/out]  {const SET_VALUE} * _pt_val 数据指针
 * @return         * void 
 * @retval         
 * 
 * @warning        
 * @note           
 */
extern void data_mgr_get_data_from_system(uint8_t _uc_type , const SET_VALUE * _pt_val)
{
    printf("%s type = %d ,pointer = %p\n", __FUNCTION__ , _uc_type , _pt_val);
    //分别更新到对应数组内
    data_sys_update_from_system(_uc_type , _pt_val);
    data_usr_update_from_system(_uc_type , _pt_val);
}

//TODO 后续优化
data_bool_t data_mgr_check_diff(void)
{
    // 检查系统数据差异
    if (data_sys_check_diff())
    {
        return true;
    }
    
    // 检查用户数据差异
    if (data_usr_check_diff())
    {
        return true;
    }
    
    return false;
}

/**
 * @brief           修改菜单数据
 * @param[in]       module: 模块类型，如MODULE_DEV_SET、MODULE_DEV_FIX等
 * @param[in]       menu_id: 菜单ID，对应具体的菜单索引
 * @param[in]       data_id: 数据ID，对应菜单中的具体数据项索引
 * @param[in]       value: 要设置的新值
 * @return          data_bool_t: 修改成功返回true，失败返回false
 * @date            2026-02-02
 */
data_bool_t data_mgr_modify_menu_data(DataModule module, uint8_t menu_id, uint8_t data_id, float value)
{
    // 1. 参数有效性检查
    if (module < MODULE_DEV_SET || module >= MODULE_END)
    {
        printf("%s: Invalid module %d\n", __FUNCTION__, module);
        return false;
    }
    
    // 获取模块对应的配置信息
    t_datafixval_cfg_total *p_cfg = NULL;
    uint16_t module_size = data_mgr_get_module_cfg_total(module, &p_cfg);
       
    
    if (p_cfg == NULL || module_size == 0)
    {
        printf("%s: Invalid module configuration\n", __FUNCTION__);
        return false;
    }
    
    // 检查menu_id是否有效
    if (menu_id >= module_size)
    {
        printf("%s: Invalid menu_id %d for module %d\n", __FUNCTION__, menu_id, module);
        return false;
    }
    
    // 检查data_id是否有效
    if (data_id >= p_cfg[menu_id].us_val)
    {
        printf("%s: Invalid data_id %d for menu %d\n", __FUNCTION__, data_id, menu_id);
        return false;
    }
    
    // 获取当前修改的数据项
    t_datafixval_cfg *p_data = &(p_cfg[menu_id].fs[data_id]);
    
    // 检查是否为"不停电传动投入"软压板，设置为只读
    if (p_data->us_addr == SET_TRASW_YB)
    {
        printf("%s: SET_TRASW_YB is read-only\n", __FUNCTION__);
        return false;
    }
    
    // 检查是否为互斥软压板之一
    data_bool_t is_mutex_switch = false;
    uint16_t mutex_switches[] = {SET_BH_YBTT, SET_CHZ_YB, SET_FA_YBTT, SET_GOOSE_YBTT};
    int mutex_count = sizeof(mutex_switches) / sizeof(mutex_switches[0]);
    
    for (int i = 0; i < mutex_count; i++)
    {
        if (p_data->us_addr == mutex_switches[i])
        {
            is_mutex_switch = true;
            break;
        }
    }
    
    // 2. 根据模块类型进行数据修改
    switch (module)
    {
        case MODULE_DEV_SET:  // 系统设备参数
        case MODULE_DEV_FIX:  // 系统定值整定数据
        {
            // 修改系统数据
            p_data->f_val_set = value;
            
            // 实现软压板互斥控制
            if (is_mutex_switch && value == 1.0f)
            {
                // 遍历所有功能软压板，将其他互斥软压板设置为0
                for (uint16_t i = 0; i < p_cfg[menu_id].us_val; i++)
                {
                    t_datafixval_cfg *p_other = &(p_cfg[menu_id].fs[i]);
                    for (int j = 0; j < mutex_count; j++)
                    {
                        if (p_other->us_addr == mutex_switches[j] && p_other->us_addr != p_data->us_addr)
                        {
                            p_other->f_val_set = 0.0f;
                            printf("%s: Set mutex switch %d to 0\n", __FUNCTION__, p_other->us_addr);
                        }
                    }
                }
            }
            
            break;
        }
        
        case MODULE_DEV_SET_SHOW:  // 用户设备参数查看
        case MODULE_DEV_FIX_SHOW:  // 用户定值查看数据
        {
            // 修改用户数据
            p_data->f_val_set = value;
            
            // 实锟斤拷锟斤拷压锟藉互锟斤拷锟斤拷锟?
            if (is_mutex_switch && value == 1.0f)
            {
                // 遍历所有功能软压板，将其他互斥软压板设置为0
                for (uint16_t i = 0; i < p_cfg[menu_id].us_val; i++)
                {
                    t_datafixval_cfg *p_other = &(p_cfg[menu_id].fs[i]);
                    for (int j = 0; j < mutex_count; j++)
                    {
                        if (p_other->us_addr == mutex_switches[j] && p_other->us_addr != p_data->us_addr)
                        {
                            p_other->f_val_set = 0.0f;
                            printf("%s: Set mutex switch %d to 0\n", __FUNCTION__, p_other->us_addr);
                        }
                    }
                }
            }
            break;
        }
        
        default:
            printf("%s: Unsupported module %d\n", __FUNCTION__, module);
            return false;
    }
    
    // 3. 修改成功
    printf("%s: Modified module %d, menu %d, data %d to value %.2f\n", 
           __FUNCTION__, module, menu_id, data_id, value);
    
    return true;
}

/**
 * @brief           修改菜单IP数据
 * @param[in]       module: 模块类型，如MODULE_DEV_SET、MODULE_DEV_FIX等
 * @param[in]       menu_id: 菜单ID，对应具体的菜单索引
 * @param[in]       data_id: 数据ID，对应菜单中的具体数据项索引
 * @param[in]       value: 要设置的新IP地址值
 * @return          data_bool_t: 修改成功返回true，失败返回false
 * @date            2026-02-05
 */
data_bool_t data_mgr_modify_menu_data_ip(DataModule module, uint8_t menu_id, uint8_t data_id, uint32_t value)
{
    // 1. 参数有效性检查
    if (module < MODULE_DEV_SET || module >= MODULE_END)
    {
        printf("%s: Invalid module %d\n", __FUNCTION__, module);
        return false;
    }

    // 获取模块对应的配置信息
    t_datafixval_cfg_total *p_cfg = NULL;
    uint16_t module_size = data_mgr_get_module_cfg_total(module, &p_cfg);

    if (p_cfg == NULL || module_size == 0)
    {
        printf("%s: Invalid module configuration\n", __FUNCTION__);
        return false;
    }

    // 检查menu_id是否有效
    if (menu_id >= module_size)
    {
        printf("%s: Invalid menu_id %d for module %d\n", __FUNCTION__, menu_id, module);
        return false;
    }

    // 检查data_id是否有效
    if (data_id >= p_cfg[menu_id].us_val)
    {
        printf("%s: Invalid data_id %d for menu %d\n", __FUNCTION__, data_id, menu_id);
        return false;
    }

    t_datafixval_cfg *p_data = &(p_cfg[menu_id].fs[data_id]);
    if (!is_special_ip_addr(p_data->us_addr))
    {
        printf("%s: data_id %d is not ip addr\n", __FUNCTION__, data_id);
        return false;
    }

    p_data->ul_val_set = value;

    printf("%s: Modified module %d, menu %d, data %d to ip 0x%lx\n",
           __FUNCTION__, module, menu_id, data_id, (unsigned long)value);

    return true;
}


E_FUN_MODE Get_DTU_Runmode(void)
{
    const TSETSW *sw_set = NULL;
    sw_set = &pRunSet->tSwSet[0];

#if (0) /* 肇庆菜单不要和保护总压板关联 20250221 lch */
    return funlogicio_get_workmode();
#else
    E_FUN_MODE e_funmode = WORKMODE_NONE;
    if (1 == sw_set->btt_gnyb_cg &&
        0 == sw_set->btt_gnyb_fa &&
        0 == sw_set->btt_gnyb_dfa)
    {
        e_funmode = WORKMODE_GEN;
    }
    if (0 == sw_set->btt_gnyb_cg &&
        1 == sw_set->btt_gnyb_fa &&
        0 == sw_set->btt_gnyb_dfa)
    {
        e_funmode = WORKMODE_FA;
    }
    if (0 == sw_set->btt_gnyb_cg &&
        0 == sw_set->btt_gnyb_fa &&
        1 == sw_set->btt_gnyb_dfa)
    {
        e_funmode = WORKMODE_DFA;
    }
    return e_funmode;
#endif
}



data_bool_t data_mgr_set_data_to_system(DataModule module)
{
    uint8_t uc_updata_equip = 0, uc_updata_sf = 0, uc_updata_cst = 0, uc_save_flag = 1, uc_updata_fixarea_flag = 0;
    uint16_t i = 0, j = 0;
    SET_VALUE *pt_buf = m_SetBuf;

        // 获取模块对应的配置信息
    t_datafixval_cfg_total *p_cfg = NULL;
    uint16_t module_size = data_mgr_get_module_cfg_total(module, &p_cfg);
       
    
    if (p_cfg == NULL || module_size == 0)
    {
        printf("%s: Invalid module configuration\n", __FUNCTION__);
        return false;
    }

    /* 读取装置参数 */
    if (!ReadPara((void *)pt_buf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0]))
    {
        rt_err_set(ERR_CODE_EQU_PARA, 0);
        GetDefPara((void *)pt_buf, EQUIP_PARA_NUMBER, &tEquipParaTable[0]);
    }

    for (i = 0; i < module_size; i++)
    {
        for (j = 0; j < p_cfg[i].us_val; j++)
        {
            t_datafixval_cfg *p_data = &(p_cfg[i].fs[j]);

            if(p_data->uc_type == RMT_GRP_EQSET)
            {
                // 特殊处理IP地址等长整型数据
                if(is_special_ip_addr(p_data->us_addr))
                {
                    pt_buf[p_data->us_addr].tt = (long)p_data->ul_val_set;
                    p_data->ul_val_bak = p_data->ul_val_set;
                    uc_updata_equip = 1;
                }
                else
                {
                    float f_abs_val = fabs(pt_buf[p_data->us_addr].ff - p_data->f_val_set);
                    if(f_abs_val >= p_data->f_val_step)
                    {
                        pt_buf[p_data->us_addr].ff = (long)p_data->f_val_set;
                        p_data->ul_val_bak = p_data->f_val_set;
                        uc_updata_equip = 1;
                    }
                }
            }
        }
    }

    if (uc_updata_equip)
    {
        uc_updata_equip = 0;
        /* 保存装置参数 */
        if (SavePara((void *)pt_buf, EEP_EQUIP_PARA_ADDR, EQUIP_PARA_NUMBER, &tEquipParaTable[0]))
        {
            soe_record_opt(EV_EQUPARA_OK, 0);
            // MakeRunPara(false, false);
            rt_err_clr(ERR_CODE_EQU_PARA, 0);
        }
        else
        {
            uc_save_flag = 0;
        }
    }

    /* 读取内部定值 */
    if (!ReadPara((void *)pt_buf, EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0]))
    {
        rt_err_set(ERR_CODE_SET_IN, 0);
        GetDefPara((void *)pt_buf, CSTSET_NUMBER, &tCstSetTable[0]);
    }
    else
    {
        rt_err_clr(ERR_CODE_SET_IN, 0);
    }

    for (i = 0; i < module_size; i++)
    {
        for (j = 0; j < p_cfg[i].us_val; j++)
        {
            t_datafixval_cfg *p_data = &(p_cfg[i].fs[j]);

            if(p_data->uc_type == RMT_GRP_CSSET)    //内部定值
            {
                float f_abs_val = fabs(pt_buf[p_data->us_addr].ff - p_data->f_val_set);
                if (f_abs_val >= p_data->f_val_step)
                {
                    pt_buf[p_data->us_addr].ff = (long)p_data->f_val_set;
                    p_data->ul_val_bak = p_data->f_val_set;
                    uc_updata_cst = 1;
                }
            }

        }

    }

    // 保存内部定值
    if (uc_updata_cst)
    {
        if (SavePara((void *)pt_buf, EEP_CSTSET_ADDR, CSTSET_NUMBER, &tCstSetTable[0]))
        {
            soe_record_opt(EV_CSTSET_OK, 0); // 内部定值整定成功
            // MakeRunSet(false);               // 将当前运行定值区转换为运行定值区
            rt_err_clr(ERR_CODE_SET_IN, 0);
        }
        else
        {
            uc_save_flag = 0;
        }
    }

    /*读取定值*/
    if (!ReadSet(setio_get_fixarea(), (void *)pt_buf)) // 读定值
    {
        uc_save_flag = 0;
        rt_err_set(ERR_CODE_SET, 0);
        printf("%s 读取当前运行定值无效! \n", __FUNCTION__);
        GetDefSet((float *)pt_buf);
    }
    else
    {
        rt_err_clr(ERR_CODE_SET, 0);
    }

    for (i = 0; i < module_size; i++)
    {
        for (j = 0; j < p_cfg[i].us_val; j++)
        {
            t_datafixval_cfg *p_data = &(p_cfg[i].fs[j]);

            if(p_data->uc_type == RMT_GRP_PUSET)    //公共定值
            {
                float f_abs_val = fabs(pt_buf[p_data->us_addr].ff - p_data->f_val_set);
                if (f_abs_val >= p_data->f_val_step)
                {
                    pt_buf[p_data->us_addr].ff = (long)p_data->f_val_set;
                    p_data->ul_val_bak = p_data->f_val_set;
                    uc_updata_sf = 1;
                }
            }
            else if (p_data->uc_type == RMT_GRP_SWSET)  //开关定值
            {
                // 跳过"不停电传动投入"软压板，保持只读状态
                if (p_data->us_addr == SET_TRASW_YB)
                {
                    continue;
                }
                
                float f_abs_val = fabs(pt_buf[p_data->us_addr + PUB_SET_NUMBER].ff - p_data->f_val_set);
                if (f_abs_val >= p_data->f_val_step)
                {
                    pt_buf[p_data->us_addr + PUB_SET_NUMBER].ff = (long)p_data->f_val_set;
                    p_data->ul_val_bak = p_data->f_val_set;
                    uc_updata_sf = 1;
                }
            }
        }

    }

    if (uc_updata_sf)
    {
        /* 保存开关、公共定值 */
        if(SaveSet(setio_get_fixarea(), (void *)pt_buf))
        {
            soe_record_opt(EV_SET_OK, 0);
            rt_err_clr(ERR_CODE_SET, 0);
        }
    }

    /* 实际有定值更新才转换 */
    if ((uc_updata_sf || uc_updata_cst) && uc_save_flag)
    {
        MakeRunSet(false);
    }

    if (uc_save_flag)
    {
        log_str_time(LOG_OPERATE, "液晶整定定值成功!", 0, 0);
    }
    else
    {
        log_str_time(LOG_OPERATE, "液晶整定定值失败!", 0, 0);
    }
    
    return uc_save_flag;
}

/**
 * @brief 恢复模块的默认值
 * 
 * 该函数遍历指定模块中的所有数据项，将IP地址类型的数据项的ul_val_set恢复为ul_val_bak，
 * 将非IP地址类型的数据项的f_val_set恢复为f_val_bak。
 * 
 * @param module 要恢复默认值的模块
 */
void data_mgr_restore_default_values(DataModule module)
{
    // 获取模块对应的配置信息
    t_datafixval_cfg_total *p_cfg = NULL;
    uint16_t module_size = data_mgr_get_module_cfg_total(module, &p_cfg);
    
    if (p_cfg == NULL || module_size == 0)
    {
        printf("%s: Invalid module configuration\n", __FUNCTION__);
        return;
    }
    
    // 遍历模块中的所有菜单
    for (uint16_t i = 0; i < module_size; i++)
    {
        // 遍历菜单中的所有数据项
        for (uint16_t j = 0; j < p_cfg[i].us_val; j++)
        {
            t_datafixval_cfg *p_data = &(p_cfg[i].fs[j]);
            
            // 检查是否为IP地址类型的数据
            if (p_data->uc_type == RMT_GRP_EQSET && is_special_ip_addr(p_data->us_addr))
            {
                // 对于IP地址类型，使用ul_val_bak覆盖ul_val_set
                p_data->ul_val_set = p_data->ul_val_bak;
                // printf("%s: Restored IP address data for module %d, menu %d, data %d to 0x%lx\n", 
                //        __FUNCTION__, module, i, j, p_data->ul_val_set);
            }
            else
            {
                // 对于非IP地址类型，使用f_val_bak覆盖f_val_set
                p_data->f_val_set = p_data->f_val_bak;
                // printf("%s: Restored non-IP data for module %d, menu %d, data %d to %.2f\n", 
                //        __FUNCTION__, module, i, j, p_data->f_val_set);
            }
        }
    }
    
    // printf("%s: Restored default values for module %d\n", __FUNCTION__, module);
}

/**
 * @brief           初始化实时数据模块
 * @return         * void 
 * @retval         
 * 
 * @warning        
 * @note           调用data_real_time模块的初始化函数
 */
void data_mgr_real_time_init(void)
{
    data_real_time_init();
}

/**
 * @brief           获取遥信数据
 * @return         * void 
 * @retval         
 * 
 * @warning        
 * @note           调用data_real_time模块的获取遥信数据函数
 */
void data_mgr_get_yx_data(void)
{
    data_real_time_get_yx_data();
}

/**
 * @brief           获取遥测数据
 * @param[in]      {uint8_t} type 遥测类型：TYPE_YCDISPLY_PRIMARY(一次值) / TYPE_YCDISPLY_SECONDY(二次值)
 * @return         * void 
 * @retval         
 * 
 * @warning        
 * @note           调用data_real_time模块的获取遥测数据函数
 */
void data_mgr_get_yc_data(GET_TYPE type)
{
    data_real_time_get_yc_data(type);
}
/**
 * @brief           获取遥控数据
 * @return         * void
 * @retval
 *
 * @warning
 * @note           调用data_real_time模块的获取遥控数据函数
 */
void data_mgr_get_yk_data(void)
{
    data_real_time_get_yk_data();
}

// ===================== DO遥控控制接口实现 =====================

/**
 * @brief           执行DO遥控操作（开出控制）
 * @param[in]       do_index: DO索引（0 ~ do_num-1）
 * @param[in]       type: 操作类型，DO_CTRL_OFF(分闸) 或 DO_CTRL_ON(合闸)
 * @return          DoCtrlRet: 操作结果
 * @date            2026-02-26
 */
DoCtrlRet data_mgr_do_control(uint8_t do_index, DoCtrlType type)
{
    int ret = 0;
    u32 sw_index = 0;  // 开关索引，目前默认使用开关0
    u32 do_type = SW_DO_YKH;  // 默认遥控合闸

    // 参数检查
    if (do_index >= g_equ_config->do_num)
    {
        printf("%s: DO索引超出范围, do_index=%d, do_num=%d\r\n", 
               __FUNCTION__, do_index, g_equ_config->do_num);
        return DO_CTRL_RET_PARAM_ERR;
    }

    if (type != DO_CTRL_OFF && type != DO_CTRL_ON)
    {
        printf("%s: 操作类型错误, type=%d\r\n", __FUNCTION__, type);
        return DO_CTRL_RET_PARAM_ERR;
    }

    // 调用底层sw_do函数执行遥控操作
    // 参数：sw=开关索引, index=开出类型, type=操作类型(SW_DO_TYPE_ON/OFF)
    if (do_index > SW_DO_YKT)
    {
        ret = sw_do(sw_index, do_index, (type == DO_CTRL_ON) ? SW_DO_TYPE_ON : SW_DO_TYPE_OFF);
    }
    else
    {
        
        if (0 == sw_do(sw_index, do_index,  (type == DO_CTRL_ON) ? SW_DO_TYPE_SELECT_ON : SW_DO_TYPE_SELECT_OFF) )
        {
            printf("%s DO预置成功\n", __FUNCTION__);
            ret = sw_do(sw_index, do_index, (type == DO_CTRL_ON) ? SW_DO_TYPE_ON : SW_DO_TYPE_OFF);
        }
        else
        {
            printf("%s DO预置失败\n", __FUNCTION__);
            ret = -4; // 选合/分失败，返回执行错误
        }      
    }

    // 转换返回值
    switch (ret)
    {
    case 0:
        printf("%s: DO遥控操作成功, do_index=%d, do_type=%d, type=%s\r\n", 
               __FUNCTION__, do_index, do_type, (type == DO_CTRL_ON) ? "合闸" : "分闸");
        return DO_CTRL_RET_OK;
    case -1:
        printf("%s: DO遥控操作失败-参数错误\r\n", __FUNCTION__);
        return DO_CTRL_RET_PARAM_ERR;
    case -2:
        printf("%s: DO遥控操作失败-气压低闭锁\r\n", __FUNCTION__);
        return DO_CTRL_RET_BS_ERR;
    case -3:
        printf("%s: DO遥控操作失败-通道未配置\r\n", __FUNCTION__);
        return DO_CTRL_RET_CFG_ERR;
    default:
        printf("%s: DO遥控操作失败-未知错误, ret=%d\r\n", __FUNCTION__, ret);
        return DO_CTRL_RET_EXEC_ERR;
    }
}

/**
 * @brief           获取DO遥控状态
 * @param[in]       do_index: DO索引（0 ~ do_num-1）
 * @return          int: 当前状态，0=分，1=合，-1=错误
 * @date            2026-02-26
 */
int data_mgr_get_do_status(uint8_t do_index)
{
    // 参数检查
    if (do_index >= g_equ_config->do_num)
    {
        printf("%s: DO索引超出范围, do_index=%d\r\n", __FUNCTION__, do_index);
        return -1;
    }

    // 从遥控数据数组中获取状态
    // Remote_ctrl_opt数组在data_real_time.c中定义
    extern Para_OPTTypeDef Remote_ctrl_opt[SUBMENU_REMOTCRTL_NUM];
    
    if (do_index < SUBMENU_REMOTCRTL_NUM)
    {
        return (int)Remote_ctrl_opt[do_index].value;
    }

    return -1;
}

// ===================== 出厂调试数据接口实现 =====================

/**
 * @brief           获取出厂调试指定菜单的名称
 * @param[in]       menu_idx: 菜单索引，0=状态信息，1=系统设置
 * @return          const char*: 菜单名称字符串
 */
const char* data_mgr_get_debugset_menu_name(uint8_t menu_idx)
{
    return data_debugset_get_menu_name(menu_idx);
}

/**
 * @brief           获取出厂调试指定菜单的数据项长度
 * @param[in]       menu_sel_idx: 菜单索引，0=状态信息，1=系统设置，
 * @return          数据项数量
 */
uint16_t data_mgr_get_debugset_items_len(u8 menu_sel_idx)
{
    if (menu_sel_idx >= guc_menu_debugset_num)
    {
        return 0;
    }
    return gst_debugset_val[menu_sel_idx].us_val;
}

/**
 * @brief           获取出厂调试状态信息指定项的值
 * @param[in]       item_idx: 状态信息项索引（0-8）
 * @return          float: 当前值
 */
float data_mgr_get_debugset_status_value(uint8_t item_idx)
{
    return data_debugset_get_status_value(item_idx);
}

/**
 * @brief           获取出厂调试状态信息指定项的名称
 * @param[in]       item_idx: 状态信息项索引（0-8）
 * @return          const char*: 名称字符串
 */
const char* data_mgr_get_debugset_status_name(uint8_t item_idx)
{
    return data_debugset_get_status_name(item_idx);
}

/**
 * @brief           获取出厂调试状态信息指定项的单位
 * @param[in]       item_idx: 状态信息项索引（0-8）
 * @return          const char*: 单位字符串
 */
const char* data_mgr_get_debugset_status_unit(uint8_t item_idx)
{
    return data_debugset_get_status_unit(item_idx);
}

/**
 * @brief           获取出厂调试系统设置指定项的值
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @return          float: 当前值
 */
float data_mgr_get_debugset_system_value(uint8_t item_idx)
{
    return data_debugset_get_system_value(item_idx);
}

/**
 * @brief           执行系统设置操作（统一接口）
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @param[in]       param: 操作参数（根据设置项类型不同而不同）
 * @return          data_bool_t: true-成功, false-失败
 * @note            该函数为系统设置提供统一的操作接口，各设置项的具体功能在data_debugset层实现
 */
data_bool_t data_mgr_execute_sysset_operation(uint8_t item_idx, void *param)
{
    if (item_idx >= data_debugset_get_system_item_count()) {
        return false;
    }

    switch (item_idx) {
        case SYSSET_ITEM_FACTORY_RESET:
            return data_debugset_execute_factory_reset();

        case SYSSET_ITEM_CLEAR_HISTORY:
            return data_debugset_execute_clear_history();

        case SYSSET_ITEM_CLEAR_ENERGY:
            return data_debugset_execute_clear_energy();

        case SYSSET_ITEM_DATETIME:
            if (param != NULL) {
                data_datetime_t *dt = (data_datetime_t *)param;
                return data_debugset_set_datetime(dt->year, dt->month, dt->day,
                                                   dt->hour, dt->minute, dt->second);
            }
            return false;

        case SYSSET_ITEM_PASSWORD:
            if (param != NULL) {
                uint16_t *pwd = (uint16_t *)param;
                return data_debugset_set_password(*pwd);
            }
            return false;

        case SYSSET_ITEM_CALIBRATION:
            return data_debugset_execute_calibration();

        case SYSSET_ITEM_BACKLIGHT:
            if (param != NULL) {
                uint32_t *time = (uint32_t *)param;
                return data_debugset_set_backlight_time(*time);
            }
            return false;

        default:
            return false;
    }
}

/**
 * @brief           获取出厂调试系统设置指定项的名称
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @return          const char*: 名称字符串
 */
const char* data_mgr_get_debugset_system_name(uint8_t item_idx)
{
    return data_debugset_get_system_name(item_idx);
}

/**
 * @brief           获取出厂调试系统设置指定项的单位
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @return          const char*: 单位字符串
 */
const char* data_mgr_get_debugset_system_unit(uint8_t item_idx)
{
    return data_debugset_get_system_unit(item_idx);
}

/**
 * @brief           获取出厂调试系统设置指定项的配置参数
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @param[out]      min: 输出最小值
 * @param[out]      max: 输出最大值
 * @param[out]      point: 输出小数位数
 * @param[out]      numeric_opt: 输出数值选项类型
 * @return          data_bool_t: true-成功, false-失败
 */
data_bool_t data_mgr_get_debugset_system_config(uint8_t item_idx, uint32_t *min, uint32_t *max, 
                                                  uint8_t *point, uint8_t *numeric_opt)
{
    if (item_idx >= data_debugset_get_system_item_count())
    {
        return false;
    }
    
    if (min != NULL)
    {
        *min = data_debugset_get_system_min(item_idx);
    }
    if (max != NULL)
    {
        *max = data_debugset_get_system_max(item_idx);
    }
    if (point != NULL)
    {
        *point = data_debugset_get_system_point(item_idx);
    }
    if (numeric_opt != NULL)
    {
        *numeric_opt = data_debugset_get_system_numeric_opt(item_idx);
    }
    
    return true;
}

/**
 * @brief           检查出厂调试系统设置项是否为开关类型
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @return          data_bool_t: true-是开关类型, false-不是
 */
data_bool_t data_mgr_is_debugset_system_switch_type(uint8_t item_idx)
{
    return data_debugset_is_system_switch_type(item_idx);
}

/**
 * @brief           检查出厂调试系统设置项是否为数值类型
 * @param[in]       item_idx: 系统设置项索引（0-6）
 * @return          data_bool_t: true-是数值类型, false-不是
 */
data_bool_t data_mgr_is_debugset_system_number_type(uint8_t item_idx)
{
    return data_debugset_is_system_number_type(item_idx);
}

/**
 * @brief           更新出厂调试数据（从系统获取最新数据）
 * @return          void
 */
void data_mgr_refresh_debugset_data(void)
{
    data_debugset_refresh_data();
}

/* ==================================================================================================================== */
/* 菜单和配置数据接口封装 - 数据流向: data_debugset.c -> data_manager.c -> service层 */
/* ==================================================================================================================== */

uint8_t data_mgr_get_debugset_menu_count(void)
{
    return data_debugset_get_menu_count();
}

data_bool_t data_mgr_get_password_config(uint16_t *min, uint16_t *max, uint16_t *default_val)
{
    return data_debugset_get_password_config(min, max, default_val);
}

data_bool_t data_mgr_get_backlight_config(uint32_t *min, uint32_t *max, uint32_t *default_val)
{
    return data_debugset_get_backlight_config(min, max, default_val);
}

data_bool_t data_mgr_get_datetime_default(uint16_t *year, uint8_t *month, uint8_t *day,
                                    uint8_t *hour, uint8_t *min, uint8_t *sec)
{
    return data_debugset_get_datetime_default(year, month, day, hour, min, sec);
}
