#include <assert.h>
#include "Crc64.h"
#include "CcosLock.h"
#include "PacketAnalizer.h"
#include <iostream>
#include <sstream> // 添加字符串流支持
#include <cstdint> // 添加标准整数类型头文件

// 使用标准命名空间
using namespace std;

PacketAnalizer::PacketAnalizer(void)
{
}

PacketAnalizer::~PacketAnalizer(void)
{
}

uint32_t PacketAnalizer::MakePacketIdx()
{
    return Thread_GetUniqTick();
}

uint32_t PacketAnalizer::GetPacketIdx(ResDataObject* pObj)
{
    uint32_t ret = 0;
    try {
        int Idx = (*pObj).GetFirstOf(CCOS_PACK_IDX);
        if (Idx >= 0)
        {
            ret = static_cast<uint32_t>((*pObj)[CCOS_PACK_IDX]);
        }

    }
    catch (ResDataObjectExption& exp)
    {
        cout << exp.what() << endl;
    }
    catch (...)
    {
    }

    return ret;
}

bool PacketAnalizer::GetDestinationMachineId(ResDataObject& packet, string& machineId)
{
    bool ret = false;
    try {
        // 检查目标并分派
        PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);

        switch (type)
        {
            // 请求：设备总线+进程
        case PACKET_TYPE_REQ:
            if (PacketAnalizer::GetPacketHandleMachineId(&packet, machineId, true))
            {
                return true;
            }
            break;
            // 响应和通知：所有者总线+进程
        case PACKET_TYPE_RES:
        case PACKET_TYPE_NOTIFY:
            if (PacketAnalizer::GetPacketHandleMachineId(&packet, machineId, false))
            {
                return true;
            }

            break;
        default:
            break;
        }
    }
    catch (...)
    {
    }

    return ret;
}

bool PacketAnalizer::GetDestinationBusId(ResDataObject& packet, string& busId)
{
    bool ret = false;
    try {
        // 检查目标并分派
        PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);

        switch (type)
        {
            // 请求：设备总线+进程
        case PACKET_TYPE_REQ:
            if (PacketAnalizer::GetPacketHandleBusId(&packet, busId, true))
            {
                return true;
            }
            break;
            // 响应和通知：所有者总线+进程
        case PACKET_TYPE_RES:
        case PACKET_TYPE_NOTIFY:
            if (PacketAnalizer::GetPacketHandleBusId(&packet, busId, false))
            {
                return true;
            }

            break;
        default:
            break;
        }
    }
    catch (...)
    {
    }

    return ret;
}

bool PacketAnalizer::GetDestinationProcId(ResDataObject& packet, uint64_t& procId)
{
    bool ret = false;
    try {
        // 检查目标并分派
        PACKET_TYPE type = PacketAnalizer::GetPacketType(&packet);

        switch (type)
        {
            // 请求：设备总线+进程
        case PACKET_TYPE_REQ:
            if (PacketAnalizer::GetPacketHandleProcId(&packet, procId, true))
            {
                return true;
            }
            break;
            // 响应和通知：所有者总线+进程
        case PACKET_TYPE_RES:
        case PACKET_TYPE_NOTIFY:
            if (PacketAnalizer::GetPacketHandleProcId(&packet, procId, false))
            {
                return true;
            }

            break;
        default:
            break;
        }
    }
    catch (...)
    {
    }

    return ret;
}

PACKET_TYPE PacketAnalizer::GetPacketType(ResDataObject* pObj)
{
    int cmd;
    PACKET_TYPE ret = PACKET_TYPE_NONE;

    try {
        cmd = static_cast<int>((*pObj)[CCOS_PACK_TYPE]);
        ret = static_cast<PACKET_TYPE>(cmd);
        if (ret >= 0 && ret < PACKET_TYPE_MAX)
        {
            return ret;
        }

    }
    catch (ResDataObjectExption& exp)
    {
        cout << exp.what() << endl;
    }
    catch (...)
    {
    }

    return PACKET_TYPE_NONE;
}

PACKET_CMD PacketAnalizer::GetPacketCmd(ResDataObject* pObj)
{
    int cmd;
    PACKET_CMD ret = PACKET_CMD_NONE;

    try {
        cmd = static_cast<int>(((*pObj)[CCOS_PACK_CMD]));
        ret = static_cast<PACKET_CMD>(cmd);
        if (ret >= 0 && ret < PACKET_CMD_MAX)
        {
            return ret;
        }

    }
    catch (ResDataObjectExption& exp)
    {
        cout << exp.what() << endl;
    }
    catch (...)
    {
    }

    return PACKET_CMD_NONE;
}

