#include "cJSON.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <time.h>
#include "emsctrl.h"

// #define DEBUG
// #define LOG_ERR 0
#undef _DEBUG_LOG
#ifdef _DEBUG_LOG
#undef dbg_syslog
#define dbg_syslog(xx, fmt, ...) printf("[%s:%d->%s]" fmt "\r\n", __FILE__, __LINE__, __func__, ##__VA_ARGS__)
#else
#endif

#define JSON_GET_NUM_PRINT(root, val, key)                   \
    tmp = cJSON_GetObjectItemCaseSensitive(root, key);       \
    if (cJSON_IsNumber(tmp))                                 \
    {                                                        \
        dbg_syslog(LOG_ERR, "%s:%d\r\n", key, tmp->valueint); \
        val = tmp->valueint;                                 \
    }

#define JSON_GET_NUM_PRINT_INIT_NUM(root, val, key, defaultValue)\
    tmp = cJSON_GetObjectItemCaseSensitive(root, key);       \
    if (cJSON_IsNumber(tmp))                                 \
    {                                                        \
        dbg_syslog(LOG_ERR, "%s:%d\r\n", key, tmp->valueint); \
        val = tmp->valueint;                                 \
    }                                                        \
    else                                                     \
    {                                                        \
        val = defaultValue;                                  \
    }

#define JSON_GET_DOUBLE_NUM_PRINT(root, val, key)               \
    tmp = cJSON_GetObjectItemCaseSensitive(root, key);          \
    if (cJSON_IsNumber(tmp))                                    \
    {                                                           \
        dbg_syslog(LOG_ERR, "%s:%f\r\n", key, tmp->valuedouble); \
        val = tmp->valuedouble;                                 \
    }

#define JSON_GET_STRING_PRINT(root, val, key)                   \
    tmp = cJSON_GetObjectItemCaseSensitive(root, key);          \
    if (cJSON_IsString(tmp))                                    \
    {                                                           \
        dbg_syslog(LOG_ERR, "%s:%s\r\n", key, tmp->valuestring); \
        strcpy(val, tmp->valuestring);                          \
    }

#define JSON_GET_DUP_STRING_PRINT(root, val, key)               \
    tmp = cJSON_GetObjectItemCaseSensitive(root, key);          \
    if (cJSON_IsString(tmp))                                    \
    {                                                           \
        dbg_syslog(LOG_ERR, "%s:%s\r\n", key, tmp->valuestring); \
        *val = strdup(tmp->valuestring);                        \
    }

#define JSON_GET_DOUBLE_NUM_DEFAULT(root, val, key,defaultValue)\
    tmp = cJSON_GetObjectItemCaseSensitive(root, key);          \
    if (cJSON_IsNumber(tmp))                                    \
    {                                                           \
        dbg_syslog(LOG_ERR, "%s:%f\r\n", key, tmp->valuedouble); \
        val = tmp->valuedouble;                                 \
    }                                                           \
    else                                                         \
    {                                                            \
        val = defaultValue;                                         \
    } 

/*  --[[  以15分钟为例(精确到时间戳)：需量时间map如下：：：合理的 demand_config.demand_inter 3 5 10 12 15 20 30
    local critical_map = {
        {MIN_L = 0, MIN_H = 900},
        {MIN_L = 900, MIN_H = 1800},
        {MIN_L = 1800, MIN_H = 2700},
        {MIN_L = 2700, MIN_H = 3600},
        }]]   ******************************************************************************/
static int init_critical_map(CHARGE_MNG_INFO_T *char_mng, PCS_CFG_T *pcfg)
{
	BYTE i = 0;
	
    if ((pcfg->DCI != 3) && (pcfg->DCI != 5) && (pcfg->DCI != 10) && \
		(pcfg->DCI != 12) && (pcfg->DCI != 15) && (pcfg->DCI != 20) && (pcfg->DCI != 30)) //参数过滤
		{dbg_syslog(LOG_ERR, "Parameter error: %d", pcfg->DCI); return -1;}

	memset(&char_mng->dynamic_demand.critical_map, 0, sizeof(critical_map_t));
	BYTE number = 60;
    for (i = 0; i < number; i++)
    {
        char_mng->dynamic_demand.critical_map.time_map[i].MIN_L = i * 60;
		char_mng->dynamic_demand.critical_map.time_map[i].MIN_H = (i + 1) * 60;
    }
	char_mng->dynamic_demand.critical_map.num = number;
	
    dbg_syslog(LOG_ERR, "dynamic_demand init critical_map: time quantum: %d", char_mng->dynamic_demand.critical_map.num);
	return 0;
}

