#include "define.h"
#include "mqtt_emms2.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <sys/syslog.h>
#include "../ems/jsonct.h"

// 同步模板文件给站控和云平台
#define ALARM_ZH_FILE_PATH "/app/global/alarminfo/zh_CN/alarm_def.json"
#define ALARM_EN_FILE_PATH "/app/global/alarminfo/en_US/alarm_def.json"
#define GLOBAL_TEMPLATE_FILE_PATH "/app/global/template"
#define SYNC_RECORD_FILE_HEAD "/app/temp/sync_record_"
#define SYNC_RECORD_DIR     "/app/temp/"
// 获取同步记录

static int check_temp_dir(const char* dir)
{
    if (dir == NULL)
        return -1;

    if (access(dir, F_OK) != 0)
    {
        if (mkdir(dir, 0755) != 0)
        {
            ems_syslog(LOG_ERR, "MQTT check template dir fail, dir %s", dir);
            return -1;
        }
    }
    return 0;
}

static cJSON* get_sync_record_json(const mqtt_emms2_var_t* var)
{
    char file_path[256] = {0};
    char *buf = NULL;

    snprintf(file_path, sizeof(file_path), "%s%s.json", SYNC_RECORD_FILE_HEAD, var->station_id);

    buf = read_file_data(file_path);
    if (buf == NULL)
    {
        return cJSON_CreateObject();
    }
    else
    {
        cJSON* root = cJSON_Parse(buf);
        free(buf);
        if (root == NULL)
        {
            return cJSON_CreateObject();
        }
        else
        {
            return root;
        }
    }
    return NULL;
}

// 发送文件
extern int mqtt_publish_message(const mqtt_emms2_var_t* var, char* pub_topic, char* data, int data_len);

static int mqtt_upload_temp_or_alarm(const mqtt_emms2_var_t* var, const char* topic_post, const char* Funcid, const char* lang, const char* filename, const char* file_path)
{
    if (var == NULL || filename == NULL || file_path == NULL) return -1;
    if (access(file_path, F_OK) != 0) return -1;

    char* topic        = NULL;
    char* payload      = NULL;
    int   payload_size = 0;
    int   ret          = -1;

    char* file = read_file_data(file_path);
    cJSON* root = NULL;
    char* file_data = NULL;
    if (file == NULL) goto END;
    root = cJSON_Parse(file);
    if (root == NULL) goto END;
    file_data = cJSON_PrintUnformatted(root);
    if (file_data == NULL) goto END;

    topic = malloc(256);
    if (topic == NULL)
        goto END;

    payload_size = strlen(file_data) + 512;
    payload      = malloc(payload_size);

    if (payload == NULL)
        goto END;
    snprintf(topic, 256, "emms2/%s/%s/%s", topic_post, var->topic_sn, Funcid);

    snprintf(payload,
             payload_size,
             "{\"funcId\":\"%s\", \"lcSN\":\"%s\",\"seq\" : %d,\"time\" : %ld,\"lang\" : \"%s\",\"file\":\"%s\" , \"%s\":%s}",
             Funcid,
             var->topic_sn,
             var->seq,
             time(NULL),
             lang,
             filename,
             strcmp(Funcid, FUNCTION_TEMPLATE) == 0 ? "template" : "alarm",
             file_data);

    ret = mqtt_publish_message(var, topic, payload, strlen(payload));

    ems_syslog(LOG_INFO, "MQTT upload template:%s,topic %s", filename, Funcid);
END:
    if (file) free(file);
    if (file_data) free(file_data);
    if (root) cJSON_Delete(root);
    if (topic) free(topic);
    if (payload) free(payload);
    return ret;
}

// 保存同步记录
static void save_sync_record_json(const mqtt_emms2_var_t* var, cJSON* record)
{
    if (var == NULL || record == NULL)
        return;

    char* data = cJSON_Print(record);
    if (data == NULL)
    {
        ems_syslog(LOG_ERR, "MQTT save sync record json fail");
        return;
    }

    char file[256] = {0};
    snprintf(file, sizeof(file), "%s%s.json", SYNC_RECORD_FILE_HEAD, var->station_id);
    write_file_data(file, data, strlen(data));
    free(data);
}