ACTION_SYNC_MODE PacketAnalizer::GetPacketSyncMode(ResDataObject* pObj)
{
    ACTION_SYNC_MODE ret = ACTION_SYNC;
    try {
        ret = static_cast<ACTION_SYNC_MODE>(static_cast<int>((*pObj)[CCOS_PACKET_SYNC]));
    }
    catch (...)
    {
        ret = ACTION_SYNC;
    }

    return ret;
}

ResDataObject* PacketAnalizer::GetPacketKeysRes(ResDataObject* pObj)
{
    try {
        int Idx = (*pObj).GetFirstOf(CCOS_PACK_KEY);
        if (Idx >= 0)
        {
            ResDataObject& Res = (*pObj)[CCOS_PACK_KEY];
            return &Res;
        }

    }
    catch (ResDataObjectExption& exp)
    {
        cout << exp.what() << endl;
    }
    catch (...)
    {
    }

    return NULL;
}

string PacketAnalizer::GetPacketPublisher(ResDataObject* pObj)
{
    std::string key = "";
    try {
        int Idx = (*pObj).GetFirstOf(CCOS_PUBLISH);
        if (Idx >= 0)
        {
            key = static_cast<const char*>((*pObj)[CCOS_PUBLISH]);
        }

    }
    catch (ResDataObjectExption& exp)
    {
        cout << exp.what() << endl;
        key = "";
    }
    catch (...)
    {
        key = "";
    }

    return key;
}

std::string PacketAnalizer::GetPacketKey(ResDataObject* pObj)
{
    std::string key = "";
    try {
        int Idx = (*pObj).GetFirstOf(CCOS_PACK_KEY);
        if (Idx >= 0)
        {
            key = static_cast<const char*>((*pObj)[CCOS_PACK_KEY]);
        }

    }
    catch (ResDataObjectExption& exp)
    {
        cout << exp.what() << endl;
        key = "";
    }
    catch (...)
    {
        key = "";
    }

    return key;
}