int To_initialize(CHARGE_MNG_INFO_T *char_mng, PCS_CFG_T *pcfg)
{
	BYTE i = 0;
	time_t time1 = -1;
    struct tm tNow;
    struct tm action_tim;
	struct tm step_tim;
	struct tm dci_tim;
	char time_str[64];

	if (init_critical_map(char_mng, pcfg) == -1) return -1;
	
	time(&time1);
    // tNow = localtime(&time1);//localtime_r
    localtime_r(&time1, &tNow); // localtime_r 修改；
	time_t now_sec = tNow.tm_min * 60 + tNow.tm_sec;
    time_t min_sec = 0;
	
    for (i = 0; i < char_mng->dynamic_demand.critical_map.num; i++)
    {
        if (now_sec == char_mng->dynamic_demand.critical_map.time_map[i].MIN_L) 
        {
			min_sec = char_mng->dynamic_demand.critical_map.time_map[i].MIN_L;
            break;
        }
		if (i < (char_mng->dynamic_demand.critical_map.num - 1))
		{
            if ((now_sec > char_mng->dynamic_demand.critical_map.time_map[i].MIN_L) && (now_sec <= char_mng->dynamic_demand.critical_map.time_map[i].MIN_H))
            {
               min_sec = char_mng->dynamic_demand.critical_map.time_map[i+1].MIN_L; // 丢弃本区间数据，直接采用下区间时间段，此处区间为1分钟（恒定）
			   break;
			}
		}else if (i == (char_mng->dynamic_demand.critical_map.num - 1))
		{
			if ((now_sec > char_mng->dynamic_demand.critical_map.time_map[i].MIN_L) && (now_sec <= char_mng->dynamic_demand.critical_map.time_map[i].MIN_H))
			{
			   min_sec = char_mng->dynamic_demand.critical_map.time_map[0].MIN_L + 60*60;
			   break;
			}
		}
    }

	tNow.tm_min = 0;
	tNow.tm_sec = 0;
	char_mng->dynamic_demand.action_tim = mktime(&tNow) + min_sec;
	char_mng->dynamic_demand.step_tim = char_mng->dynamic_demand.action_tim + 1 * 60; // 1分钟计算一次平均值
	char_mng->dynamic_demand.dci_tim = char_mng->dynamic_demand.action_tim + pcfg->DCI * 60;

	localtime_r(&char_mng->dynamic_demand.action_tim, &action_tim);
	localtime_r(&char_mng->dynamic_demand.step_tim, &step_tim);
	localtime_r(&char_mng->dynamic_demand.dci_tim, &dci_tim);
	
	char_mng->dynamic_demand.ping_pong = 0;
	memset(char_mng->dynamic_demand.pingpangbuff, 0, sizeof(char_mng->dynamic_demand.pingpangbuff));

	char_mng->dynamic_demand.power_data.num = 0;
	memset(char_mng->dynamic_demand.power_data.data, 0, sizeof(char_mng->dynamic_demand.power_data.data));

	dbg_syslog(LOG_ERR, "action_tim : %04d-%02d-%02d %02d:%02d:%02d ", action_tim.tm_year + 1900, action_tim.tm_mon + 1, action_tim.tm_mday, action_tim.tm_hour, action_tim.tm_min, action_tim.tm_sec);
	dbg_syslog(LOG_ERR, "step_tim : %04d-%02d-%02d %02d:%02d:%02d ", step_tim.tm_year + 1900, step_tim.tm_mon + 1, step_tim.tm_mday, step_tim.tm_hour, step_tim.tm_min, step_tim.tm_sec);
	dbg_syslog(LOG_ERR, "dci_tim : %04d-%02d-%02d %02d:%02d:%02d ", dci_tim.tm_year + 1900, dci_tim.tm_mon + 1, dci_tim.tm_mday, dci_tim.tm_hour, dci_tim.tm_min, dci_tim.tm_sec);

	return 0;
}

int load_some_state_cfg(CHARGE_MNG_INFO_T *pcfg, const char *cfg_file, int savestate)  //记录一些运行状态之类的
{
    if (savestate == 0)return E_TRUE;
    char *pdata = NULL;
    cJSON *root = NULL;
    cJSON *node = NULL;
    cJSON *tmp = NULL;
    int node_cnt = 0, i = 0;

    if (pcfg == NULL || cfg_file == NULL)
    {
        dbg_syslog(LOG_ERR, "pcfg:%p cfg_file:%p var:%p", pcfg, cfg_file);
        return -1;
    }
    pdata = read_file_data(cfg_file);

    if (pdata == NULL)
    {
        dbg_syslog(LOG_ERR, "read cfg file %s error", cfg_file);

        goto out;
    }
    root = cJSON_Parse(pdata);
    if (!root)
    {
        dbg_syslog(LOG_ERR, "parse cfg file %s error", cfg_file);

        goto out;
    }
    JSON_GET_NUM_PRINT(root, pcfg->runState, TO_STRING(JSON_NAME_RUNSTATE  ));
    JSON_GET_NUM_PRINT(root, pcfg->connState,TO_STRING(JSON_NAME_CONNSTATE ));
    JSON_GET_NUM_PRINT(root, pcfg->pcs_yggl, TO_STRING(JSON_NAME_YGGL      ));
    JSON_GET_NUM_PRINT(root, pcfg->pcs_wggl, TO_STRING(JSON_NAME_WGGL      ));
    out:
    cJSON_Delete(root);
    if (pdata != NULL)
    {
        free(pdata);
    }
}