void clear_sync_upload_queue(mqtt_emms2_var_t* var)
{
    if (var == NULL)
        return;

    sync_upload_queue_t* q = &var->sync_upload_queue;
    if (q->items != NULL)
    {
        free(q->items);
        q->items = NULL;
    }
    if (q->record != NULL)
    {
        cJSON_Delete((cJSON*)q->record);
        q->record = NULL;
    }
    q->count        = 0;
    q->capacity     = 0;
    q->cursor       = 0;
    q->last_send_ts = 0;
}

static int sync_upload_queue_push(sync_upload_queue_t* q,
                                  sync_upload_type_e type,
                                  const char* filename,
                                  const char* lang,
                                  const char* file_path,
                                  const char* md5)
{
    sync_upload_item_t* item = NULL;
    int                 i;

    if (q == NULL || filename == NULL || lang == NULL || file_path == NULL || md5 == NULL)
        return -1;

    /* 按 type + filename + lang 去重，同模板多设备只上报一次 */
    for (i = 0; i < q->count; i++)
    {
        if (q->items[i].type == type &&
            strcmp(q->items[i].filename, filename) == 0 &&
            strcmp(q->items[i].lang, lang) == 0)
        {
            return 0;
        }
    }

    if (q->count >= q->capacity)
    {
        int                 new_cap = (q->capacity == 0) ? SYNC_UPLOAD_QUEUE_INIT_CAP : (q->capacity * 2);
        sync_upload_item_t* neu     = (sync_upload_item_t*)realloc(q->items, (size_t)new_cap * sizeof(sync_upload_item_t));
        if (neu == NULL)
        {
            ems_syslog(LOG_ERR, "MQTT sync upload queue realloc fail");
            return -1;
        }
        q->items    = neu;
        q->capacity = new_cap;
    }

    item = &q->items[q->count];
    memset(item, 0, sizeof(*item));
    item->type = type;
    snprintf(item->filename, sizeof(item->filename), "%s", filename);
    snprintf(item->lang, sizeof(item->lang), "%s", lang);
    snprintf(item->file_path, sizeof(item->file_path), "%s", file_path);
    snprintf(item->md5, sizeof(item->md5), "%s", md5);
    q->count++;
    return 0;
}

/* 设备模板：同文件名+语言去重；MD5 未变化则跳过 */
static int enqueue_device_template(mqtt_emms2_var_t* var, const char* filename, cJSON* record)
{
    char        file_path[256] = {0};
    char        md5[33]        = {0};
    const char* languages[2]   = {"zh_CN", "en_US"};
    int         i;

    if (var == NULL || filename == NULL || record == NULL)
        return -1;

    for (i = 0; i < 2; i++)
    {
        cJSON* item      = NULL;
        cJSON* lang_item = NULL;

        snprintf(file_path, sizeof(file_path), "%s/%s/%s", GLOBAL_TEMPLATE_FILE_PATH, languages[i], filename);
        if (access(file_path, F_OK) != 0)
            continue;

        get_file_md5(file_path, md5);
        item = cJSON_GetObjectItem(record, filename);
        if (item != NULL)
            lang_item = cJSON_GetObjectItem(item, languages[i]);

        if (lang_item != NULL && cJSON_IsString(lang_item) && strcmp(lang_item->valuestring, md5) == 0)
            continue;

        sync_upload_queue_push(&var->sync_upload_queue,
                               SYNC_UPLOAD_TYPE_TEMPLATE,
                               filename,
                               languages[i],
                               file_path,
                               md5);
    }
    return 0;
}

/* EMS 总模板 / 告警：按 MD5 变化才入队 */
static int enqueue_ems_template_if_needed(mqtt_emms2_var_t* var, cJSON* record)
{
    char  file_path[128] = {0};
    char  md5[33]        = {0};
    char  language[8]    = {0};
    char* lang           = NULL;
    cJSON* item          = NULL;

    if (var == NULL || record == NULL)
        return -1;

    lang = getenv("LANG");
    if (lang != NULL)
        sscanf(lang, "%[^.]", language);
    if (strlen(language) != 5)
        snprintf(language, sizeof(language), "zh_CN");

    snprintf(file_path, sizeof(file_path), "%s/%s", TEMPLATE_DIR, EMS_TEMP_MASTER_FILE);
    if (access(file_path, F_OK) != 0)
        return -1;
    get_file_md5(file_path, md5);

    item = cJSON_GetObjectItem(record, EMS_TEMP_MASTER_FILE);
    if (item == NULL || !cJSON_IsString(item) || strcmp(item->valuestring, md5) != 0)
    {
        sync_upload_queue_push(&var->sync_upload_queue,
                               SYNC_UPLOAD_TYPE_EMS_TEMPLATE,
                               EMS_TEMP_MASTER_FILE,
                               language,
                               file_path,
                               md5);
    }
    return 0;
}