bool PacketAnalizer::GetPacketHandleExistance(ResDataObject* pPacket)
{
    bool ret = false;
    try {
        if ((*pPacket).GetFirstOf(CCOS_PACK_HANDLE) >= 0)
        {
            ret = true;
        }
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketHandle(ResDataObject* pPacket, ResDataObject& Handle)
{
    bool ret = true;
    try {
        Handle = (*pPacket)[CCOS_PACK_HANDLE];
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketHandleBusId(ResDataObject* pPacket, string& BusId, bool dev)
{
    bool ret = true;
    try {
        if (dev)
        {
            BusId = static_cast<const char*>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_BUSID]);
        }
        else
        {
            BusId = static_cast<const char*>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_OWNERID][CCOS_PACK_TARGET_BUSID]);
        }

    }
    catch (...)
    {
        BusId = "";
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketHandleMachineId(ResDataObject* pPacket, string& MachineId, bool dev)
{
    bool ret = true;
    try {
        if (dev)
        {
            MachineId = static_cast<const char*>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_MACHINEID]);
        }
        else
        {
            MachineId = static_cast<const char*>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_OWNERID][CCOS_PACK_TARGET_MACHINEID]);
        }

    }
    catch (...)
    {
        MachineId = "";
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketHandleProcId(ResDataObject* pPacket, uint64_t& ProcId, bool dev)
{
    bool ret = true;
    try {
        if (dev)
        {
            ProcId = static_cast<uint64_t>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_PROCID]);
        }
        else
        {
            ProcId = static_cast<uint64_t>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_OWNERID][CCOS_PACK_TARGET_PROCID]);
        }

    }
    catch (...)
    {
        ProcId = 0;
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketHandleCrc(ResDataObject* pPacket, uint64_t& Crc)
{
    bool ret = true;
    try {
        Crc = static_cast<uint64_t>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACKET_HANDLE_KEY]);
    }
    catch (...)
    {
        Crc = 0;
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketHandleAddr(ResDataObject* pPacket, uint64_t& Addr, bool dev)
{
    bool ret = true;
    try {
        if (dev)
        {
            Addr = static_cast<uint64_t>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_ADDR]);
        }
        else
        {
            Addr = static_cast<uint64_t>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_OWNERID][CCOS_PACK_TARGET_ADDR]);
        }

    }
    catch (...)
    {
        Addr = 0;
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::MakePacketContextExistance(ResDataObject* pPacket)
{
    bool ret = false;
    try {
        if ((*pPacket).GetFirstOf(CCOS_PACK_CONTEXT) >= 0)
        {
            ret = true;
        }
        else
        {
            (*pPacket).add(CCOS_PACK_CONTEXT, "");
            ret = true;
        }
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketRoute(ResDataObject* pPacket, CCOS_PACKET_ROUTE& Route)
{
    bool ret = true;
    Route = CCOS_PACKET_ROUTE_ANY; // 设置默认值
    try {
        Route = static_cast<CCOS_PACKET_ROUTE>(static_cast<int>((*pPacket)[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_ROUTE]));
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketContext(ResDataObject* pPacket, ResDataObject& Context)
{
    bool ret = true;
    try {
        int Idx = (*pPacket).GetFirstOf(CCOS_PACK_CONTEXT);
        if (Idx >= 0)
        {
            Context = (*pPacket)[Idx];
        }
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketTransaction(ResDataObject* pPacket, string& transaction)
{
    bool ret = true;
    try {
        int Idx = (*pPacket).GetFirstOf(CCOS_TRANSACTION);
        if (Idx >= 0)
        {
            string id = static_cast<string>((*pPacket)[Idx]);
            transaction = id;
        }
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::GetPacketRetCode(ResDataObject* pPacket, RET_STATUS& retcode)
{
    bool ret = true;
    try {
        (retcode) = (RET_STATUS)((int)((*pPacket)[CCOS_PACK_RETURN][CCOS_PACK_CODE]));
    }
    catch (...)
    {
        retcode = RET_FAILED;
        ret = false;
    }

    return ret;

}

bool PacketAnalizer::GetPacketMsgInfo(ResDataObject* pPacket, string& Info)
{
    bool ret = true;
    try {
        int Idx = (*pPacket)[CCOS_PACK_RETURN].GetFirstOf(CCOS_PACK_MSG);
        if (Idx >= 0)
        {
            Info = static_cast<const char*>(((*pPacket)[CCOS_PACK_RETURN][Idx]));
        }
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

void  PacketAnalizer::MakeRetCode(RET_STATUS retcode, ResDataObject* pObj, const char* pMsg)
{
    ResDataObject RetObj, SubObj;
    SubObj.add(CCOS_PACK_CODE, static_cast<int>(retcode));
    if (pMsg)
    {
        SubObj.add(CCOS_PACK_MSG, pMsg);
    }

    pObj->update(CCOS_PACK_RETURN, SubObj);
}

bool  PacketAnalizer::CloneResponse(ResDataObject& Obj, ResDataObject* pReq)
{
    Obj.clear();
    // 复制索引
    uint32_t Idx = PacketAnalizer::GetPacketIdx(pReq);
    if (Idx)
    {
        Obj.add(CCOS_PACK_IDX, Idx);
        Obj.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_RES));
        PACKET_CMD cmd = PacketAnalizer::GetPacketCmd(pReq);
        if (cmd != PACKET_CMD_NONE)
        {
            Obj.add(CCOS_PACK_CMD, static_cast<int>(cmd));
            Obj.add(CCOS_PACK_HANDLE, (*pReq)[CCOS_PACK_HANDLE]);
            string keystr = PacketAnalizer::GetPacketKey(pReq);
            Obj.add(CCOS_PACK_KEY, keystr.c_str());
            Obj.add(CCOS_PACK_CONTEXT, "");

            return true;
        }
    }

    return false;
}

bool  PacketAnalizer::UpdateOpenRequest(ResDataObject& Req, ResDataObject& MachineId, ResDataObject& busId, uint64_t ProcId, uint64_t Addr)
{
    try {
        Req[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_ADDR] = Addr;
        Req[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_PROCID] = ProcId;
        Req[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_BUSID] = busId;
        Req[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID][CCOS_PACK_TARGET_MACHINEID] = MachineId;
        string the_crc = "";
        the_crc += Req[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_OWNERID].encode();
        the_crc += static_cast<const char*>(Req[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_DEVID].encode());

        uint64_t crc = GetCrc64(the_crc.c_str(), static_cast<uint32_t>(the_crc.size()));
        Req[CCOS_PACK_HANDLE][CCOS_PACKET_HANDLE_KEY] = crc;

        return true;
    }
    catch (...)
    {
    }

    return false;
}

bool PacketAnalizer::UpdateHandleId(ResDataObject* Obj, uint64_t id)
{
    (*Obj)[CCOS_PACK_HANDLE][CCOS_PACKET_HANDLE_KEY] = id;
    return true;
}

bool PacketAnalizer::GetHandleId(ResDataObject* Obj, uint64_t& Id)
{
    bool ret = true;
    try {
        Id = static_cast<uint64_t>((*Obj)[CCOS_PACK_HANDLE][CCOS_PACKET_HANDLE_KEY]);
    }
    catch (...)
    {
        Id = 0;
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::UpdateDeviceNotifyResponse(ResDataObject& Notify, ResDataObject& MachineId, ResDataObject& busId, uint64_t ProcId, uint64_t Addr)
{
    try {
        CcosDevFileHandle handle;
        handle.GetTarget(false)[CCOS_PACK_TARGET_MACHINEID] = static_cast<const char*>(MachineId);
        handle.GetTarget(false)[CCOS_PACK_TARGET_BUSID] = static_cast<const char*>(busId);
        handle.GetTarget(false)[CCOS_PACK_TARGET_PROCID] = ProcId;
        handle.GetTarget(false)[CCOS_PACK_TARGET_ADDR] = Addr;

        ResDataObject handleObj;
        handle.GetResDataObject(handleObj);
        Notify.update(CCOS_PACK_HANDLE, handleObj);

        return true;
    }
    catch (...)
    {
    }

    return false;
}

bool PacketAnalizer::UpdatePacketContext(ResDataObject& packet, ResDataObject& Context)
{
    try {
        packet[CCOS_PACK_CONTEXT] = Context;
        return true;
    }
    catch (...)
    {
    }

    return false;
}

bool PacketAnalizer::UpdatePacketTransaction(ResDataObject& packet, string strTransaction)
{
    try {
        packet.update(CCOS_TRANSACTION, strTransaction.c_str());
        return true;
    }
    catch (...)
    {
    }

    return false;
}

bool  PacketAnalizer::MakeOpenResponse(ResDataObject& Req, ResDataObject& Res, ResDataObject& DevResource)
{
    PacketAnalizer::CloneResponse(Res, &Req);
    try {
        Res.update(CCOS_PACK_CONTEXT, DevResource);
        PacketAnalizer::MakeRetCode(RET_SUCCEED, &Res);
        return true;
    }
    catch (...)
    {
    }

    return false;
}

void  PacketAnalizer::MakeNotifyP2P(ResDataObject& Obj, PACKET_CMD cmd, ResDataObject* pReq, const char* pKey, const char* pContext)
{
    Obj.clear();
    Obj.update(CCOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
    Obj.update(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_NOTIFY));
    Obj.update(CCOS_PACK_CMD, static_cast<int>(cmd));
    Obj.update(CCOS_PACK_HANDLE, (*pReq)[CCOS_PACK_HANDLE]);
    Obj.update(CCOS_PACK_KEY, pKey);
    Obj.update(CCOS_PACK_CONTEXT, pContext);
    Obj.update(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);
}

bool PacketAnalizer::UpdatePacketRoute(ResDataObject& Obj, CCOS_PACKET_ROUTE Route)
{
    Obj[CCOS_PACK_HANDLE][CCOS_PACK_HANDLE_ROUTE] = static_cast<int>(Route);
    return true;
}

bool PacketAnalizer::UpdateNotifyHandle(ResDataObject& Obj, CcosDevFileHandle& handle)
{
    ResDataObject handleObj;
    handle.GetResDataObject(handleObj);
    Obj.update(CCOS_PACK_HANDLE, handleObj);
    return true;
}

void  PacketAnalizer::MakeNotify(ResDataObject& Obj, PACKET_CMD cmd, const char* pKey, const char* pContext)
{
    Obj.clear();
    Obj.update(CCOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
    Obj.update(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_NOTIFY));
    Obj.update(CCOS_PACK_CMD, static_cast<int>(cmd));
    Obj.update(CCOS_PACK_KEY, pKey);
    Obj.update(CCOS_PACK_CONTEXT, pContext);
    Obj.update(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);
}

void  PacketAnalizer::MakeNotify(ResDataObject& Obj, PACKET_CMD cmd, ResDataObject& Key, const ResDataObject& Context)
{
    Obj.clear();
    Obj.add(CCOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
    Obj.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_NOTIFY));
    Obj.add(CCOS_PACK_CMD, static_cast<int>(cmd));
    Obj.add(CCOS_PACK_KEY, Key);
    Obj.add(CCOS_PACK_CONTEXT, const_cast<ResDataObject&>(Context));
    Obj.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);
}

void  PacketAnalizer::MakeNotify(ResDataObject& Obj, PACKET_CMD cmd, const char* pKey, const ResDataObject& Context)
{
    Obj.clear();
    Obj.add(CCOS_PACK_IDX, PacketAnalizer::MakePacketIdx());
    Obj.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_NOTIFY));
    Obj.add(CCOS_PACK_CMD, static_cast<int>(cmd));
    Obj.add(CCOS_PACK_KEY, pKey);
    Obj.add(CCOS_PACK_CONTEXT, const_cast<ResDataObject&>(Context));
    Obj.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);
}

uint32_t  PacketAnalizer::MakeActionRequest(ResDataObject& Obj, CcosDevFileHandle& handle, const char* pActionName, ResDataObject& ReqParams, ACTION_SYNC_MODE mode)
{
    uint32_t tick = PacketAnalizer::MakePacketIdx();
    Obj.clear();
    Obj.add(CCOS_PACK_IDX, tick);
    Obj.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_REQ));
    Obj.add(CCOS_PACK_CMD, static_cast<int>(PACKET_CMD_EXE));
    Obj.add(CCOS_PACKET_SYNC, static_cast<int>(mode));
    Obj.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);

    ResDataObject handleObj;
    handle.GetResDataObject(handleObj);
    Obj.add(CCOS_PACK_HANDLE, handleObj);

    Obj.add(CCOS_PACK_KEY, pActionName);
    Obj.add(CCOS_PACK_CONTEXT, ReqParams);

    return tick;
}

uint32_t PacketAnalizer::MakeRequest(ResDataObject& Obj, const char* pszReqName, PACKET_CMD cmd, ResDataObject* reqParams)
{
    DWORD tick = PacketAnalizer::MakePacketIdx();
    Obj.clear();
    Obj.add(CCOS_PACK_IDX, tick);
    Obj.add(CCOS_PACK_TYPE, (int)PACKET_TYPE_REQ);
    Obj.add(CCOS_PACK_CMD, (int)cmd);
    Obj.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);

    Obj.add(CCOS_PACK_KEY, pszReqName);
    Obj.add(CCOS_PACK_CONTEXT, *reqParams);

    return tick;
}
uint32_t PacketAnalizer::MakeOpenRequest(ResDataObject& Obj, CcosDevFileHandle& handle, const char* pFilePath)
{
    uint32_t tick = PacketAnalizer::MakePacketIdx();
    Obj.clear();
    Obj.add(CCOS_PACK_IDX, tick);
    Obj.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_REQ));
    Obj.add(CCOS_PACK_CMD, static_cast<int>(PACKET_CMD_OPEN));
    Obj.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);

    ResDataObject handleObj;
    handle.GetResDataObject(handleObj);
    Obj.add(CCOS_PACK_HANDLE, handleObj);

    Obj.add(CCOS_PACK_KEY, pFilePath);

    ResDataObject context;
    context.add(CCOS_RESP_TOPIC, "");
    Obj.add(CCOS_PACK_CONTEXT, context);

    return tick;
}