int load_pcs_cfg(PCS_CFG_T *pcfg, const char *cfg_file)
{
    char *pdata = NULL;
    cJSON *root = NULL;
    cJSON *nodes = NULL;
    cJSON *node = NULL;
    cJSON *tmp = NULL;
    int node_cnt = 0, i = 0;

    if (pcfg == NULL || cfg_file == NULL)
    {
        dbg_syslog(LOG_ERR, "pcfg:%p cfg_file:%p var:%p", pcfg, cfg_file);
        return -1;
    }
    pdata = read_file_data(cfg_file);

    if (pdata == NULL)
    {
        dbg_syslog(LOG_ERR, "read cfg file %s error", cfg_file);

        goto out;
    }
    root = cJSON_Parse(pdata);
    if (!root)
    {
        dbg_syslog(LOG_ERR, "parse cfg file %s error", cfg_file);

        goto out;
    }
    JSON_GET_NUM_PRINT(root, pcfg->CLCha, TO_STRING(JSON_NAME_CLHA));
    JSON_GET_NUM_PRINT(root, pcfg->CLDischa, TO_STRING(JSON_NAME_CLDISCHA));
    JSON_GET_NUM_PRINT(root, pcfg->Pmlmax, TO_STRING(JSON_NAME_PMLMAX));
    if (pcfg->Pmlmax <= 0)
    {
        pcfg->Pmlmax = POWER_MAX_VAL;
    }
	JSON_GET_NUM_PRINT(root, pcfg->EDD, TO_STRING(JSON_NAME_EDD));
	JSON_GET_NUM_PRINT(root, pcfg->MD, TO_STRING(JSON_NAME_MD));
	if (pcfg->MD == 0) pcfg->MD = (USHORT)((float)pcfg->Pmlmax * 80/100);
	JSON_GET_NUM_PRINT(root, pcfg->DCI, TO_STRING(JSON_NAME_DCI));
	if (pcfg->DCI == 0) pcfg->DCI = 15;
	JSON_GET_NUM_PRINT(root, pcfg->Dylmax, TO_STRING(JSON_NAME_DYLMAX));
	if (pcfg->Dylmax < pcfg->MD) pcfg->Dylmax = pcfg->MD;
    JSON_GET_NUM_PRINT(root, pcfg->K1, TO_STRING(JSON_NAME_K1));
    JSON_GET_NUM_PRINT(root, pcfg->K2, TO_STRING(JSON_NAME_K2));
    // JSON_GET_NUM_PRINT(root,pcfg->SOCmax,TO_STRING(JSON_NAME_SOCMAX));
    // JSON_GET_NUM_PRINT(root,pcfg->SOCmin,TO_STRING(JSON_NAME_SOCMIN));
    JSON_GET_DOUBLE_NUM_PRINT(root, pcfg->SOCmax, TO_STRING(JSON_NAME_SOCMAX));
    JSON_GET_DOUBLE_NUM_PRINT(root, pcfg->SOCmin, TO_STRING(JSON_NAME_SOCMIN));
    JSON_GET_NUM_PRINT(root, pcfg->Pset, TO_STRING(JSON_NAME_PSET));
    JSON_GET_NUM_PRINT(root, pcfg->Perr, TO_STRING(JSON_NAME_PERR));
    JSON_GET_NUM_PRINT(root, pcfg->PVmax, TO_STRING(JSON_NAME_PVMAX));
    JSON_GET_NUM_PRINT(root, pcfg->PCSmax, TO_STRING(JSON_NAME_PCSMAX));
    JSON_GET_NUM_PRINT(root, pcfg->Pcha, TO_STRING(JSON_NAME_PCHA));
    JSON_GET_NUM_PRINT(root, pcfg->PchaMax, TO_STRING(JSON_NAME_PCHAMAX));
    JSON_GET_NUM_PRINT(root, pcfg->PchaMin, TO_STRING(JSON_NAME_PCHAMIN));
    JSON_GET_NUM_PRINT(root, pcfg->PDisc, TO_STRING(JSON_NAME_PDISC));
    JSON_GET_NUM_PRINT(root, pcfg->PDiscMax, TO_STRING(JSON_NAME_PDISCMAX));
    JSON_GET_NUM_PRINT(root, pcfg->PDiscMin, TO_STRING(JSON_NAME_PDISCMIN));
    JSON_GET_NUM_PRINT(root, pcfg->Adjstep, TO_STRING(JSON_NAME_ADJSTEP));
    JSON_GET_NUM_PRINT(root, pcfg->Adjpreriod, TO_STRING(JSON_NAME_ADJPRERIOD));
    JSON_GET_NUM_PRINT(root, pcfg->Sliptime, TO_STRING(JSON_NAME_SLIPTIME));
    JSON_GET_NUM_PRINT(root, pcfg->loadgridmetershare, TO_STRING(JSON_NAME_LOADGRIDMETERSHARE));
    JSON_GET_STRING_PRINT(root, pcfg->DayUPgradeTime, TO_STRING(JSON_NAME_UPGRADE_PLAN_ONEDAY));
    if(strlen(pcfg->DayUPgradeTime) <=1)strcpy(pcfg->DayUPgradeTime,"P0000");
    JSON_GET_NUM_PRINT(root, pcfg->SOCdrt, TO_STRING(JSON_NAME_SOCDRT));
    JSON_GET_NUM_PRINT(root, pcfg->runState, TO_STRING(JSON_NAME_RUN_STATE));
    JSON_GET_NUM_PRINT(root, pcfg->trackDiff, TO_STRING(JSON_NAME_TRACK_DIFF));
    JSON_GET_NUM_PRINT(root, pcfg->type, TO_STRING(JSON_NAME_TYPE));
    JSON_GET_NUM_PRINT(root, pcfg->dischargeThreshold, TO_STRING(JSON_NAME_DISCHARGE_THRESHOLD));
    JSON_GET_NUM_PRINT(root, pcfg->chargeStartPower, TO_STRING(JSON_NAME_CHARGE_START_POWER));
    JSON_GET_NUM_PRINT(root, pcfg->chargeEndPower, TO_STRING(JSON_NAME_CHARGE_END_POWER));
    JSON_GET_NUM_PRINT(root, pcfg->dischargeEndThreshold, TO_STRING(JSON_NAME_DISCHARGE_END_THRESHOLD));
    JSON_GET_NUM_PRINT(root, pcfg->dischareeEndThresholdVal, TO_STRING(JSON_NAME_DISCHARGE_THRESHOLD_OFFSET));
    JSON_GET_NUM_PRINT(root, pcfg->tempThreshold, TO_STRING(JSON_NAME_TEMP_THRESHOLD));
    JSON_GET_NUM_PRINT(root, pcfg->door_io_flag, TO_STRING(JSON_NAME_DOOR_FLAG));

    JSON_GET_DOUBLE_NUM_DEFAULT(root, pcfg->KM, TO_STRING(JSON_NAME_KM),0.3f);
    JSON_GET_NUM_PRINT_INIT_NUM(root, pcfg->savestate, TO_STRING(JSON_NAME_SAVESTATE),0);
    JSON_GET_NUM_PRINT(root, pcfg->PvSwitch, TO_STRING(JSON_NAME_PVSWITCH));
    JSON_GET_NUM_PRINT(root, pcfg->socThreshold, TO_STRING(JSON_NAME_SOCTHRESHOLD));
    JSON_GET_NUM_PRINT(root, pcfg->forbidden, TO_STRING(JSON_NAME_FORBIDDEN));
    JSON_GET_NUM_PRINT(root, pcfg->MAXSupplementP, TO_STRING(JSON_NAME_MAXSUPPLEMENT_P));
    JSON_GET_NUM_PRINT(root, pcfg->p1Margin, TO_STRING(JSON_NAME_P1_MARGIN));
    JSON_GET_NUM_PRINT(root, pcfg->pvMaxPower, TO_STRING(JSON_NAME_PV_MAX_POWER));
    JSON_GET_NUM_PRINT(root, pcfg->alarmClose, TO_STRING(JSON_NAME_ALARMCLOSE));
    JSON_GET_NUM_PRINT(root, pcfg->supportStandy, TO_STRING(JSON_NAME_SUPPORTSTANDY));
    JSON_GET_NUM_PRINT(root, pcfg->SOCpv, TO_STRING(JSON_NAME_SOCPV));
    JSON_GET_NUM_PRINT(root, pcfg->aircond_set_timeout_before, TO_STRING(JSON_NAME_AIRCOND_SET_TIMEOUT_BEFORE));
    JSON_GET_NUM_PRINT(root, pcfg->aircond_set_timeout_after, TO_STRING(JSON_NAME_AIRCOND_SET_TIMEOUT_AFTER));
	JSON_GET_NUM_PRINT(root, pcfg->singlemax, TO_STRING(JSON_NAME_SINGLEMAX));
    JSON_GET_NUM_PRINT(root, pcfg->singlemin, TO_STRING(JSON_NAME_SINGLEMIN));
    JSON_GET_NUM_PRINT_INIT_NUM(root, pcfg->dev_online_timeout, TO_STRING(JSON_NAME_DEV_ONLINE_TIMEOUT), 30);
	JSON_GET_NUM_PRINT_INIT_NUM(root, pcfg->manual_flag, TO_STRING(JSON_NAME_MANUAL_FLAG), 0);
	JSON_GET_NUM_PRINT_INIT_NUM(root, pcfg->meter_flag, TO_STRING(JSON_NAME_DEV_METER_FLAG), 0);
    nodes = cJSON_GetObjectItemCaseSensitive(root, TO_STRING(JSON_NAME_PLANINFO));
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get nodes_cfg failed");
        goto out;
    }
    node_cnt = cJSON_GetArraySize(nodes);
    for (i = 0; i < node_cnt; i++)
    {
        int j;
        CHAR timer[TIME_VAL_LEN] = {0};
        node = cJSON_GetArrayItem(nodes, i);
        JSON_GET_STRING_PRINT(node, timer, TO_STRING(JSON_NAME_TIME));
        for (j = 0; j < MAX_DEMAND_NUMBER; j++)
        {
            //  dbg_syslog(LOG_ERR, "time:%s",pcfg->demand_table[j].time);
            if (strcmp(timer, pcfg->demand_table[j].time) == 0)
            {
                JSON_GET_NUM_PRINT(node, pcfg->demand_table[j].power, TO_STRING(JSON_NAME_POWER));
                JSON_GET_NUM_PRINT(node, pcfg->demand_table[j].price, TO_STRING(JSON_NAME_PRICE));
                JSON_GET_NUM_PRINT(node, pcfg->demand_table[j].option, TO_STRING(JSON_NAME_OPTION));
                pcfg->demand_table[j].flag = 1;
                break;
            }
        }
    }
