#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <time.h>
#include <cjson/cJSON.h>

#include "log.h"
#include "json_interface.h"

typedef const char *(*StructToJsonCb)(void *pStruct);
typedef int (*JsonToStructCb)(const char *pJsonStr, void **pStruct);
typedef void (*Base64Code)(void *pStruct, int enCode);

typedef struct {
    JSON_ENGINE_TYPE    typeId;
    StructToJsonCb      s2jCb;
    JsonToStructCb      j2sCb;
    Base64Code          base64Cb;
} JSON_ENGINE, *PJSON_ENGINE;

static const char *__interface_encode(void *pData)
{
    const char     *pJsonS;
    PJSON_INTERFACE p     = (PJSON_INTERFACE)pData;
    cJSON          *pRoot = cJSON_CreateObject();

    if(!p) {
        return NULL;
    }

    cJSON_AddNumberToObject(pRoot, "cmdId",         p->cmdId);
    cJSON_AddNumberToObject(pRoot, "ver",           INTERFACE_VERSINO);
    cJSON_AddNumberToObject(pRoot, "cryptoType",    p->cryptoType);
    cJSON_AddNumberToObject(pRoot, "timeStamp",     time((time_t *)NULL));

    if(p->msgContent) {
        cJSON_AddStringToObject(pRoot, "msgContent",    p->msgContent);
    }

    pJsonS  = cJSON_Print(pRoot);
    cJSON_Delete(pRoot);
    return pJsonS;
}

static int __interface_decode(const char *pJsonS, void **pStruct)
{
    cJSON  *pRoot, *pVal;
    PJSON_INTERFACE pData;
    *pStruct = malloc(sizeof(JSON_INTERFACE));

    if(*pStruct == NULL) {
        return -RET_INPUTERR;
    }

    pData = (PJSON_INTERFACE) * pStruct;
    pRoot = cJSON_Parse(pJsonS);

    if(!pRoot) {
        return -RET_SYSERR;
    }

    memset(pData, 0, sizeof(JSON_INTERFACE));
    pVal = cJSON_GetObjectItem(pRoot, "cmdId");

    if(cJSON_IsNumber(pVal)) {
        pData->cmdId = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "ver");

    if(cJSON_IsNumber(pVal)) {
        pData->ver = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "cryptoType");

    if(cJSON_IsNumber(pVal)) {
        pData->cryptoType = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "timeStamp");

    if(cJSON_IsNumber(pVal)) {
        pData->timeStamp = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "msgContent");

    if(cJSON_IsString(pVal)) {
        pData->msgContent = strdup(pVal->valuestring);
    }

    cJSON_Delete(pRoot);
    return RET_OK;
}

static const char *__obj_add_encode(void *pData)
{
    const char     *pJsonS;
    PIFC_RET_MSG p         = (PIFC_RET_MSG)pData;
    cJSON           *pRoot = cJSON_CreateObject();

    if(!p) {
        return NULL;
    }

    cJSON_AddNumberToObject(pRoot, "retCode",    p->ret_code);

    if(p->mesg) {
        cJSON_AddStringToObject(pRoot, "mesg",    p->mesg);
    }

    if(p->n_items > 0) {
        cJSON *pArray = cJSON_AddArrayToObject(pRoot, "data");

        if(pArray) {
            int i;

            for(i = 0; i < p->n_items; i++) {
                cJSON *pItem = cJSON_CreateObject();

                if(!pItem) {
                    continue;
                }

                cJSON_AddStringToObject(pItem, "name",      p->data[i].name);
                cJSON_AddNumberToObject(pItem, "retCode",  p->data[i].ret_code);

                if(p->data[i].mesg) {
                    cJSON_AddStringToObject(pItem, "mesg", p->data[i].mesg);
                }

                cJSON_AddItemToArray(pArray, pItem);
            }
        }
    }

    pJsonS  = cJSON_Print(pRoot);
    cJSON_Delete(pRoot);
    return pJsonS;
}