static int enqueue_alarms_if_needed(mqtt_emms2_var_t* var, cJSON* record)
{
    char        md5[33]       = {0};
    const char* filename      = "alarm_def.json";
    const char* file_paths[2] = {ALARM_ZH_FILE_PATH, ALARM_EN_FILE_PATH};
    const char* languages[2]  = {"zh_CN", "en_US"};
    int         i;

    if (var == NULL || record == NULL)
        return -1;

    for (i = 0; i < 2; i++)
    {
        cJSON* item      = NULL;
        cJSON* lang_item = NULL;

        if (access(file_paths[i], F_OK) != 0)
        {
            ems_syslog(LOG_NOTICE, "MQTT upload alarm file , file %s not exist", file_paths[i]);
            continue;
        }

        get_file_md5(file_paths[i], md5);
        item = cJSON_GetObjectItem(record, filename);
        if (item != NULL)
            lang_item = cJSON_GetObjectItem(item, languages[i]);

        if (lang_item == NULL || !cJSON_IsString(lang_item) || strcmp(lang_item->valuestring, md5) != 0)
        {
            sync_upload_queue_push(&var->sync_upload_queue,
                                   SYNC_UPLOAD_TYPE_ALARM,
                                   filename,
                                   languages[i],
                                   file_paths[i],
                                   md5);
        }
    }
    return 0;
}

static void update_sync_record_after_upload(cJSON* record, const sync_upload_item_t* item)
{
    cJSON* obj = NULL;

    if (record == NULL || item == NULL)
        return;

    if (item->type == SYNC_UPLOAD_TYPE_EMS_TEMPLATE)
    {
        cJSON* old = cJSON_GetObjectItem(record, item->filename);
        if (old == NULL)
            cJSON_AddStringToObject(record, item->filename, item->md5);
        else
            cJSON_ReplaceItemInObject(record, item->filename, cJSON_CreateString(item->md5));
        return;
    }

    obj = cJSON_GetObjectItem(record, item->filename);
    if (obj == NULL)
    {
        obj = cJSON_CreateObject();
        cJSON_AddItemToObject(record, item->filename, obj);
        cJSON_AddStringToObject(obj, item->lang, item->md5);
    }
    else
    {
        cJSON* lang_item = cJSON_GetObjectItem(obj, item->lang);
        if (lang_item == NULL)
            cJSON_AddStringToObject(obj, item->lang, item->md5);
        else
            cJSON_ReplaceItemInObject(obj, item->lang, cJSON_CreateString(item->md5));
    }
}

cJSON* get_device_config()
{
    cJSON* root = NULL;
    char file_path[256] = {0};
    snprintf(file_path, sizeof(file_path), "%s/%s", CONFIG_PATH, COLLECTOR_DEVICE);
    char* data = read_file_data(file_path);
    if (data == NULL)
    {
        ems_syslog(LOG_ERR, "MQTT get device config fail");
        goto END;
    }
    root = cJSON_Parse(data);
    free(data);

    if (get_cabinet_info()->ctrl_mode)  //主从模式需要查看从机设备配置
    {
        char* data = read_file_data(EMS_LC_ALL_DEVICE_CFG);
        if (data != NULL)
        {
            
            cJSON* lc_root = cJSON_Parse(data);
            if (lc_root != NULL)
            {
                cJSON* root_dev = cJSON_GetObjectItem(root, "dev_class");
                if (root_dev == NULL)
                {
                    root_dev = cJSON_CreateArray();
                    cJSON_AddItemToObject(root, "dev_class", root_dev);
                }
                cJSON* lc_devs = cJSON_GetObjectItem(lc_root, "dev_class");
                if (lc_devs != NULL)
                {
                    int size = cJSON_GetArraySize(lc_devs);
                    while (size > 0)
                    {
                        cJSON* obj = cJSON_DetachItemFromArray(lc_devs, 0);
                        cJSON_AddItemToArray(root_dev, obj);
                        size = cJSON_GetArraySize(lc_devs);
                    }
                }
                cJSON_Delete(lc_root);
            }
            free(data);
        }
    }
END:
    return root;
}