out:
    cJSON_Delete(root);
    if (pdata != NULL)
    {
        free(pdata);
    }
}

int parse_week_set(CHAR *buf, WEEK_INFO_T *pweek_info)
{
    int i = 0;
    char *token = strtok(buf, ",");
    for (int j = 0; j < WEEK_DAY_NUM; j++)
    {
        pweek_info->weekNum[j] = 0;
    }
    while (token != NULL)
    {
        i = atoi(token);
        if (i == 7)
        {
            pweek_info->weekNum[0] = 1;
        }
        else if (0 < i < 7)
        {
            pweek_info->weekNum[i] = 1;
        }
        dbg_syslog(LOG_ERR, "%d", i);
        token = strtok(NULL, ",");
    }
    return 0;
}
int get_date_by_string(CHAR *buf, time_t *pday);

#define ONE_DAY_SECOND 86400

int upgrade_pcs_plan_cfg(STRATEGY_MNG_T *pstrategymng, cJSON *root)
{
    cJSON *rootnode = NULL;
    cJSON *nodes = NULL;
    cJSON *node = NULL;
    cJSON *tmp = NULL;
    int root_cnt = 0, node_cnt = 0, i = 0, j = 0;
    
    dbg_syslog(LOG_INFO, "upgrade_pcs_plan_cfg");
    if (pstrategymng == NULL || root == NULL)
    {
        dbg_syslog(LOG_ERR, "pstrategymng:%p root:%p", pstrategymng, root);
        return -1;
    }
    root_cnt = cJSON_GetArraySize(root);
    if (pstrategymng->pStrategyTable != NULL)
    {
        free(pstrategymng->pStrategyTable);
        dbg_syslog(LOG_ERR, "pStrategyTable free");
        pstrategymng->pStrategyTable = NULL;
    }
    pstrategymng->pStrategyTable = malloc(root_cnt * sizeof(STRATEGY_REPEAT_T));
    if (pstrategymng->pStrategyTable == NULL)
    {
        return -1;
    }
    memset(pstrategymng->pStrategyTable, 0, root_cnt * sizeof(STRATEGY_REPEAT_T));
    pstrategymng->cont = root_cnt;
    for (i = 0; i < root_cnt; i++)
    {
        CHAR tembuf[32] = {0};
        rootnode = cJSON_GetArrayItem(root, i);
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].repeat, "repeat");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].priority, "priority");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.SOCmax, "SOCmax");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.SOCmin, "SOCmin");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PVmax, "pvMax");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.AgainstState, "AgainstState");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.demandState, "demandState");
		JSON_GET_NUM_PRINT_INIT_NUM(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.lgState, "lgState", 0);
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.Pset, "Pset");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.Pmlmax, "Pmlmax");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.EDD, "EDD");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.MD, "MD");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.DCI, "DCI");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.Perr, "Perr");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.K1, "K1");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.K2, "K2");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.CLCha, "chargeMode");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.Pcha, "Pcha");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.CLDischa, "DischaMode");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PDisc, "PDisc");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PCSmax, "PCSmax");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.loadTrackingLimit, "LoadTrackingLimit");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.type, TO_STRING(JSON_NAME_TYPE));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.dischargeThreshold, TO_STRING(JSON_NAME_DISCHARGE_THRESHOLD));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.chargeStartPower, TO_STRING(JSON_NAME_CHARGE_START_POWER));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.chargeEndPower, TO_STRING(JSON_NAME_CHARGE_END_POWER));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.dischargeEndThreshold, TO_STRING(JSON_NAME_DISCHARGE_END_THRESHOLD));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.dischareeEndThresholdVal, TO_STRING(JSON_NAME_DISCHARGE_THRESHOLD_OFFSET));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.tempThreshold, TO_STRING(JSON_NAME_TEMP_THRESHOLD));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.GridRateVol, "Gridvol");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PmlRecoverMax, "RecPow");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.G1, "G1");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.G1T, "G1T");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.DK2, "DK2");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.K1T, "K1T");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.DK1T, "DK1T");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.RK1, "RK1");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.RK1T, "RK1T");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.G2T, "G2T");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.GST1, "GST1");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.GST2, "GST2");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PFT1, "PFT1");
        JSON_GET_DOUBLE_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.pf, "PF");

        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.Adjpreriod, TO_STRING(JSON_NAME_ADJPRERIOD));
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PchaMax, "PchaMax");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PDiscMax, "PDiscMax");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.PvSwitch, "PvSwitch");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.socThreshold, "socThreshold");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.forbidden, "forbidden");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.MAXSupplementP , "MAXSupplementP");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.p1Margin, "p1Margin");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.pvMaxPower, "pvMaxPower");
        //以当前时间为准，提前开启代表以当前时间往延后算时间为充放电plan，Kbefor给aircond_set_timeout_after， Kafter的值给aircond_set_timeout_before
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.aircond_set_timeout_before, "Kafter");
        JSON_GET_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.aircond_set_timeout_after, "Kbefor");
        dbg_syslog(LOG_INFO, "get aircond Kbefor:%d,Kafter:%d.",pstrategymng->pStrategyTable[i].strategryTemplate.aircond_set_timeout_after,pstrategymng->pStrategyTable[i].strategryTemplate.aircond_set_timeout_before);
	    JSON_GET_DOUBLE_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.singlemax, "singlemax");        
        JSON_GET_DOUBLE_NUM_PRINT(rootnode, pstrategymng->pStrategyTable[i].strategryTemplate.singlemin, "singlemin");	
        if (pstrategymng->pStrategyTable[i].repeat != E_REPEAT_KEEP)
        {
            JSON_GET_STRING_PRINT(rootnode, tembuf, "startDate");
            get_date_by_string(tembuf, &pstrategymng->pStrategyTable[i].startDate);
            JSON_GET_STRING_PRINT(rootnode, tembuf, "endDate");
            get_date_by_string(tembuf, &pstrategymng->pStrategyTable[i].endDate);
            pstrategymng->pStrategyTable[i].endDate += ONE_DAY_SECOND;
            JSON_GET_STRING_PRINT(rootnode, tembuf, "weekly"); // todo 日期处理
            parse_week_set(tembuf, &pstrategymng->pStrategyTable[i].weekly);
        }
        nodes = cJSON_GetObjectItemCaseSensitive(rootnode, TO_STRING(JSON_NAME_PLANINFO));
        if (!nodes)
        {
            dbg_syslog(LOG_ERR, "get JSON_NAME_PLANINFO failed");
            return -1;
        }
        node_cnt = cJSON_GetArraySize(nodes);
        for (j = 0; j < node_cnt; j++)
        {
            node = cJSON_GetArrayItem(nodes, j);
            JSON_GET_STRING_PRINT(node, pstrategymng->pStrategyTable[i].strategryTemplate.PlanInfo[j].time, TO_STRING(JSON_NAME_TIME));
            JSON_GET_NUM_PRINT(node, pstrategymng->pStrategyTable[i].strategryTemplate.PlanInfo[j].power, TO_STRING(JSON_NAME_POWER));
            JSON_GET_NUM_PRINT(node, pstrategymng->pStrategyTable[i].strategryTemplate.PlanInfo[j].price, TO_STRING(JSON_NAME_PRICE));
            JSON_GET_NUM_PRINT(node, pstrategymng->pStrategyTable[i].strategryTemplate.PlanInfo[j].option, TO_STRING(JSON_NAME_OPTION));
        }
    }
    return 0;
}