static int __obj_add_decode(const char *pJsonS, void **pStruct)
{
    cJSON  *pRoot, *pVal;
    PIFACE_ADD_OBJ pData;
    int arraySize;
    int i, j;
    *pStruct = malloc(sizeof(IFACE_ADD_OBJ));

    if(*pStruct == NULL) {
        return -RET_NOMEM;
    }

    pData = (PIFACE_ADD_OBJ) * pStruct;
    pRoot = cJSON_Parse(pJsonS);

    if(!pRoot) {
        return -RET_SYSERR;
    }

    if(!cJSON_IsArray(pRoot)) {
        cJSON_Delete(pRoot);
        return -RET_INPUTERR;
    }

    memset(pData, 0, sizeof(IFACE_ADD_OBJ));
    arraySize = cJSON_GetArraySize(pRoot);
    pData->pCtx = (PIFC_ADD_CTX)malloc(sizeof(IFC_ADD_CTX) * arraySize);

    if(pData->pCtx == NULL) {
        LOG_EX(LOG_Error, "Malloc memory %d error\n", sizeof(IFC_ADD_CTX) * arraySize);
        cJSON_Delete(pRoot);
        return -RET_NOMEM;
    }

    memset(pData->pCtx, 0, sizeof(IFC_ADD_CTX) * arraySize);

    for(i = 0; i < arraySize; i++) {
        pData->pCtx[i].pObj = malloc(sizeof(CMHI_OBJECT));

        if(pData->pCtx[i].pObj == NULL) {
            for(j = 0; j < i; j++) {
                if(pData->pCtx[j].pObj) {
                    free(pData->pCtx[j].pObj);
                }
            }

            LOG_EX(LOG_Error, "Malloc memory (%d):%d error\n", i,
                   sizeof(CMHI_OBJECT) * arraySize);
            cJSON_Delete(pRoot);
            free(pData->pCtx);
            return -RET_NOMEM;
        }

        memset(pData->pCtx[i].pObj, 0, sizeof(CMHI_OBJECT));
    }

    pData->n_obj = arraySize;

    for(i = 0; i < arraySize; i++) {
        PCMHI_OBJECT pObj = pData->pCtx[i].pObj;
        POBJECT_K pObjK = &pData->pCtx[i].objk;
        cJSON *pSub = cJSON_GetArrayItem(pRoot, i);
        cJSON *pSubContent = cJSON_GetObjectItem(pSub, "objContent");

        if(!cJSON_IsArray(pSubContent)) {
            LOG_EX(LOG_Error, "Don't found (objContent) content\n");
            cJSON_Delete(pRoot);

            for(j = 0; j < arraySize; j++) {
                if(pData->pCtx[j].pObj) {
                    free(pData->pCtx[j].pObj);
                }
            }

            free(pData->pCtx);
            return -RET_INPUTERR;
        }

        pObjK->ctx_num = cJSON_GetArraySize(pSubContent);

        if(pObjK->ctx_num <= 0) {
            LOG_EX(LOG_Error, "The objContent has no member\n");

            for(j = 0; j < arraySize; j++) {
                if(pData->pCtx[j].pObj) {
                    free(pData->pCtx[j].pObj);
                }
            }

            free(pData->pCtx);
            cJSON_Delete(pRoot);
            return -RET_INPUTERR;
        }

        pVal = cJSON_GetObjectItem(pSub, "prio");

        if(cJSON_IsNumber(pVal)) {
            pObj->prio = pVal->valueint;
        }

        pVal = cJSON_GetObjectItem(pSub, "type");

        if(cJSON_IsNumber(pVal)) {
            pObjK->type = pVal->valueint;
        }

        pVal = cJSON_GetObjectItem(pSub, "name");

        if(cJSON_IsString(pVal)) {
            strncpy(pObj->name, pVal->valuestring, MAX_NAME_LEN - 1);
        }

        pVal = cJSON_GetObjectItem(pSub, "desc");

        if(cJSON_IsString(pVal)) {
            strncpy(pObj->desc, pVal->valuestring, MAX_DESC - 1);
        }

        for(j = 0; j < pObjK->ctx_num; j++) {
            cJSON *pItem = cJSON_GetArrayItem(pSubContent, j);

            switch(pObjK->type / 10) {
                case OBJ_TYPE_SERVER:
                    pVal = cJSON_GetObjectItem(pItem, "proType");

                    if(cJSON_IsNumber(pVal)) {
                        pObjK->objs.svr_obj[j].pro_type = pVal->valueint;
                    }

                    pVal = cJSON_GetObjectItem(pItem, "porPort");

                    if(cJSON_IsString(pVal)) {
                        pObjK->objs.svr_obj[j].str_val = strdup(pVal->valuestring);
                    }

                    break;

                case OBJ_TYPE_ADDR:
                    pVal = cJSON_GetObjectItem(pItem, "ipAddr");

                    if(cJSON_IsString(pVal)) {
                        pObjK->objs.addr_obj[j].str_val = strdup(pVal->valuestring);
                    }

                    break;

                case OBJ_TYPE_DATETIME:
                    pVal = cJSON_GetObjectItem(pItem, "repType");

                    if(cJSON_IsNumber(pVal)) {
                        pObjK->objs.dt_obj[j].rep_mode = pVal->valueint;
                    }

                    pVal = cJSON_GetObjectItem(pItem, "timeValue");

                    if(cJSON_IsString(pVal)) {
                        pObjK->objs.dt_obj[j].str_val = strdup(pVal->valuestring);
                    }

                    break;
            }
        }
    }

    cJSON_Delete(pRoot);
    return RET_OK;
}