// 检查并收集待上传的告警和模板文件(入队，不立即发送)
int check_and_upload_templates_and_alarm(mqtt_emms2_var_t* var)
{
    cJSON* record          = NULL;
    cJSON* root            = NULL;
    cJSON* dev_class       = NULL;
    int    dev_class_size  = 0;
    int    i;

    if (var == NULL)
        return -1;
    if (check_temp_dir(SYNC_RECORD_DIR) < 0)
        return -1;

    /* 重登时丢弃未发完的旧队列，按当前配置重新收集 */
    clear_sync_upload_queue(var);

    record = get_sync_record_json(var);
    root   = get_device_config();
    if (root == NULL)
        goto END;

    dev_class = cJSON_GetObjectItem(root, "dev_class");
    if (dev_class == NULL || !cJSON_IsArray(dev_class) || cJSON_GetArraySize(dev_class) == 0)
        goto END;

    dev_class_size = cJSON_GetArraySize(dev_class);
    for (i = 0; i < dev_class_size; i++)
    {
        cJSON* dev_class_item = cJSON_GetArrayItem(dev_class, i);
        cJSON* type           = NULL;
        cJSON* devs           = NULL;
        int    dev_size       = 0;
        int    j;

        if (dev_class_item == NULL)
            continue;
        type = cJSON_GetObjectItem(dev_class_item, "type");
        if (type == NULL || !cJSON_IsString(type) || strlen(type->valuestring) == 0 ||
            strcmp(type->valuestring, "CELL") == 0)
        {
            continue;
        }

        devs = cJSON_GetObjectItem(dev_class_item, "devs");
        if (devs == NULL || !cJSON_IsArray(devs))
            continue;

        dev_size = cJSON_GetArraySize(devs);
        for (j = 0; j < dev_size; j++)
        {
            cJSON* dev      = cJSON_GetArrayItem(devs, j);
            cJSON* template = NULL;
            char*  file_name = NULL;

            if (dev == NULL || !cJSON_IsObject(dev))
                continue;
            template = cJSON_GetObjectItem(dev, "template");
            if (template == NULL || !cJSON_IsString(template) || strlen(template->valuestring) == 0)
                continue;

            if (template->valuestring[0] == '/') /* 绝对路径 */
                file_name = strrchr(template->valuestring, '/') + 1;
            else
                file_name = template->valuestring;

            /* 同模板多设备：push 内按 filename+lang 去重 */
            enqueue_device_template(var, file_name, record);
        }
    }

    enqueue_ems_template_if_needed(var, record);
    if (strcmp(var->station_id, MQTT_STACTRL_STATION_ID) == 0)
        enqueue_alarms_if_needed(var, record);

    if (var->sync_upload_queue.count > 0)
    {
        var->sync_upload_queue.record       = record;
        var->sync_upload_queue.cursor       = 0;
        var->sync_upload_queue.last_send_ts = 0;
        record                              = NULL; /* 所有权交给队列 */
        ems_syslog(LOG_WARNING,
                   "MQTT sync upload queue ready, count=%d, interval=%ds",
                   var->sync_upload_queue.count,
                   SYNC_UPLOAD_INTERVAL_SEC);
    }

END:
    if (record)
        cJSON_Delete(record);
    if (root)
        cJSON_Delete(root);
    return 0;
}