int load_pcs_plan_cfg(STRATEGY_MNG_T *pstrategymng, const char *cfg_file)
{
    char *pdata = NULL;
    cJSON *root = NULL;
    if (pstrategymng == NULL || cfg_file == NULL)
    {
        dbg_syslog(LOG_ERR, "pstrategymng:%p cfg_file:%p var:%p", pstrategymng, cfg_file);
        return -1;
    }

    pdata = read_file_data(cfg_file);

    if (pdata == NULL)
    {
        dbg_syslog(LOG_ERR, "read cfg file %s error", cfg_file);

        return -1;
    }
    root = cJSON_Parse(pdata);
    if (!root)
    {
        dbg_syslog(LOG_ERR, "parse json data %s error", root);

        goto out;
    }
    upgrade_pcs_plan_cfg(pstrategymng, root);

    if (pdata != NULL)
    {
        free(pdata);
    }
out:
    cJSON_Delete(root);
    return 0;
}

int load_devInfo_cfg(pcs_ctrl_var_t *var, const char *cfg_file)
{
    char *pdata = NULL;
    cJSON *root = NULL;
    cJSON *nodes = NULL;
    cJSON *node = NULL;
    cJSON *tmp = NULL;
    int node_cnt = 0, i = 0;

    if (var == NULL || cfg_file == NULL)
    {
        dbg_syslog(LOG_ERR, "var:%p cfg_file:%p", var, cfg_file);
        return -1;
    }
    pdata = read_file_data(cfg_file);

    if (pdata == NULL)
    {
        dbg_syslog(LOG_ERR, "read pdevnodcfg file %s error", cfg_file);
        goto out;
    }
    root = cJSON_Parse(pdata);
    if (!root)
    {
        dbg_syslog(LOG_ERR, "parse pdevnodcfg file %s error", cfg_file);

        goto out;
    }
    nodes = cJSON_GetObjectItemCaseSensitive(root, "node");
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get pdevnodcfg node failed");
        goto out;
    }
    node_cnt = cJSON_GetArraySize(nodes);
    dbg_syslog(LOG_ERR, "node_cnt:%d", node_cnt);
    if (node_cnt != 0)
    {
        var->devnodeinfo.pdevnodecfg = (DEV_NODE_CFG_T *)malloc(node_cnt * sizeof(DEV_NODE_CFG_T));
        if (var->devnodeinfo.pdevnodecfg == NULL)
        {
            dbg_syslog(LOG_ERR, "malloc pdevnodcfg failed,node_cnt:%d", node_cnt);
            goto out;
        }
        var->devnodeinfo.cont = node_cnt;
        for (i = 0; i < node_cnt; i++)
        {
            node = cJSON_GetArrayItem(nodes, i);
            JSON_GET_STRING_PRINT(node, var->devnodeinfo.pdevnodecfg[i].identifier, "identifier");
            JSON_GET_STRING_PRINT(node, var->devnodeinfo.pdevnodecfg[i].devSn, "devSn");
            JSON_GET_STRING_PRINT(node, var->devnodeinfo.pdevnodecfg[i].name, "name");
        }
    }
    JSON_GET_STRING_PRINT(root, var->vir_sn_str, "devSn");
    if(strlen(var->vir_sn_str) <= 1) snprintf(var->vir_sn_str,sizeof(var->vir_sn_str),"%s_EMSCTRL",var->sn_str);
    JSON_GET_STRING_PRINT(root, var->bmsSn, "bmsSn");
    JSON_GET_STRING_PRINT(root, var->loadmeterSn, "loadmeterSn");
    if(strlen(var->loadmeterSn) <= 1) snprintf(var->loadmeterSn,sizeof(var->loadmeterSn),"virtual_loadmeter");
    JSON_GET_STRING_PRINT(root, var->gridmeterSn, "gridmeterSn");
    if(strlen(var->gridmeterSn) <= 1) snprintf(var->gridmeterSn,sizeof(var->gridmeterSn),"virtual_gridmeter");
    JSON_GET_STRING_PRINT(root, var->pcsSn, "pcsSn");
    JSON_GET_STRING_PRINT(root, var->pvpcsSn, "pvpcsSn");
    JSON_GET_STRING_PRINT(root, var->auxiSn, "auxiDISn");
    JSON_GET_STRING_PRINT(root, var->chargeStatinoSn, "chargeStatSn");
    JSON_GET_STRING_PRINT(root, var->port_type, "portType");
    JSON_GET_NUM_PRINT(root, var->chargeType, "chargeType");
    JSON_GET_NUM_PRINT(root, var->dischargeVal, "dischargeVal");
    JSON_GET_NUM_PRINT(root, var->startchargeVal, "startchargeVal");
    JSON_GET_NUM_PRINT(root, var->chargeVal, "chargeVal");
    JSON_GET_NUM_PRINT(root, var->idleVal, "idleVal");
    JSON_GET_STRING_PRINT(root, var->energyAssignSn, "energyAssignSn");
    if(strlen(var->energyAssignSn) <= 1) snprintf(var->energyAssignSn,sizeof(var->energyAssignSn),"%s_ENGASS",var->sn_str);
    if(strlen(var->pcsSn) <= 1) strcpy(var->pcsSn,var->energyAssignSn);
    JSON_GET_STRING_PRINT(root, var->guardSn, "guardSn");
    if(strlen(var->guardSn) <= 1) snprintf(var->guardSn,sizeof(var->guardSn),"%s_GUARD",var->sn_str);
    JSON_GET_STRING_PRINT(root, var->deamndSn, "deamndSn");
    if(strlen(var->deamndSn) <= 1) snprintf(var->deamndSn,sizeof(var->deamndSn),"%s_DEMAND",var->sn_str);
	JSON_GET_STRING_PRINT(root, var->multiMeterSn, "multiMeterSn");
    if(strlen(var->multiMeterSn) <= 1) snprintf(var->multiMeterSn,sizeof(var->multiMeterSn),"%s_MULMET",var->sn_str);
	JSON_GET_STRING_PRINT(root, var->diSn, "diSn");
    if(strlen(var->diSn) <= 1) snprintf(var->diSn,sizeof(var->diSn),"%s_DI",var->sn_str); // 本柜DI--combo,必须部署在6ull上
    // exnode
    nodes = cJSON_GetObjectItemCaseSensitive(root, "stateStr");
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get stateStr not exist!!");
        cJSON_Delete(root);
        return 0;
    }
    node_cnt = cJSON_GetArraySize(nodes);
    dbg_syslog(LOG_ERR, "node_cnt:%d", node_cnt);
    if (node_cnt != 0)
    {
        if (node_cnt > E_STATE_MAX)
        {
            node_cnt = E_STATE_MAX;
        }
        for (i = 0; i < node_cnt; i++)
        {
            node = cJSON_GetArrayItem(nodes, i);
            if (node == NULL)
            {
                continue;
            }
            dbg_syslog(LOG_INFO, "%s", node->valuestring);
            memcpy(var->switchStateStr[i].stateStr, node->valuestring, strlen(node->valuestring) > STATE_STR_LEN ? STATE_STR_LEN : strlen(node->valuestring));
        }
    }
    // exnode
    nodes = cJSON_GetObjectItemCaseSensitive(root, "exnode");
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get exnode not exist!!");
        cJSON_Delete(root);
        return 0;
    }
    node_cnt = cJSON_GetArraySize(nodes);
    dbg_syslog(LOG_ERR, "node_cnt:%d", node_cnt);
    if (node_cnt != 0)
    {
        var->exdevnodeinfo.pdevnodecfg = (DEV_NODE_CFG_T *)malloc(node_cnt * sizeof(DEV_NODE_CFG_T));
        if (var->exdevnodeinfo.pdevnodecfg == NULL)
        {
            dbg_syslog(LOG_ERR, "malloc pdevnodcfg failed,node_cnt:%d", node_cnt);
            goto out;
        }
        var->exdevnodeinfo.cont = node_cnt;
        for (i = 0; i < node_cnt; i++)
        {
            node = cJSON_GetArrayItem(nodes, i);
            JSON_GET_STRING_PRINT(node, var->exdevnodeinfo.pdevnodecfg[i].identifier, "identifier");
            JSON_GET_STRING_PRINT(node, var->exdevnodeinfo.pdevnodecfg[i].devSn, "devSn");
            JSON_GET_STRING_PRINT(node, var->exdevnodeinfo.pdevnodecfg[i].name, "name");
            {
                int j, tagcon = 0;
                cJSON *tagnodes = NULL;
                cJSON *tagnode = NULL;
                tagnodes = cJSON_GetObjectItemCaseSensitive(node, "tagnode");
                if (!tagnode)
                {
                    // todo 是否需要判断加载失败退出
                    tagcon = cJSON_GetArraySize(tagnodes);
                    dbg_syslog(LOG_ERR, "tagcon:%d", tagcon);
                    var->exdevnodeinfo.pdevnodecfg[i].tagNode.ptagNode = (TAG_NODE_T *)malloc(tagcon * sizeof(TAG_NODE_T));
                    if (var->exdevnodeinfo.pdevnodecfg[i].tagNode.ptagNode == NULL)
                    {
                        goto out;
                    }
                    var->exdevnodeinfo.pdevnodecfg[i].tagNode.nodecont = tagcon;
                    for (j = 0; j < tagcon; j++)
                    {
                        tagnode = cJSON_GetArrayItem(tagnodes, j);
                        JSON_GET_STRING_PRINT(tagnode, var->exdevnodeinfo.pdevnodecfg[i].tagNode.ptagNode[j].tag, "tag");
                        JSON_GET_STRING_PRINT(tagnode, var->exdevnodeinfo.pdevnodecfg[i].tagNode.ptagNode[j].name, "name");
                    }
                }
            }
        }
        nodes = cJSON_GetObjectItemCaseSensitive(root, "mqtt_broker");
        if (!nodes)
        {
            dbg_syslog(LOG_ERR, "get mqtt_broker failed");
            goto out;
        }
        GET_JSON_VALUE_STRING_LOG(nodes, "host", var->mqttBroker.hostname);
        GET_JSON_VALUE_STRING_LOG(nodes, "user", var->mqttBroker.username);
        GET_JSON_VALUE_STRING_LOG(nodes, "passwd", var->mqttBroker.password);
        GET_JSON_VALUE_INT_LOG(nodes, "port", var->mqttBroker.port);
    }

    // exnode
    nodes = cJSON_GetObjectItemCaseSensitive(root, "linkage");
    if (!nodes)
    {
        dbg_syslog(LOG_ERR, "get linkage not exist!!");
    }
    else
    {
        cJSON *subnode = NULL;
        subnode = cJSON_GetObjectItemCaseSensitive(nodes, "fire_w_g");
        if (subnode)
        {
            node_cnt = cJSON_GetArraySize(subnode);
            if (node_cnt != 0)
            {

                var->fire_w_g_lingageInfo.plingage = (LINGAGE_T *)malloc(node_cnt * sizeof(LINGAGE_T));
                if (var->fire_w_g_lingageInfo.plingage == NULL)
                {
                    dbg_syslog(LOG_ERR, "malloc plingage failed,node_cnt:%d", node_cnt);
                    goto out;
                }
                var->fire_w_g_lingageInfo.cont = node_cnt;
                for (i = 0; i < node_cnt; i++)
                {
                    node = cJSON_GetArrayItem(subnode, i);
                    JSON_GET_STRING_PRINT(node, var->fire_w_g_lingageInfo.plingage[i].identifier, "identifier");
                }
            }
        }

        subnode = cJSON_GetObjectItemCaseSensitive(nodes, "mastswitch");
        if (subnode)
        {
            node_cnt = cJSON_GetArraySize(subnode);
            if (node_cnt != 0)
            {

                var->mastswitch_lingageInfo.plingage = (LINGAGE_T *)malloc(node_cnt * sizeof(LINGAGE_T));
                if (var->mastswitch_lingageInfo.plingage == NULL)
                {
                    dbg_syslog(LOG_ERR, "malloc plingage failed,node_cnt:%d", node_cnt);
                    goto out;
                }
                var->mastswitch_lingageInfo.cont = node_cnt;
                for (i = 0; i < node_cnt; i++)
                {
                    node = cJSON_GetArrayItem(subnode, i);
                    JSON_GET_STRING_PRINT(node, var->mastswitch_lingageInfo.plingage[i].identifier, "identifier");
                    var->mastswitch_lingageInfo.plingage[i].val = 0;
                }
            }
        }
    }

    cJSON_Delete(root);
    if (pdata != NULL)
    {
        free(pdata);
    }
    return 0;