static const char *__obj_del_encode(void *pData)
{
    const char     *pJsonS;
    PIFC_RET_MSG p         = (PIFC_RET_MSG)pData;
    cJSON           *pRoot = cJSON_CreateObject();

    if(!p) {
        return NULL;
    }

    cJSON_AddNumberToObject(pRoot, "retCode",    p->ret_code);

    if(p->mesg) {
        cJSON_AddStringToObject(pRoot, "mesg",    p->mesg);
    }

    if(p->n_items > 0) {
        cJSON *pArray = cJSON_AddArrayToObject(pRoot, "data");

        if(pArray) {
            int i;

            for(i = 0; i < p->n_items; i++) {
                cJSON *pItem = cJSON_CreateObject();

                if(!pItem) {
                    continue;
                }

                cJSON_AddStringToObject(pItem, "name",      p->data[i].name);
                cJSON_AddNumberToObject(pItem, "retCode",  p->data[i].ret_code);

                if(p->data[i].mesg) {
                    cJSON_AddStringToObject(pItem, "mesg", p->data[i].mesg);
                }

                cJSON_AddItemToArray(pArray, pItem);
            }
        }
    }

    pJsonS  = cJSON_Print(pRoot);
    cJSON_Delete(pRoot);
    return pJsonS;
}

static int __obj_del_decode(const char *pJsonS, void **pStruct)
{
    cJSON  *pRoot;
    PIFACE_DEL_OBJ pData;
    int arraySize;
    int i;
    *pStruct = malloc(sizeof(IFACE_DEL_OBJ));

    if(*pStruct == NULL) {
        return -RET_NOMEM;
    }

    pData = (PIFACE_DEL_OBJ) * pStruct;
    pRoot = cJSON_Parse(pJsonS);

    if(!pRoot) {
        return -RET_SYSERR;
    }

    if(!cJSON_IsArray(pRoot)) {
        cJSON_Delete(pRoot);
        return -RET_INPUTERR;
    }

    memset(pData, 0, sizeof(IFACE_ADD_OBJ));
    arraySize = cJSON_GetArraySize(pRoot);
    pData->n_obj = arraySize;

    for(i = 0; i < arraySize; i++) {
        cJSON *pSub = cJSON_GetArrayItem(pRoot, i);

        if(pSub) {
            cJSON *pVal = cJSON_GetObjectItem(pSub, "name");

            if(cJSON_IsString(pVal)) {
                strncpy(pData->name[i], pVal->valuestring, MAX_NAME_LEN - 1);
            }
        }
    }

    cJSON_Delete(pRoot);
    return RET_OK;
}