/* 心跳态匀速 drain：默认每秒最多发 SYNC_UPLOAD_BATCH_PER_TICK 条 */
int drain_sync_upload_queue(mqtt_emms2_var_t* var)
{
    sync_upload_queue_t* q      = NULL;
    time_t               now    = 0;
    int                  sent   = 0;
    const char*          funcid = NULL;

    if (var == NULL)
        return -1;

    q = &var->sync_upload_queue;
    if (q->items == NULL || q->cursor >= q->count)
        return 0;

    now = time(NULL);
    if (q->last_send_ts != 0 && (now - q->last_send_ts) < SYNC_UPLOAD_INTERVAL_SEC)
        return 0;

    while (sent < SYNC_UPLOAD_BATCH_PER_TICK && q->cursor < q->count)
    {
        sync_upload_item_t* item = &q->items[q->cursor];
        int                 ret;

        if (item->type == SYNC_UPLOAD_TYPE_ALARM)
            funcid = FUNCTION_ALARMFILE;
        else
            funcid = FUNCTION_TEMPLATE;

        ret = mqtt_upload_temp_or_alarm(var, TYPE_POST, funcid, item->lang, item->filename, item->file_path);
        if (ret != 0)
        {
            ems_syslog(LOG_ERR,
                       "MQTT sync upload fail, file=%s lang=%s, will retry",
                       item->filename,
                       item->lang);
            q->last_send_ts = now;
            break;
        }

        if (q->record != NULL)
        {
            update_sync_record_after_upload((cJSON*)q->record, item);
            save_sync_record_json(var, (cJSON*)q->record);
        }

        ems_syslog(LOG_INFO,
                   "MQTT sync upload ok [%d/%d] file=%s lang=%s",
                   q->cursor + 1,
                   q->count,
                   item->filename,
                   item->lang);

        q->cursor++;
        sent++;
        q->last_send_ts = now;
    }

    if (q->cursor >= q->count)
    {
        ems_syslog(LOG_WARNING, "MQTT sync upload queue finished, total=%d", q->count);
        clear_sync_upload_queue(var);
    }
    return 0;
}

int upload_template_by_dev_no(const mqtt_emms2_var_t* var, const char* dev_no, const char* languages, char* topic_post)
{
    char   cfg_path[256]     = {0};
    char   file_path[256]    = {0};
    char*  device_cfg_str    = NULL;
    int    ret               = -1;

    // 解析 dev_no：如果包含 '.' 则为从机设备（如 LC.BMS → 从机 LC，设备 BMS）
    // 否则为本机设备（如 GRID_METER）
    const char* dot = strchr(dev_no, '.');
    if (dot != NULL)
    {
        // 从机设备：去 /app/config/lc_devs/{从机名}/device_config.json 查找
        int lc_name_len = dot - dev_no;
        if (lc_name_len <= 0 || lc_name_len >= (int)(sizeof(cfg_path) - 64))
            return -1;
        snprintf(cfg_path, sizeof(cfg_path), CONFIG_PATH"/lc_devs/%.*s/device_config.json", lc_name_len, dev_no);
    }
    else
    {
        // 本机设备：去 /app/config/device_config.json 查找
        snprintf(cfg_path, sizeof(cfg_path), CONFIG_PATH"/device_config.json");
    }

    device_cfg_str = read_file_data(cfg_path);
    cJSON* root = cJSON_Parse(device_cfg_str);
    if (root == NULL) goto END;

    // 去掉前缀后的设备名用于匹配
    const char* match_no = (dot != NULL) ? (dot + 1) : dev_no;

    cJSON* dev_class = cJSON_GetObjectItem(root, "dev_class");
    if (dev_class != NULL && cJSON_IsArray(dev_class) && cJSON_GetArraySize(dev_class) > 0)
    {
        int dev_class_size = cJSON_GetArraySize(dev_class);
        for (int i = 0; i < dev_class_size; i++)
        {
            cJSON* dev_class_item = cJSON_GetArrayItem(dev_class, i);
            if (dev_class_item == NULL) continue;

            cJSON* devs = cJSON_GetObjectItem(dev_class_item, "devs");
            if (devs == NULL || !cJSON_IsArray(devs)) continue;

            int dev_size = cJSON_GetArraySize(devs);
            for (int j = 0; j < dev_size; j++)
            {
                cJSON* dev = cJSON_GetArrayItem(devs, j);
                if (dev == NULL || !cJSON_IsObject(dev)) continue;

                cJSON* no = cJSON_GetObjectItem(dev, "no");
                if (no == NULL || !cJSON_IsString(no) || strcmp(no->valuestring, match_no) != 0)
                    continue;

                cJSON* template = cJSON_GetObjectItem(dev, "template");
                if (template == NULL || !cJSON_IsString(template) || strlen(template->valuestring) == 0)
                    continue;

                char* file_name = NULL;
                if (template->valuestring[0] == '/') //绝对路径
                {
                    file_name = strrchr(template->valuestring, '/') + 1;
                }
                else
                {
                    file_name = template->valuestring;
                }
                snprintf(file_path, sizeof(file_path), "%s/%s/%s", GLOBAL_TEMPLATE_FILE_PATH, languages, file_name);
                if (mqtt_upload_temp_or_alarm(var, TYPE_GET_RESP, FUNCTION_TEMPLATE, languages, file_name, file_path) == 0)
                {
                    ret = 0;
                }
                goto END;
            }
        }
    }

END:
    if (device_cfg_str) free(device_cfg_str);
    if (root) cJSON_Delete(root);
    return ret;
}