out:
    cJSON_Delete(root);
    if (pdata != NULL)
    {
        free(pdata);
    }
    if (var->devnodeinfo.pdevnodecfg)
    {
        free(var->devnodeinfo.pdevnodecfg);
    }
    if (var->exdevnodeinfo.pdevnodecfg)
    {
        free(var->exdevnodeinfo.pdevnodecfg);
    }
    if (var->fire_w_g_lingageInfo.plingage)
    {
        free(var->fire_w_g_lingageInfo.plingage);
    }
    return 0;
}

cJSON *api_create_object()
{
    cJSON *root = NULL;
    root = cJSON_CreateObject();
    if (!root)
    {
        dbg_syslog(LOG_ERR, "create api node error");
    }
    return root;
}

void get_date_p(time_t time1, BYTE *pwday)
{
    struct tm t;
    if (NULL == pwday)
    {
        return;
    }
    // t = localtime(&time1);
    localtime_r(&time1, &t);
    // *pyear = t->tm_year + 1900;
    // *pmon = t->tm_mon + 1;
    // *pday = t->tm_mday;
    *pwday = t.tm_wday;
    //dbg_syslog(LOG_ERR, "get_date:%d/%d/%d week %d\n", t.tm_year + 1900,
      //        t.tm_mon + 1, t.tm_mday, t.tm_wday);
}