static const char *__obj_mod_encode(void *pData)
{
    const char     *pJsonS;
    PIFC_RET_MSG p         = (PIFC_RET_MSG)pData;
    cJSON           *pRoot = cJSON_CreateObject();

    if(!p) {
        return NULL;
    }

    cJSON_AddNumberToObject(pRoot, "retCode",    p->ret_code);

    if(p->mesg) {
        cJSON_AddStringToObject(pRoot, "mesg",    p->mesg);
    }

    if(p->n_items > 0) {
        cJSON *pArray = cJSON_AddArrayToObject(pRoot, "data");

        if(pArray) {
            int i;

            for(i = 0; i < p->n_items; i++) {
                cJSON *pItem = cJSON_CreateObject();

                if(!pItem) {
                    continue;
                }

                cJSON_AddStringToObject(pItem, "name",      p->data[i].name);
                cJSON_AddNumberToObject(pItem, "retCode",  p->data[i].ret_code);

                if(p->data[i].mesg) {
                    cJSON_AddStringToObject(pItem, "mesg", p->data[i].mesg);
                }

                cJSON_AddItemToArray(pArray, pItem);
            }
        }
    }

    pJsonS  = cJSON_Print(pRoot);
    cJSON_Delete(pRoot);
    return pJsonS;
}

static int __obj_mod_decode(const char *pJsonS, void **pStruct)
{
    cJSON  *pRoot, *pVal;
    PIFACE_ADD_OBJ pData;
    int arraySize;
    int i, j;
    *pStruct = malloc(sizeof(IFACE_ADD_OBJ));

    if(*pStruct == NULL) {
        return -RET_NOMEM;
    }

    pData = (PIFACE_ADD_OBJ) * pStruct;
    pRoot = cJSON_Parse(pJsonS);

    if(!pRoot) {
        return -RET_SYSERR;
    }

    if(!cJSON_IsArray(pRoot)) {
        cJSON_Delete(pRoot);
        return -RET_INPUTERR;
    }

    memset(pData, 0, sizeof(IFACE_ADD_OBJ));
    arraySize = cJSON_GetArraySize(pRoot);
    pData->pCtx = (PIFC_ADD_CTX)malloc(sizeof(IFC_ADD_CTX) * arraySize);

    if(pData->pCtx == NULL) {
        LOG_EX(LOG_Error, "Malloc memory %d error\n", sizeof(IFC_ADD_CTX) * arraySize);
        cJSON_Delete(pRoot);
        return -RET_NOMEM;
    }

    memset(pData->pCtx, 0, sizeof(IFC_ADD_CTX) * arraySize);

    for(i = 0; i < arraySize; i++) {
        pData->pCtx[i].pObj = malloc(sizeof(CMHI_OBJECT));

        if(pData->pCtx[i].pObj == NULL) {
            for(j = 0; j < i; j++) {
                if(pData->pCtx[j].pObj) {
                    free(pData->pCtx[j].pObj);
                }
            }

            LOG_EX(LOG_Error, "Malloc memory (%d):%d error\n", i,
                   sizeof(CMHI_OBJECT) * arraySize);
            cJSON_Delete(pRoot);
            free(pData->pCtx);
            return -RET_NOMEM;
        }

        memset(pData->pCtx[i].pObj, 0, sizeof(CMHI_OBJECT));
    }

    pData->n_obj = arraySize;

    for(i = 0; i < arraySize; i++) {
        PCMHI_OBJECT pObj = pData->pCtx[i].pObj;
        POBJECT_K pObjK = &pData->pCtx[i].objk;
        cJSON *pSub = cJSON_GetArrayItem(pRoot, i);
        cJSON *pSubContent = cJSON_GetObjectItem(pSub, "objContent");

        if(!cJSON_IsArray(pSubContent)) {
            LOG_EX(LOG_Error, "Don't found (objContent) content\n");
            cJSON_Delete(pRoot);

            for(j = 0; j < arraySize; j++) {
                if(pData->pCtx[j].pObj) {
                    free(pData->pCtx[j].pObj);
                }
            }

            free(pData->pCtx);
            return -RET_INPUTERR;
        }

        pObjK->ctx_num = cJSON_GetArraySize(pSubContent);

        if(pObjK->ctx_num <= 0) {
            LOG_EX(LOG_Error, "The objContent has no member\n");

            for(j = 0; j < arraySize; j++) {
                if(pData->pCtx[j].pObj) {
                    free(pData->pCtx[j].pObj);
                }
            }

            free(pData->pCtx);
            cJSON_Delete(pRoot);
            return -RET_INPUTERR;
        }

        pVal = cJSON_GetObjectItem(pSub, "prio");

        if(cJSON_IsNumber(pVal)) {
            pObj->prio = pVal->valueint;
        }

        pVal = cJSON_GetObjectItem(pSub, "type");

        if(cJSON_IsNumber(pVal)) {
            pObjK->type = pVal->valueint;
        }

        pVal = cJSON_GetObjectItem(pSub, "name");

        if(cJSON_IsString(pVal)) {
            strncpy(pObj->name, pVal->valuestring, MAX_NAME_LEN - 1);
        }

        pVal = cJSON_GetObjectItem(pSub, "desc");

        if(cJSON_IsString(pVal)) {
            strncpy(pObj->desc, pVal->valuestring, MAX_DESC - 1);
        }

        for(j = 0; j < pObjK->ctx_num; j++) {
            cJSON *pItem = cJSON_GetArrayItem(pSubContent, j);

            switch(pObjK->type / 10) {
                case OBJ_TYPE_SERVER:
                    pVal = cJSON_GetObjectItem(pItem, "proType");

                    if(cJSON_IsNumber(pVal)) {
                        pObjK->objs.svr_obj[j].pro_type = pVal->valueint;
                    }

                    pVal = cJSON_GetObjectItem(pItem, "porPort");

                    if(cJSON_IsString(pVal)) {
                        pObjK->objs.svr_obj[j].str_val = strdup(pVal->valuestring);
                    }

                    break;

                case OBJ_TYPE_ADDR:
                    pVal = cJSON_GetObjectItem(pItem, "ipAddr");

                    if(cJSON_IsString(pVal)) {
                        pObjK->objs.addr_obj[j].str_val = strdup(pVal->valuestring);
                    }

                    break;

                case OBJ_TYPE_DATETIME:
                    pVal = cJSON_GetObjectItem(pItem, "repType");

                    if(cJSON_IsNumber(pVal)) {
                        pObjK->objs.dt_obj[j].rep_mode = pVal->valueint;
                    }

                    pVal = cJSON_GetObjectItem(pItem, "timeValue");

                    if(cJSON_IsString(pVal)) {
                        pObjK->objs.dt_obj[j].str_val = strdup(pVal->valuestring);
                    }

                    break;
            }
        }
    }

    cJSON_Delete(pRoot);
    return RET_OK;
}