int upload_alarminfo_by_language(const mqtt_emms2_var_t* var, const char* lang, char* topic_post)
{
    if (var == NULL)
        return -1;

    const char* filename      = "alarm_def.json";
    const char* file_paths[2] = {ALARM_ZH_FILE_PATH, ALARM_EN_FILE_PATH};
    const char* languages[2]  = {"zh_CN", "en_US"};

    int ret = -1;
    for (int i = 0; i < 2; i++)
    {
        if (strcmp(lang, languages[i]) != 0) continue;

        if (access(file_paths[i], F_OK) != 0)
        {
            ems_syslog(LOG_NOTICE, "MQTT upload alarm file , file %s not exist", file_paths[i]);
            continue;
        }

        if (mqtt_upload_temp_or_alarm(var, topic_post, FUNCTION_ALARMFILE, languages[i], filename, file_paths[i]) == 0)
        {
            ret = 0;
        }
    }
    return ret;
}

int upload_template_request(const mqtt_emms2_var_t* var, cJSON* info)
{
    cJSON* dev_no    = cJSON_GetObjectItem(info, "dev_no");
    cJSON* languages = cJSON_GetObjectItem(info, "lang");
    if (dev_no == NULL || dev_no->valuestring == NULL || dev_no->valuestring[0] == '\0' ||
        languages == NULL || languages->valuestring == NULL || languages->valuestring[0] == '\0')
        return -1;
    return upload_template_by_dev_no(var, dev_no->valuestring, languages->valuestring, TYPE_GET_RESP);
}

int upload_alarm_requset(const mqtt_emms2_var_t* var, cJSON* info)
{
    cJSON* languages = cJSON_GetObjectItem(info, "lang");
    if (languages == NULL || languages->valuestring == NULL || languages->valuestring[0] == '\0')
        return -1;
    return upload_alarminfo_by_language(var, languages->valuestring,TYPE_GET_RESP);
}

int check_and_clear_upload_record(char *mqtt_id, cJSON* config)
{
    if (mqtt_id == NULL || config == NULL) return -1;
    cJSON *new_config = config;
    if (new_config == NULL) return -1;


    char file[256] = {0};
    cJSON *new_host = NULL;
    cJSON *new_port = NULL;
    char *old_config_file = NULL;
    cJSON *old_config = NULL;
    cJSON *old_host = NULL;
    cJSON *old_port = NULL;

    new_host = cJSON_GetObjectItem(new_config, "host");
    new_port = cJSON_GetObjectItem(new_config, "port");

    if (new_host == NULL || new_host->valuestring == NULL || new_host->valuestring[0] == '\0' ||
         new_port == NULL || new_port->valueint == 0)
            goto END;
    if (strcmp(mqtt_id, MQTT_EMMS2_STATION_ID) == 0) 
    {
        old_config_file = read_file_data(MQTT_EMMS2_CONFIG_PATH);
    }
    else if(strcmp(mqtt_id, MQTT_STACTRL_STATION_ID) == 0) {
        old_config_file = read_file_data(MQTT_STACTRL_CONFIG_PATH);
    }
    if (old_config_file == NULL)
        goto END;

    old_config = cJSON_Parse(old_config_file);
    if (old_config == NULL)
        goto END;

    old_host = cJSON_GetObjectItem(old_config, "host");
    old_port = cJSON_GetObjectItem(old_config, "port");

    if (old_host == NULL || old_host->valuestring == NULL || old_port == NULL ||
        strcmp(new_host->valuestring, old_host->valuestring) != 0 ||
        new_port->valueint != old_port->valueint) 
    {
        snprintf(file, sizeof(file), "%s%s.json", SYNC_RECORD_FILE_HEAD, mqtt_id);
        if (access(file, F_OK) == 0) 
        {
            remove(file);
            return 0;
        }
    }

END:
  if (old_config) cJSON_Delete(old_config);
  if (old_config_file) free(old_config_file);
  return -1;
}