bool PacketAnalizer::MakeResponseByReq(ResDataObject& Response, ResDataObject& Req, RET_STATUS ret, const char* pInfo)
{
    PacketAnalizer::CloneResponse(Response, &Req);
    PacketAnalizer::MakeRetCode(ret, &Response, pInfo);
    return true;
}

bool PacketAnalizer::MakeCloseNotifyByRes(ResDataObject& Response, ResDataObject& Req)
{
    uint32_t tick = PacketAnalizer::MakePacketIdx();
    Req.clear();
    Req.add(CCOS_PACK_IDX, tick);
    Req.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_NOTIFY));
    Req.add(CCOS_PACK_CMD, static_cast<int>(PACKET_CMD_CLOSE));
    Req.add(CCOS_PACK_HANDLE, Response[CCOS_PACK_HANDLE]);
    Req.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);

    return true;
}

bool PacketAnalizer::MakeCloseRequestByRes(ResDataObject& Response, ResDataObject& Req)
{
    uint32_t tick = PacketAnalizer::MakePacketIdx();
    Req.clear();
    Req.add(CCOS_PACK_IDX, tick);
    Req.add(CCOS_PACK_TYPE, static_cast<int>(PACKET_TYPE_REQ));
    Req.add(CCOS_PACK_CMD, static_cast<int>(PACKET_CMD_CLOSE));
    Req.add(CCOS_PACK_HANDLE, Response[CCOS_PACK_HANDLE]);

    return true;
}