static const char *__obj_query_list_encode(void *pData)
{
    const char     *pJsonS;
    PIFC_RET_PAGE_MSG p      = (PIFC_RET_PAGE_MSG)pData;
    cJSON             *pRoot = cJSON_CreateObject();

    if(!p) {
        return NULL;
    }

    cJSON_AddNumberToObject(pRoot, "retCode",    p->ret_code);

    if(p->mesg) {
        cJSON_AddStringToObject(pRoot, "mesg",    p->mesg);
    }

    if(p->ret_code == RET_OK) {
        if(p->session) {
            cJSON_AddStringToObject(pRoot, "session",    p->session);
        }

        cJSON_AddNumberToObject(pRoot, "type",    p->type);
        cJSON_AddNumberToObject(pRoot, "tolItems",    p->tolItems);
        cJSON_AddNumberToObject(pRoot, "start",    p->start);
        cJSON_AddNumberToObject(pRoot, "end",    p->end);
        cJSON_AddNumberToObject(pRoot, "n_items",    p->n_items);

        if(p->n_items > 0) {
            cJSON *pArray = cJSON_AddArrayToObject(pRoot, "data");

            if(pArray) {
                int i;

                for(i = 0; i < p->n_items; i++) {
                    cJSON *pItem = cJSON_CreateObject();

                    if(!pItem) {
                        continue;
                    }

                    cJSON_AddStringToObject(pItem, "name",      p->data[i].name);
                    cJSON_AddNumberToObject(pItem, "type",  p->data[i].type);
                    cJSON_AddNumberToObject(pItem, "ref_count",  p->data[i].ref_count);

                    if(p->data[i].desc) {
                        cJSON_AddStringToObject(pItem, "desc", p->data[i].desc);
                    }

                    cJSON_AddItemToArray(pArray, pItem);
                }
            }
        }
    }

    pJsonS  = cJSON_Print(pRoot);
    cJSON_Delete(pRoot);
    return pJsonS;
}