int get_date_by_string(CHAR *buf, time_t *pday)
{

    struct tm t = {0};
    if (NULL == pday)
    {
        return -1;
    }
    if (NULL == strptime(buf, "%Y-%m-%d", &t))
    {
        return -1;
    }
    *pday = mktime(&t);
	if (*pday == -1) *pday = 2145888000;//32位系统time_t范围是 -2147483648到2147483647，避免溢出
    dbg_syslog(LOG_ERR, "get_date:%d/%d/%d week %d timer:%ld\n", t.tm_year + 1900,
              t.tm_mon + 1, t.tm_mday, t.tm_wday, *pday);
    return 0;
}

void get_time_p_for_air_cond(int timeout1,int timeout2,char *pbefore_timer,char *pafter_timer)
{
    time_t time_base = time(NULL);
    time_t time1 = time_base - timeout1*60;
    time_t time2 = time_base + timeout2*60;
    struct tm tNow1;
    struct tm tNow2;
    if (NULL == pbefore_timer && NULL == pafter_timer)
    {
        return;
    }
    // tNow = localtime(&time1);//localtime_r
    localtime_r(&time1, &tNow1); // localtime_r 修改；
    localtime_r(&time2, &tNow2); // localtime_r 修改；
    if (tNow1.tm_min >= 45)
    {
        sprintf(pbefore_timer, "P%02d%02d", tNow1.tm_hour, 45);
    }
    else if (tNow1.tm_min >= 30)
    {
        sprintf(pbefore_timer, "P%02d%02d", tNow1.tm_hour, 30);
    }
    else if (tNow1.tm_min >= 15)
    {
        sprintf(pbefore_timer, "P%02d%02d", tNow1.tm_hour, 15);
    }
    else
    {
        sprintf(pbefore_timer, "P%02d%02d", tNow1.tm_hour, 0);
    }

    if (tNow2.tm_min >= 45)
    {
        sprintf(pafter_timer, "P%02d%02d", tNow2.tm_hour, 45);
    }
    else if (tNow2.tm_min >= 30)
    {
        sprintf(pafter_timer, "P%02d%02d", tNow2.tm_hour, 30);
    }
    else if (tNow2.tm_min >= 15)
    {
        sprintf(pafter_timer, "P%02d%02d", tNow2.tm_hour, 15);
    }
    else
    {
        sprintf(pafter_timer, "P%02d%02d", tNow2.tm_hour, 0);
    }
    return;
}