bool PacketAnalizer::MakeCloseRequest(ResDataObject& Obj, CcosDevFileHandle& handle, PACKET_TYPE Type)
{
    uint32_t tick = PacketAnalizer::MakePacketIdx();
    Obj.clear();
    Obj.add(CCOS_PACK_IDX, tick);
    Obj.add(CCOS_PACK_TYPE, static_cast<int>(Type));
    Obj.add(CCOS_PACK_CMD, static_cast<int>(PACKET_CMD_CLOSE));
    Obj.add(CCOS_PACKET_VER, CCOS_PACKET_VER_NOW);
    ResDataObject handleObj;
    handle.GetResDataObject(handleObj);
    Obj.add(CCOS_PACK_HANDLE, handleObj);

    return true;
}

bool PacketAnalizer::MakeCloseResponse(ResDataObject& Req, ResDataObject& Res)
{
    PacketAnalizer::CloneResponse(Res, &Req);
    PacketAnalizer::MakeRetCode(RET_SUCCEED, &Res);
    return true;
}

bool  PacketAnalizer::GetParam(ResDataObject* pReq, unsigned int ParamIdx, ResDataObject& value)
{
    bool ret = false;
    string parami = "P" + to_string(ParamIdx); // 使用标准库函数生成参数名

    try {
        if ((*pReq)[CCOS_PACK_CONTEXT].GetFirstOf(parami.c_str()) >= 0)
        {
            value = (*pReq)[CCOS_PACK_CONTEXT][parami.c_str()];
            return true;
        }
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool  PacketAnalizer::AddParam(ResDataObject* pRes, unsigned int ParamIdx, ResDataObject& value)
{
    bool ret = true;
    string parami = "P" + to_string(ParamIdx); // 使用标准库函数生成参数名

    try {
        ret = (*pRes)[CCOS_PACK_CONTEXT].add(parami.c_str(), value);
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool  PacketAnalizer::UpdateParam(ResDataObject* pRes, unsigned int ParamIdx, ResDataObject& value)
{
    bool ret = true;
    string parami = "P" + to_string(ParamIdx); // 使用标准库函数生成参数名

    try {
        ret = (*pRes)[CCOS_PACK_CONTEXT].update(parami.c_str(), value);
    }
    catch (...)
    {
        ret = false;
    }

    return ret;
}

bool PacketAnalizer::UpdatePacketTopic(ResDataObject* Obj, const char* pszTopic, const char* pszClientID)
{
    Obj->update(CCOS_TOPIC, pszTopic);
    Obj->update(CCOS_PUBLISH, pszClientID);
    return true;
}

bool PacketAnalizer::UpdatePacketKey(ResDataObject* Obj, const char* keystr)
{
    Obj->update(CCOS_PACK_KEY, keystr);
    return true;
}

bool PacketAnalizer::UpdateContextTopic(ResDataObject* Obj, const char* pszRespTopic)
{
    (*Obj)[CCOS_PACK_CONTEXT].update(CCOS_RESP_TOPIC, pszRespTopic);
    return true;
}

bool PacketAnalizer::GetContextTopic(ResDataObject* Obj, ResDataObject& topic)
{
    if ((*Obj).GetFirstOf("ResponseTopic") > 0)
        topic = (*Obj)["ResponseTopic"];
    else
        topic = (*Obj)[CCOS_PACK_CONTEXT][CCOS_RESP_TOPIC];
    return true;
}

bool PacketAnalizer::GetPacketTopic(ResDataObject* Obj, ResDataObject& topic)
{
    if ((*Obj).GetFirstOf(CCOS_TOPIC) > 0)
        topic = (*Obj)[CCOS_TOPIC];
    else
        topic = (*Obj)[CCOS_PACK_CONTEXT][CCOS_RESP_TOPIC];
    return true;
}

bool PacketAnalizer::CloneTransaction(ResDataObject* req, ResDataObject* res)
{
    if ((*req).GetFirstOf("Transaction") > 0)
        res->update("Transaction", (*req)["Transaction"]);
    return true;
}

string  PacketAnalizer::GetActionTopic(const char* szDevicePath, const char* szAction)
{
    const char* pPath = szDevicePath;
    if (szDevicePath[0] == '/')
        pPath++;
    stringstream strea;
    strea << pPath << "/Action/" << szAction;
    return strea.str();
}