static int __obj_query_list_decode(const char *pJsonS, void **pStruct)
{
    cJSON  *pRoot, *pVal;
    PIFACE_QUERY_LIST pData;
    *pStruct = malloc(sizeof(IFACE_QUERY_LIST));

    if(*pStruct == NULL) {
        return -RET_NOMEM;
    }

    pData = (PIFACE_QUERY_LIST) * pStruct;
    pRoot = cJSON_Parse(pJsonS);

    if(!pRoot) {
        return -RET_SYSERR;
    }

    memset(pData, 0, sizeof(IFACE_QUERY_LIST));
    pVal = cJSON_GetObjectItem(pRoot, "type");

    if(cJSON_IsNumber(pVal)) {
        pData->type = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "start");

    if(cJSON_IsNumber(pVal)) {
        pData->start = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "end");

    if(cJSON_IsNumber(pVal)) {
        pData->end = pVal->valueint;
    }

    pVal = cJSON_GetObjectItem(pRoot, "session");

    if(cJSON_IsString(pVal)) {
        strncpy(pData->session, pVal->valuestring, MAX_SESSION - 1);
    }

    cJSON_Delete(pRoot);
    return RET_OK;
}

static const char *__obj_detail_encode(void *pData)
{
    const char     *pJsonS;
    PIFC_RET_DETAIL_MSG p         = (PIFC_RET_DETAIL_MSG)pData;
    cJSON           *pRoot = cJSON_CreateObject();

    if(!p) {
        return NULL;
    }

    cJSON_AddNumberToObject(pRoot, "retCode",    p->ret_code);

    if(p->mesg) {
        cJSON_AddStringToObject(pRoot, "mesg",    p->mesg);
    }

    if(p->n_items > 0 && p->ret_code == RET_OK) {
        cJSON *pArray = cJSON_AddArrayToObject(pRoot, "data");

        if(pArray) {
            int i;

            for(i = 0; i < p->n_items; i++) {
                cJSON *pObjArray;
                cJSON *pItem = cJSON_CreateObject();

                if(!pItem) {
                    continue;
                }

                pObjArray = cJSON_AddArrayToObject(pItem, "objContent");
                cJSON_AddStringToObject(pItem, "name",      p->data[i].name);
                cJSON_AddNumberToObject(pItem, "retCode",   p->data[i].ret_code);

                if(p->data[i].mesg) {
                    cJSON_AddStringToObject(pItem, "mesg",  p->data[i].mesg);
                }

                if(p->data[i].mesg) {
                    cJSON_AddStringToObject(pItem, "desc",  p->data[i].desc);
                }

                cJSON_AddNumberToObject(pItem, "type",      p->data[i].pObjK->type);
                cJSON_AddNumberToObject(pItem, "ref_count", p->data[i].pObjK->ref_count);
                cJSON_AddNumberToObject(pItem, "prio",      p->data[i].prio);

                if(pObjArray) {
                    int j;

                    for(j = 0; j < p->data[i].pObjK->ctx_num; j++) {
                        cJSON *pObjItem = cJSON_CreateObject();
                        PSVR_OBJECT  pSvr       = &p->data[i].pObjK->objs.svr_obj[j];
                        PADDR_OBJECT pAddr      = &p->data[i].pObjK->objs.addr_obj[j];
                        PDT_OBJECT   pDt        = &p->data[i].pObjK->objs.dt_obj[j];

                        if(!pObjItem) {
                            continue;
                        }

                        switch(p->data[i].pObjK->type / 10) {
                            case OBJ_TYPE_SERVER:
                                cJSON_AddNumberToObject(pObjItem, "proType",      pSvr->pro_type);
                                if(pSvr->str_val && strlen(pSvr->str_val) > 0) {
                                    cJSON_AddStringToObject(pObjItem, "porPort", pSvr->str_val);
                                }

                                break;

                            case OBJ_TYPE_ADDR:
                                if(pAddr->str_val && strlen(pDt->str_val) > 0) {
                                    cJSON_AddStringToObject(pObjItem, "ipAddr", pAddr->str_val);
                                }

                                break;

                            case OBJ_TYPE_DATETIME:
                                cJSON_AddNumberToObject(pObjItem, "repType",      pDt->rep_mode);
                                if(pDt->str_val && strlen(pDt->str_val) > 0) {
                                    cJSON_AddStringToObject(pObjItem, "timeValue", pDt->str_val);
                                }

                                break;
                        }

                        cJSON_AddItemToArray(pObjArray, pObjItem);
                    }
                }

                cJSON_AddItemToArray(pArray, pItem);
            }
        }
    }

    pJsonS  = cJSON_Print(pRoot);
    cJSON_Delete(pRoot);
    return pJsonS;
}