void get_time_p(char *ptimer)
{
    time_t time1 = -1;
    struct tm tNow;
    if (NULL == ptimer)
    {
        return;
    }
    time(&time1);
    // tNow = localtime(&time1);//localtime_r
    localtime_r(&time1, &tNow); // localtime_r 修改；
    if (tNow.tm_min >= 45)
    {
        sprintf(ptimer, "P%02d%02d", tNow.tm_hour, 45);
    }
    else if (tNow.tm_min >= 30)
    {
        sprintf(ptimer, "P%02d%02d", tNow.tm_hour, 30);
    }
    else if (tNow.tm_min >= 15)
    {
        sprintf(ptimer, "P%02d%02d", tNow.tm_hour, 15);
    }
    else
    {
        sprintf(ptimer, "P%02d%02d", tNow.tm_hour, 0);
    }
    return;
}

// void jsonTest(){
//     time_t time1 =-1;
//     struct tm * tNow;
//     time(&time1);
//     char timenum[TIME_VAL_LEN]={0};
//     printf("time:%s\r\n",ctime(&time1));
//     tNow = localtime(&time1);
//     printf("year%d mon:%d day:%d hour:%d min:%d\r\n",tNow->tm_year+1900,tNow->tm_mon+1,tNow->tm_mday,tNow->tm_hour,tNow->tm_min);
//     if(tNow->tm_min > 30)
//     {
//         sprintf(timenum,"P%02d%02d",tNow->tm_hour,30);
//     }else{
//         sprintf(timenum,"P%02d%02d",tNow->tm_hour,0);
//     }
//     printf("timernum:%s\r\n",timenum);
//     PCS_CFG_T pcscfg={};
//     (&pcscfg,PCS_CFG_FILE);
// }
void jsonarrtest()
{
    int i;
    cJSON *root, *sub, *info, *PlanInfo;
    CHAR *out;
    root = cJSON_CreateObject();
    if (!root)
    {
        dbg_syslog(LOG_INFO, "root null----->");
        return;
    }
    // PlanInfo = cJSON_CreateArray();
    // if (PlanInfo == NULL)
    // {
    //     dbg_syslog(LOG_INFO,"PlanInfo null----->");
    //     return;
    // }
    sub = cJSON_CreateArray();
    if (sub == NULL)
    {
        dbg_syslog(LOG_INFO, "sub null----->");
        return;
    }
    cJSON_AddItemToObject(root, "PlanInfo", sub);
    // cJSON_AddItemToArray(root,sub);
    info = cJSON_CreateObject();
    cJSON_AddItemToArray(sub, info);
    cJSON_AddStringToObject(info, "time", "P1002");
    cJSON_AddNumberToObject(info, "power", 1);
    cJSON_AddNumberToObject(info, "price", 2);
    cJSON_AddNumberToObject(info, "option", 3);
    info = cJSON_CreateObject();
    cJSON_AddItemToArray(sub, info);
    cJSON_AddStringToObject(info, "time", "P1002");
    cJSON_AddNumberToObject(info, "power", 1);
    cJSON_AddNumberToObject(info, "price", 2);
    cJSON_AddNumberToObject(info, "option", 3);
    out = cJSON_Print(root);
    cJSON_Delete(root);
    printf(out);
    free(out);
}
// #ifdef DEBUG
// void main()
// {
//     jsonarrtest();
// }
// #endif