static int __obj_detail_decode(const char *pJsonS, void **pStruct)
{
    cJSON  *pRoot;
    PIFACE_DETAIL_OBJ pData;
    int arraySize;
    int i;
    *pStruct = malloc(sizeof(IFACE_DETAIL_OBJ));

    if(*pStruct == NULL) {
        return -RET_NOMEM;
    }

    pData = (PIFACE_DETAIL_OBJ) * pStruct;
    pRoot = cJSON_Parse(pJsonS);

    if(!pRoot) {
        return -RET_SYSERR;
    }

    if(!cJSON_IsArray(pRoot)) {
        cJSON_Delete(pRoot);
        return -RET_INPUTERR;
    }

    memset(pData, 0, sizeof(IFACE_ADD_OBJ));
    arraySize = cJSON_GetArraySize(pRoot);
    pData->n_obj = arraySize;

    for(i = 0; i < arraySize; i++) {
        cJSON *pSub = cJSON_GetArrayItem(pRoot, i);

        if(pSub) {
            cJSON *pVal = cJSON_GetObjectItem(pSub, "name");

            if(cJSON_IsString(pVal)) {
                strncpy(pData->name[i], pVal->valuestring, MAX_NAME_LEN - 1);
            }
        }
    }

    cJSON_Delete(pRoot);
    return RET_OK;
}

static JSON_ENGINE g_jSonEngine[] = {
    {JE_INTERFACE,          __interface_encode,         __interface_decode,         NULL},
    {OBJ_CMD_ADD,           __obj_add_encode,           __obj_add_decode,           NULL},
    {JE_OBJ_DEL,            __obj_del_encode,           __obj_del_decode,           NULL},
    {JE_OBJ_MOD,            __obj_mod_encode,           __obj_mod_decode,           NULL},
    {JE_OBJ_QUERYLIST,      __obj_query_list_encode,    __obj_query_list_decode,    NULL},
    {JE_OBJ_QUERYDETAIL,    __obj_detail_encode,        __obj_detail_decode,        NULL},
    {JSON_ENGINE_MAX,       NULL,   NULL, NULL}
};

int Json2Struct(const char *pJsonStr, void *pData, JSON_ENGINE_TYPE type,
                int enBase64)
{
    if(pJsonStr == NULL || pData == NULL) {
        return -RET_INPUTERR;
    }

    if(type < 0 || type >= JSON_ENGINE_MAX) {
        return -RET_INPUTERR;
    }

    //LOG_EX(LOG_Debug, "Json:\n%s\n", pJsonStr);

    if(g_jSonEngine[type].j2sCb) {
        g_jSonEngine[type].j2sCb(pJsonStr, pData);

        if(enBase64 && g_jSonEngine[type].base64Cb) {
            g_jSonEngine[type].base64Cb(pData, FALSE);
        }

        return RET_OK;
    } else {
        return -RET_NOTSUPPORT;
    }
}

const char *Struct2Json(void *pStruct, JSON_ENGINE_TYPE type, int enBase64,
                        int *pErr)
{
    if(pStruct == NULL || pErr == NULL) {
        if(pErr) {
            *pErr = -RET_INPUTERR;
        }

        return NULL;
    }

    if(type < 0 || type >= JSON_ENGINE_MAX) {
        *pErr = -RET_INPUTERR;
        return NULL;
    }

    *pErr = 0;

    if(enBase64 && g_jSonEngine[type].base64Cb) {
        g_jSonEngine[type].base64Cb(pStruct, TRUE);
    }

    if(g_jSonEngine[type].s2jCb) {
        const char *pJsongStr = g_jSonEngine[type].s2jCb(pStruct);
        //LOG_EX(LOG_Debug, "Json: \n%s\n", pJsongStr);
        return (pJsongStr);
    } else {
        return NULL;
    }
}