#include "HGVersionImpl.hpp"
#include "../base/HGInc.h"
#include "../base/HGInfo.h"
#include "../base/HGMd5.h"
#include "../base/HGUtility.h"
#include "HGVersionMsg.hpp"
#include <string>
#include <vector>
#include <list>
#include <iostream>
#include <sstream>
#include <algorithm>
#include "cJSON.h"
#include "curl/curl.h"
#if defined(HG_CMP_MSC)
#include <iphlpapi.h>
#endif
#include "HGString.h"

struct VersionInfoImpl
{
    VersionInfoImpl()
    {
        size = 0;
    }

    std::string version;
    std::string desc;
    std::string bugInfo;
    std::string url;
    unsigned long long size;
    std::string md5;
};

static size_t write_data(void* ptr, size_t size, size_t nmemb, void* stream)
{
    std::string data((const char*)ptr, (size_t)size * nmemb);

    *((std::stringstream*)stream) << data << std::endl;

    return size * nmemb;
}

static HGResult GetServerConfig(HGServerConfig& config)
{
    config.postCrashInfo = HGFALSE;
    config.postUserBehaviorInfo = HGFALSE;
    config.postDeviceInfo = HGFALSE;

    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string url = "http://cd.holdtecs.net:50080/api/ver/setting";
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Accept-Encoding:gzip, deflate, sdch");
        headers = curl_slist_append(headers, "Accept-Language:zh-CN,zh;q=0.8");
        headers = curl_slist_append(headers, "Connection:keep-alive");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }
                    else if (0 == strcmp(p->string, "data") && p->type == cJSON_Object)
                    {
                        cJSON* p2 = p->child;
                        while (NULL != p2)
                        {
                            if (0 == strcmp(p2->string, "report_switch"))
                                config.postUserBehaviorInfo = (HGBool)p2->valueint;
                            else if (0 == strcmp(p2->string, "collapse_switch"))
                                config.postCrashInfo = (HGBool)p2->valueint;
                            else if (0 == strcmp(p2->string, "device_info_switch"))
                                config.postDeviceInfo = (HGBool)p2->valueint;

                            p2 = p2->next;
                        }
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static int xferinfo(void* p, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
{
    HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "ulnow=%lld, ultotal=%lld", ulnow, ultotal);
    return 0;
}

static HGResult CrashFileUpload(const std::string& crashFilePath, std::string& crashFileUrl)
{
    crashFileUrl.clear();

    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        struct curl_httppost* formpost = NULL;
        struct curl_httppost* lastptr = NULL;
        curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "file", CURLFORM_FILE, crashFilePath.c_str(), CURLFORM_END);
        curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, "submit", CURLFORM_COPYCONTENTS, "Submit", CURLFORM_END);

        std::string url = "http://cd.holdtecs.net:50080/api/coollapse/upload";
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
        curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);

        curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, xferinfo);
        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }
                    else if (0 == strcmp(p->string, "data") && p->type == cJSON_Object)
                    {
                        cJSON* p2 = p->child;
                        while (NULL != p2)
                        {
                            if (0 == strcmp(p2->string, "url") && p2->type == cJSON_String)
                                crashFileUrl = p2->valuestring;

                            p2 = p2->next;
                        }
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        /* then cleanup the formpost chain */
        curl_formfree(formpost);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static void GetMacAddrList(std::vector<std::string>& macList)
{
    macList.clear();

#if defined(HG_CMP_MSC)
    ULONG ulOutBufLen = sizeof(IP_ADAPTER_INFO);
    PIP_ADAPTER_INFO pAdapterInfo = (PIP_ADAPTER_INFO)malloc(ulOutBufLen);

    ULONG nRet = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
    if (ERROR_BUFFER_OVERFLOW == nRet)
    {
        free(pAdapterInfo);
        pAdapterInfo = NULL;
        pAdapterInfo = (PIP_ADAPTER_INFO)malloc(ulOutBufLen);

        nRet = GetAdaptersInfo(pAdapterInfo, &ulOutBufLen);
    }

    if (ERROR_SUCCESS == nRet)
    {
        PIP_ADAPTER_INFO pAdapter = pAdapterInfo;
        while (NULL != pAdapter)
        {
            DWORD dwCharacteristics = 0;

            HKEY hKey = NULL;
            RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002bE10318}", 0, KEY_ENUMERATE_SUB_KEYS, &hKey);
            if (NULL != hKey)
            {
                DWORD dwIndex = 0;

                while (1)
                {
                    CHAR szValueName[256];
                    if (ERROR_SUCCESS != RegEnumKeyA(hKey, dwIndex, szValueName, 256))
                    {
                        break;
                    }

                    HKEY hKey2 = NULL;
                    RegOpenKeyExA(hKey, szValueName, 0, KEY_QUERY_VALUE, &hKey2);
                    if (NULL != hKey2)
                    {
                        DWORD dwType;
                        CHAR szData[256] = { 0 };
                        DWORD cbData = 256;
                        if (ERROR_SUCCESS == RegQueryValueExA(hKey2, "NetCfgInstanceId", NULL, &dwType, (LPBYTE)szData, &cbData) && REG_SZ == dwType)
                        {
                            if (0 == _stricmp(szData, pAdapter->AdapterName))
                            {
                                if (ERROR_SUCCESS == RegQueryValueExA(hKey2, "Characteristics", NULL, &dwType, (LPBYTE)szData, &cbData) && REG_DWORD == dwType)
                                {
                                    dwCharacteristics = *(DWORD*)szData;
                                }
                            }
                        }

                        RegCloseKey(hKey2);
                    }

                    ++dwIndex;
                }

                RegCloseKey(hKey);
            }

            if ((dwCharacteristics & 0x4))
            {
                std::string strMacAddr;
                for (UINT i = 0; i < pAdapter->AddressLength; i++)
                {
                    char str[10];
                    sprintf(str, "%02x", pAdapter->Address[i]);
                    strMacAddr += str;
                    if (i != pAdapter->AddressLength - 1)
                        strMacAddr += "-";
                }

                macList.push_back(strMacAddr);
            }

            pAdapter = pAdapter->Next;
        }
    }

    free(pAdapterInfo);
    pAdapterInfo = NULL;
#else
    DIR* dir = opendir("/sys/class/net");
    if (NULL != dir)
    {
        HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "GetMacAddrList: opendir success");

        struct dirent* ent;
        while ((ent = readdir(dir)) != NULL)
        {
            if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
                continue;

            if (strstr(ent->d_name, "docker") == ent->d_name || strstr(ent->d_name, "sit") == ent->d_name
                || strstr(ent->d_name, "ip6tnl") == ent->d_name || strcmp(ent->d_name, "lo") == 0)
                continue;

            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "GetMacAddrList: name %s", ent->d_name);

            char addrPath[256];
            sprintf(addrPath, "/sys/class/net/%s/address", ent->d_name);

            FILE* file = fopen(addrPath, "rb");
            if (NULL != file)
            {
                char mac[1025] = { 0 };
                fread(mac, 1, 1024, file);

                int len = (int)strlen(mac);
                for (int i = 0; i < len; ++i)
                {
                    if (mac[i] == ':')
                        mac[i] = '-';
                    else if (mac[i] == '\n')
                        mac[i] = '\0';
                }

                if (strlen(mac) > 0)
                {
                    macList.push_back(mac);
                }

                HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "GetMacAddrList: mac %s", mac);
                fclose(file);
            }
            else
            {
                HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "GetMacAddrList: fopen fail %s", addrPath);
            }
        }

        closedir(dir);
    }
    else
    {
        HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "GetMacAddrList: opendir fail %s", "/sys/class/net");
    }
#endif
}

static std::string GetOSName()
{
    std::string osName;

#if defined(HG_CMP_MSC)
    osName = "Windows";
#else
    osName = "Linux";
    FILE* fp = popen("cat /etc/issue | cut -d\' \' -f1", "r");
    if (NULL != fp)
    {
        char buff[1024] = { 0 };
        fread(buff, 1024, 1, fp);

        int len = (int)strlen(buff);
        for (int i = 0; i < len; ++i)
        {
            if (buff[i] == '\n')
                buff[i] = '\0';
        }

        osName = buff;
        pclose(fp);
    }
#endif

    return osName;
}

static std::string GetArchName()
{
    std::string archName;

#if defined(HG_CMP_MSC)
    archName = "x86";
#else
    archName = "unknown";
    FILE *fp = popen("arch", "r");
    if (NULL != fp)
    {
        char buff[1024] = { 0 };
        fread(buff, 1024, 1, fp);

        int len = (int)strlen(buff);
        for (int i = 0; i < len; ++i)
        {
            if (buff[i] == '\n')
                buff[i] = '\0';
        }

        archName = buff;
        pclose(fp);
    }
#endif

    return archName;
}

static std::string GetCurrVersion(const std::string& appName, const std::string& oemName)
{
    std::string version = "0.0.0.0";

    if (appName == HGVERSION_APPNAME_SCANNER)
    {
#if defined(HG_CMP_MSC)
        std::string regName;
        if (oemName == HGVERSION_OEMNAME_HANVON)
            regName = "SOFTWARE\\HanvonScan";
        else if (oemName == HGVERSION_OEMNAME_LANXUM)
            regName = "SOFTWARE\\LanxumScan";
        else if (oemName == HGVERSION_OEMNAME_CUMTENN)
            regName = "SOFTWARE\\CumtennScan";
        else if (oemName == HGVERSION_OEMNAME_MICROTEK)
            regName = "SOFTWARE\\MicrotekScan";
        else if (oemName == HGVERSION_OEMNAME_UNIS)
            regName = "SOFTWARE\\UniScan";
        else
            regName = "SOFTWARE\\HuaGoScan";

        HKEY hKey = NULL;
        RegOpenKeyExA(HKEY_LOCAL_MACHINE, regName.c_str(), 0, KEY_QUERY_VALUE, &hKey);
        if (NULL != hKey)
        {
            CHAR szData[MAX_PATH] = { 0 };
            DWORD cbData = MAX_PATH;
            if (ERROR_SUCCESS == RegQueryValueExA(hKey, "AppVersion", NULL, NULL, (LPBYTE)szData, &cbData))
            {
                version = szData;
            }

            RegCloseKey(hKey);
        }
#else
        std::string appName;
        std::string osName = GetOSName();
        if ("UnionTech" == osName)
        {
            if (oemName == HGVERSION_OEMNAME_HANVON)
                appName = "com.hanvonchina.hanvonscan";
            else if (oemName == HGVERSION_OEMNAME_LANXUM)
                appName = "com.lanxumchina.lanxumscan";
            else if (oemName == HGVERSION_OEMNAME_CUMTENN)
                appName = "com.cumtennchina.cumtennscan";
            else if (oemName == HGVERSION_OEMNAME_MICROTEK)
                appName = "com.microtekchina.microtekscan";
            else if (oemName == HGVERSION_OEMNAME_UNIS)
                appName = "com.unischina.uniscan";
            else
                appName = "com.huagaochina.huagoscan";
        }
        else
        {
            if (oemName == HGVERSION_OEMNAME_HANVON)
                appName = "scanner-driver-hanvon";
            else if (oemName == HGVERSION_OEMNAME_LANXUM)
                appName = "scanner-driver-lanxum";
            else if (oemName == HGVERSION_OEMNAME_CUMTENN)
                appName = "scanner-driver-cumtenn";
            else if (oemName == HGVERSION_OEMNAME_MICROTEK)
                appName = "scanner-driver-microtek";
            else if (oemName == HGVERSION_OEMNAME_UNIS)
                appName = "scanner-driver-unis";
            else
                appName = "scanner-driver-huagao";
        }

        std::string cmd = "dpkg -l " + appName;
        FILE* fp = popen(cmd.c_str(), "r");
        if (NULL != fp)
        {
            char buff[2048] = { 0 };
            fread(buff, 2048, 1, fp);

            char* p = strstr(buff, appName.c_str());
            if (NULL != p)
            {
                char* p2 = p + appName.size();
                while (!isdigit(*p2) && '.' != *p2)
                    ++p2;

                int len = (int)strlen(p2);
                for (int i = 0; i < len; ++i)
                {
                    if (!isdigit(p2[i]) && '.' != p2[i])
                    {
                        p2[i] = '\0';
                        break;
                    }
                }

                version = p2;
            }

            pclose(fp);
        }
#endif
    }

    return version;
}

static bool Greater(const std::string& str1, const std::string& str2)
{
    return str1 > str2;
}

static HGResult PostInfo(int type, const std::string& appName, const std::string& oemName, const std::string& desc, const std::string& crashFileUrl,
    const std::string& exceptionAddr, const std::string& feedbackInfo, const std::string& feedbackContact)
{
    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string url = "http://cd.holdtecs.net:50080/api/recode";
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        std::vector<std::string> macList;
        GetMacAddrList(macList);
        if (macList.empty())
            macList.push_back("00-00-00-00-00-00");

        std::sort(macList.begin(), macList.end(), Greater);
        std::string strMacAddrTotal;
        for (int i = 0; i < (int)macList.size(); ++i)
        {
            strMacAddrTotal += macList[i];
        }

        HGByte md5[16] = { 0 };
        HGBase_MakeMd5((const HGByte*)strMacAddrTotal.c_str(), (HGUInt)strMacAddrTotal.size(), md5);
        char md5Str[64] = { 0 };
        char* pstr = md5Str;
        for (int i = 0; i < 16; ++i)
        {
            sprintf(pstr, "%02x", md5[i]);
            pstr += 2;
        }

        std::string version = GetCurrVersion(appName, oemName);
        std::string osName = GetOSName();
        std::string archName = GetArchName();

        std::string jsonStr;
        cJSON* json = cJSON_CreateObject();
        if (NULL != json)
        {
            cJSON_AddItemToObject(json, "type", cJSON_CreateNumber(type));
            cJSON_AddItemToObject(json, "mac", cJSON_CreateString(macList[0].c_str()));
            cJSON_AddItemToObject(json, "localid", cJSON_CreateString(md5Str));
            cJSON_AddItemToObject(json, "v", cJSON_CreateString(version.c_str()));
            cJSON_AddItemToObject(json, "desc", cJSON_CreateString(desc.c_str()));
            cJSON_AddItemToObject(json, "sys", cJSON_CreateString(osName.c_str()));
            cJSON_AddItemToObject(json, "cpu", cJSON_CreateString(archName.c_str()));
            cJSON_AddItemToObject(json, "oem", cJSON_CreateString(oemName.c_str()));
            cJSON_AddItemToObject(json, "app", cJSON_CreateString(appName.c_str()));

            if (3 == type)
            {
                cJSON_AddItemToObject(json, "crashaddress", cJSON_CreateString(exceptionAddr.c_str()));
                cJSON_AddItemToObject(json, "crash_data", cJSON_CreateString(crashFileUrl.c_str()));
            }
            else if (4 == type)
            {
                cJSON_AddItemToObject(json, "contact", cJSON_CreateString(feedbackContact.c_str()));
                cJSON_AddItemToObject(json, "content", cJSON_CreateString(feedbackInfo.c_str()));
            }

            jsonStr = cJSON_Print(json);
            cJSON_Delete(json);
        }

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type:application/json;charset=UTF-8");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonStr.c_str());

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static HGResult PostInstallInfo(const std::string& appName, const std::string& oemName, const std::string& desc)
{
    return PostInfo(1, appName, oemName, desc, "", "", "", "");
}

static HGResult PostUninstallInfo(const std::string& appName, const std::string& oemName, const std::string& desc)
{
    return PostInfo(2, appName, oemName, desc, "", "", "", "");
}

static HGResult PostCrashInfo(const std::string &appName, const std::string& oemName, const std::string &desc, const std::string& crashFilePath, const std::string& exceptionAddr)
{
    std::string crashFileUrl;
    HGResult ret = CrashFileUpload(crashFilePath, crashFileUrl);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    return PostInfo(3, appName, oemName, desc, crashFileUrl, exceptionAddr, "", "");
}

static HGResult PostUserFeedback(const std::string& appName, const std::string& oemName, const std::string& desc, const std::string& feedback, const std::string& contact)
{
    return PostInfo(4, appName, oemName, desc, "", "", feedback, contact);
}

static HGResult PostDeviceInfo(const std::string& devName, const std::string& devSN, const std::string& devType,
    const std::string& devFW, HGUInt start, HGUInt close, HGUInt scan, HGUInt clean, HGInt count, HGInt pages, HGUInt stuck)
{
    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string url = "http://cd.holdtecs.net:50080/api/bhs";
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        std::string jsonStr;
        cJSON* json = cJSON_CreateObject();
        if (NULL != json)
        {
            cJSON_AddItemToObject(json, "name", cJSON_CreateString(devName.c_str()));
            cJSON_AddItemToObject(json, "sn", cJSON_CreateString(devSN.c_str()));
            cJSON_AddItemToObject(json, "type", cJSON_CreateString(devType.c_str()));
            cJSON_AddItemToObject(json, "fw", cJSON_CreateString(devFW.c_str()));

            cJSON_AddItemToObject(json, "start", cJSON_CreateNumber(start));
            cJSON_AddItemToObject(json, "close", cJSON_CreateNumber(close));
            cJSON_AddItemToObject(json, "scan", cJSON_CreateNumber(scan));
            cJSON_AddItemToObject(json, "clean", cJSON_CreateNumber(clean));
            cJSON_AddItemToObject(json, "count", cJSON_CreateNumber(count));
            cJSON_AddItemToObject(json, "pages", cJSON_CreateNumber(pages));
            cJSON_AddItemToObject(json, "stuck", cJSON_CreateNumber(stuck));

            jsonStr = cJSON_Print(json);
            cJSON_Delete(json);
        }

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type:application/json;charset=UTF-8");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonStr.c_str());

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static HGResult PostDeviceLockInfo(const std::string& devName, const std::string& devSN, const std::string& devType, 
    const std::string& devFW, HGBool isLock)
{
    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string url = "http://cd.holdtecs.net:50080/api/info";
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        std::vector<std::string> macList;
        GetMacAddrList(macList);
        if (macList.empty())
            macList.push_back("00-00-00-00-00-00");

        std::sort(macList.begin(), macList.end(), Greater);
        std::string strMacAddrTotal;
        for (int i = 0; i < (int)macList.size(); ++i)
        {
            strMacAddrTotal += macList[i];
        }

        HGByte md5[16] = { 0 };
        HGBase_MakeMd5((const HGByte*)strMacAddrTotal.c_str(), (HGUInt)strMacAddrTotal.size(), md5);
        char md5Str[64] = { 0 };
        char* pstr = md5Str;
        for (int i = 0; i < 16; ++i)
        {
            sprintf(pstr, "%02x", md5[i]);
            pstr += 2;
        }

        std::string jsonStr;
        cJSON* json = cJSON_CreateObject();
        if (NULL != json)
        {
            cJSON_AddItemToObject(json, "name", cJSON_CreateString(devName.c_str()));
            cJSON_AddItemToObject(json, "sn", cJSON_CreateString(devSN.c_str()));
            cJSON_AddItemToObject(json, "dev_type", cJSON_CreateString(devType.c_str()));
            cJSON_AddItemToObject(json, "fw", cJSON_CreateString(devFW.c_str()));

            cJSON_AddItemToObject(json, "mac", cJSON_CreateString(macList[0].c_str()));
            cJSON_AddItemToObject(json, "localid", cJSON_CreateString(md5Str));
            cJSON_AddItemToObject(json, "lock", cJSON_CreateNumber(isLock));

            jsonStr = cJSON_Print(json);
            cJSON_Delete(json);
        }

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type:application/json;charset=UTF-8");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonStr.c_str());

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static HGResult PostUserInfo(const std::string& appName, const std::string& oemName, HGUInt powerOn, HGUInt powerOff, HGUInt login, HGUInt logout)
{
    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string url = "http://cd.holdtecs.net:50080/api/behaviors";
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        std::vector<std::string> macList;
        GetMacAddrList(macList);
        if (macList.empty())
            macList.push_back("00-00-00-00-00-00");

        std::sort(macList.begin(), macList.end(), Greater);
        std::string strMacAddrTotal;
        for (int i = 0; i < (int)macList.size(); ++i)
        {
            strMacAddrTotal += macList[i];
        }

        HGByte md5[16] = { 0 };
        HGBase_MakeMd5((const HGByte*)strMacAddrTotal.c_str(), (HGUInt)strMacAddrTotal.size(), md5);
        char md5Str[64] = { 0 };
        char* pstr = md5Str;
        for (int i = 0; i < 16; ++i)
        {
            sprintf(pstr, "%02x", md5[i]);
            pstr += 2;
        }

        std::string version = GetCurrVersion(appName, oemName);
        std::string osName = GetOSName();
        std::string archName = GetArchName();

        std::string jsonStr;
        cJSON* json = cJSON_CreateObject();
        if (NULL != json)
        {
            cJSON_AddItemToObject(json, "mac", cJSON_CreateString(macList[0].c_str()));
            cJSON_AddItemToObject(json, "localid", cJSON_CreateString(md5Str));
            cJSON_AddItemToObject(json, "v", cJSON_CreateString(version.c_str()));
            cJSON_AddItemToObject(json, "sys", cJSON_CreateString(osName.c_str()));
            cJSON_AddItemToObject(json, "cpu", cJSON_CreateString(archName.c_str()));
            cJSON_AddItemToObject(json, "oem", cJSON_CreateString(oemName.c_str()));
            cJSON_AddItemToObject(json, "app_name", cJSON_CreateString(appName.c_str()));

            cJSON_AddItemToObject(json, "power_on", cJSON_CreateNumber(powerOn));
            cJSON_AddItemToObject(json, "power_off", cJSON_CreateNumber(powerOff));
            cJSON_AddItemToObject(json, "login", cJSON_CreateNumber(login));
            cJSON_AddItemToObject(json, "logout", cJSON_CreateNumber(logout));

            jsonStr = cJSON_Print(json);
            cJSON_Delete(json);
        }

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Content-Type:application/json;charset=UTF-8");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_POST, 1);
        curl_easy_setopt(curl, CURLOPT_POSTFIELDS, jsonStr.c_str());

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static HGResult GetVersionList(const std::string& appName, const std::string& oemName, std::list<VersionInfoImpl> &versionList)
{
    versionList.clear();

    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string osName = GetOSName();
        std::string archName = GetArchName();

        std::string url = "http://cd.holdtecs.net:50080/api/ver?app=" + appName + "&oem=" + oemName + "&cpu=" + archName + "&sys=" + osName;
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Accept-Encoding:gzip, deflate, sdch");
        headers = curl_slist_append(headers, "Accept-Language:zh-CN,zh;q=0.8");
        headers = curl_slist_append(headers, "Connection:keep-alive");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }
                    else if (0 == strcmp(p->string, "data") && p->type == cJSON_Array)
                    {
                        cJSON* p2 = p->child;
                        while (NULL != p2)
                        {
                            VersionInfoImpl version;

                            cJSON* p3 = p2->child;
                            while (NULL != p3)
                            {
                                if (0 == strcmp(p3->string, "full") && p3->type == cJSON_String)
                                    version.url = p3->valuestring;
                                else if (0 == strcmp(p3->string, "size") && p3->type == cJSON_String)
                                    version.size = atoll(p3->valuestring);
                                else if (0 == strcmp(p3->string, "desc") && p3->type == cJSON_String)
                                    version.desc = p3->valuestring;
                                else if (0 == strcmp(p3->string, "bug") && p3->type == cJSON_String)
                                    version.bugInfo = p3->valuestring;
                                else if (0 == strcmp(p3->string, "md5") && p3->type == cJSON_String)
                                    version.md5 = p3->valuestring;
                                else if (0 == strcmp(p3->string, "v") && p3->type == cJSON_String)
                                    version.version = p3->valuestring;

                                p3 = p3->next;
                            }

                            versionList.push_back(version);
                            p2 = p2->next;
                        }
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static size_t curlWriteFunction(void* ptr, size_t size, size_t nmemb, FILE* stream)
{
    return fwrite(ptr, size, nmemb, stream);
}

struct myprogress
{
    HGHttpDownloadFunc func;
    void* param;
};

static int xferinfo2(void* p, curl_off_t dltotal, curl_off_t dlnow, curl_off_t ultotal, curl_off_t ulnow)
{
    HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "ulnow=%lld, ultotal=%lld", ulnow, ultotal);

    struct myprogress* myp = (struct myprogress*)p;
    if (NULL != myp->func)
        return myp->func(dltotal, dlnow, myp->param);
    return 0;
}

static HGResult HttpDownload(const std::string& url, const std::string& saveFilePath, HGHttpDownloadFunc func, void* param)
{
    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        FILE* fp = fopen(saveFilePath.c_str(), "wb");    // 打开文件，准备写入
        if (NULL != fp)
        {
            curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
            curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
            curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curlWriteFunction);

            struct myprogress prog;
            prog.func = func;
            prog.param = param;
            curl_easy_setopt(curl, CURLOPT_XFERINFODATA, &prog);

            curl_easy_setopt(curl, CURLOPT_XFERINFOFUNCTION, xferinfo2);
            curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);

            /* Perform the request, res will get the return code */
            CURLcode res = curl_easy_perform(curl);
            /* Check for errors */
            if (res != CURLE_OK)
                HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
            else
                ret = HGBASE_ERR_OK;

            fclose(fp);
        }
        else
        {
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "HttpDownload: Create File Fail %s", saveFilePath.c_str());
            ret = HGBASE_ERR_ACCESSDENIED;
        }

        curl_easy_cleanup(curl);
    }

    return ret;
}



HGVersionMgrImpl::HGVersionMgrImpl()
{
    m_lock = NULL;
    HGBase_CreateLock(&m_lock);
	m_serverCfg.postCrashInfo = HGFALSE;
	m_serverCfg.postUserBehaviorInfo = HGFALSE;
	m_serverCfg.postDeviceInfo = HGFALSE;

	curl_global_init(CURL_GLOBAL_ALL);

    m_msgPump = NULL;
    HGBase_CreateMsgPump(&m_msgPump);
    m_thread = NULL;
    HGBase_OpenThread(ThreadFunc, this, &m_thread);
}

HGVersionMgrImpl::~HGVersionMgrImpl()
{
    HGBase_ExitMsgPump(m_msgPump);
    HGBase_CloseThread(m_thread);
    m_thread = NULL;
    HGBase_DestroyMsgPump(m_msgPump);
    m_msgPump = NULL;

	curl_global_cleanup();

    HGBase_DestroyLock(m_lock);
    m_lock = NULL;
}

HGResult HGVersionMgrImpl::GetServerConfig(HGServerConfig* config)
{
    if (NULL == config)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGBase_EnterLock(m_lock);
    memcpy(config, &m_serverCfg, sizeof(HGServerConfig));
    HGBase_LeaveLock(m_lock);
    return HGBASE_ERR_OK;
}

HGResult HGVersionMgrImpl::PostInstallInfo(const HGChar* appName, const HGChar* oemName, const HGChar* desc)
{
    return ::PostInstallInfo(appName, oemName, desc);
}

HGResult HGVersionMgrImpl::PostUninstallInfo(const HGChar* appName, const HGChar* oemName, const HGChar* desc)
{
    return ::PostUninstallInfo(appName, oemName, desc);
}

HGResult HGVersionMgrImpl::PostCrashInfo(const HGChar* appName, const HGChar* oemName, const HGChar* desc, const HGChar* crashFilePath, const HGChar* exceptionAddr)
{
    HGBase_EnterLock(m_lock);
    HGBool postCrashInfo = m_serverCfg.postCrashInfo;
    HGBase_LeaveLock(m_lock);
    if (!postCrashInfo)
        return HGBASE_ERR_FAIL;

    return ::PostCrashInfo(appName, oemName, desc, crashFilePath, exceptionAddr);
}

HGResult HGVersionMgrImpl::PostUserFeedback(const HGChar* appName, const HGChar* oemName, const HGChar* desc, const HGChar* feedback, const HGChar* contact)
{
    return ::PostUserFeedback(appName, oemName, desc, feedback, contact);
}

HGResult HGVersionMgrImpl::PostDeviceOpenInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceInfoParam* param = new PostDeviceInfoParam;
    param->devName = devName;
    param->devSN = devSN;
    param->devType = devType;
    param->devFW = devFW;

    HGMsg msg;
    msg.id = MsgId_PostDeviceOpenInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDeviceCloseInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceInfoParam* param = new PostDeviceInfoParam;
    param->devName = devName;
    param->devSN = devSN;
    param->devType = devType;
    param->devFW = devFW;

    HGMsg msg;
    msg.id = MsgId_PostDeviceCloseInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDeviceScanCountInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW, HGUInt scanCount)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceScanCountInfoParam* param = new PostDeviceScanCountInfoParam;
    param->baseInfo.devName = devName;
    param->baseInfo.devSN = devSN;
    param->baseInfo.devType = devType;
    param->baseInfo.devFW = devFW;
    param->scanCount = scanCount;

    HGMsg msg;
    msg.id = MsgId_PostDeviceScanCountInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDeviceClearRollerInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceInfoParam* param = new PostDeviceInfoParam;
    param->devName = devName;
    param->devSN = devSN;
    param->devType = devType;
    param->devFW = devFW;

    HGMsg msg;
    msg.id = MsgId_PostDeviceClearRollerInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDeviceHistroyCountInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW, HGUInt histroyCount)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceHistroyCountInfoParam* param = new PostDeviceHistroyCountInfoParam;
    param->baseInfo.devName = devName;
    param->baseInfo.devSN = devSN;
    param->baseInfo.devType = devType;
    param->baseInfo.devFW = devFW;
    param->histroyCount = histroyCount;

    HGMsg msg;
    msg.id = MsgId_PostDeviceHistroyCountInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDeviceRollerCountInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW, HGUInt rollerCount)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceRollerCountInfoParam* param = new PostDeviceRollerCountInfoParam;
    param->baseInfo.devName = devName;
    param->baseInfo.devSN = devSN;
    param->baseInfo.devType = devType;
    param->baseInfo.devFW = devFW;
    param->rollerCount = rollerCount;

    HGMsg msg;
    msg.id = MsgId_PostDeviceRollerCountInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDevicePaperJamInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW)
{
    HGBase_EnterLock(m_lock);
    HGBool postDeviceInfo = m_serverCfg.postDeviceInfo;
    HGBase_LeaveLock(m_lock);
    if (!postDeviceInfo)
        return HGBASE_ERR_FAIL;

    if (NULL == devSN || '\0' == *devSN)
        return HGBASE_ERR_FAIL;

    PostDeviceInfoParam* param = new PostDeviceInfoParam;
    param->devName = devName;
    param->devSN = devSN;
    param->devType = devType;
    param->devFW = devFW;

    HGMsg msg;
    msg.id = MsgId_PostDevicePaperJamInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostUserOpenInfo(const HGChar* appName, const HGChar* oemName)
{
    HGBase_EnterLock(m_lock);
    HGBool postUserBehaviorInfo = m_serverCfg.postUserBehaviorInfo;
    HGBase_LeaveLock(m_lock);
    if (!postUserBehaviorInfo)
        return HGBASE_ERR_FAIL;

    PostUserInfoParam* param = new PostUserInfoParam;
    param->appName = appName;
    param->oemName = oemName;

    HGMsg msg;
    msg.id = MsgId_PostUserOpenInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostUserCloseInfo(const HGChar* appName, const HGChar* oemName)
{
    HGBase_EnterLock(m_lock);
    HGBool postUserBehaviorInfo = m_serverCfg.postUserBehaviorInfo;
    HGBase_LeaveLock(m_lock);
    if (!postUserBehaviorInfo)
        return HGBASE_ERR_FAIL;

    PostUserInfoParam* param = new PostUserInfoParam;
    param->appName = appName;
    param->oemName = oemName;

    HGMsg msg;
    msg.id = MsgId_PostUserCloseInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostUserLoginInfo(const HGChar* appName, const HGChar* oemName)
{
    HGBase_EnterLock(m_lock);
    HGBool postUserBehaviorInfo = m_serverCfg.postUserBehaviorInfo;
    HGBase_LeaveLock(m_lock);
    if (!postUserBehaviorInfo)
        return HGBASE_ERR_FAIL;

    PostUserInfoParam* param = new PostUserInfoParam;
    param->appName = appName;
    param->oemName = oemName;

    HGMsg msg;
    msg.id = MsgId_PostUserLoginInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostUserLogoutInfo(const HGChar* appName, const HGChar* oemName)
{
    HGBase_EnterLock(m_lock);
    HGBool postUserBehaviorInfo = m_serverCfg.postUserBehaviorInfo;
    HGBase_LeaveLock(m_lock);
    if (!postUserBehaviorInfo)
        return HGBASE_ERR_FAIL;

    PostUserInfoParam* param = new PostUserInfoParam;
    param->appName = appName;
    param->oemName = oemName;

    HGMsg msg;
    msg.id = MsgId_PostUserLogoutInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::PostDeviceLockInfo(const HGChar* devName, const HGChar* devSN, const HGChar* devType,
    const HGChar* devFW, HGBool isLock)
{
    PostDeviceLockInfoParam* param = new PostDeviceLockInfoParam;
    param->baseInfo.devName = devName;
    param->baseInfo.devSN = devSN;
    param->baseInfo.devType = devType;
    param->baseInfo.devFW = devFW;
    param->islock = isLock;

    HGMsg msg;
    msg.id = MsgId_PostDeviceLockInfo;
    msg.data = param;
    HGResult ret = HGBase_PostPumpMessage(m_msgPump, &msg);
    if (HGBASE_ERR_OK != ret)
        delete param;
    return ret;
}

HGResult HGVersionMgrImpl::GetVersionList(const HGChar* appName, const HGChar* oemName, HGVersionInfo** info, HGUInt* count)
{
    if (NULL == info || NULL == count)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    std::list<VersionInfoImpl> versionList;
    HGResult ret = ::GetVersionList(appName, oemName, versionList);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    if (versionList.empty())
    {
        return HGBASE_ERR_FAIL;
    }

    HGUInt count2 = (HGUInt)versionList.size();
    HGVersionInfo *info2 = new HGVersionInfo[count2];

    HGUInt index = 0;
    std::list<VersionInfoImpl>::const_iterator iter;
    for (iter = versionList.begin(); iter != versionList.end(); ++iter)
    {
        const VersionInfoImpl& ver = *iter;
        info2[index].version = new HGChar[ver.version.size() + 1];
        strcpy(info2[index].version, ver.version.c_str());
        info2[index].desc = new HGChar[ver.desc.size() + 1];
        strcpy(info2[index].desc, ver.desc.c_str());
        info2[index].bugInfo = new HGChar[ver.bugInfo.size() + 1];
        strcpy(info2[index].bugInfo, ver.bugInfo.c_str());
        info2[index].url = new HGChar[ver.url.size() + 1];
        strcpy(info2[index].url, ver.url.c_str());
        info2[index].size = ver.size;
        info2[index].md5 = new HGChar[ver.md5.size() + 1];
        strcpy(info2[index].md5, ver.md5.c_str());

        ++index;
    }

    *info = info2;
    *count = count2;
    return HGBASE_ERR_OK;
}

HGResult HGVersionMgrImpl::HttpDownload(const HGChar* url, const HGChar* saveFilePath, HGHttpDownloadFunc func, HGPointer param)
{
    return ::HttpDownload(url, saveFilePath, func, param);
}

HGResult HGVersionMgrImpl::ReleaseVersionList(HGVersionInfo* info, HGUInt count)
{
    if (NULL == info || 0 == count)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    for (HGUInt i = 0; i < count; ++i)
    {
        delete[] info[i].version;
        info[i].version = NULL;
        delete[] info[i].desc;
        info[i].desc = NULL;
        delete[] info[i].bugInfo;
        info[i].bugInfo = NULL;
        delete[] info[i].url;
        info[i].url = NULL;
        delete[] info[i].md5;
        info[i].md5 = NULL;
    }

    delete[] info;
    return HGBASE_ERR_OK;
}

HGResult HGVersionMgrImpl::GetCurrVersion(const HGChar* appName, const HGChar* oemName, HGChar* version, HGUInt maxLen)
{
    if (NULL == version || 0 == maxLen)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    std::string ver = ::GetCurrVersion(appName, oemName);
    if (maxLen < ver.size() + 1)
    {
        return HGBASE_ERR_FAIL;
    }

    strcpy(version, ver.c_str());
    return HGBASE_ERR_OK;
}

HGResult HGVersionMgrImpl::BlackListCheck(const HGChar* devSN, HGBool* inList)
{
    if (NULL == devSN || NULL == inList)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    *inList = HGFALSE;

    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        char url[256];
        sprintf(url, "http://cd.holdtecs.net:50080/api/check?sn=%s", devSN);
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url);

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Accept-Encoding:gzip, deflate, sdch");
        headers = curl_slist_append(headers, "Accept-Language:zh-CN,zh;q=0.8");
        headers = curl_slist_append(headers, "Connection:keep-alive");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }
                    else if (0 == strcmp(p->string, "data") && p->type == cJSON_False)
                    {
                        *inList = HGTRUE;
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

static HGResult GetDriverVersionList(const std::string& devType, std::list<VersionInfoImpl>& versionList)
{
    versionList.clear();

    HGResult ret = HGBASE_ERR_FAIL;
    CURL* curl = curl_easy_init();
    if (NULL != curl)
    {
        std::stringstream out;

        std::string url = "http://cd.holdtecs.net:50080/api/ver?app=Driver&dev_type=" + devType;
        curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, 2);
        curl_easy_setopt(curl, CURLOPT_URL, url.c_str());

        struct curl_slist* headers = NULL;
        headers = curl_slist_append(headers, "Accept-Encoding:gzip, deflate, sdch");
        headers = curl_slist_append(headers, "Accept-Language:zh-CN,zh;q=0.8");
        headers = curl_slist_append(headers, "Connection:keep-alive");
        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
        curl_easy_setopt(curl, CURLOPT_HTTPGET, 1);

        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &out);

        /* Perform the request, res will get the return code */
        CURLcode res = curl_easy_perform(curl);
        /* Check for errors */
        if (res != CURLE_OK)
            HGBase_WriteInfo(HGBASE_INFOTYPE_ERROR, "curl_easy_perform() failed: %s", curl_easy_strerror(res));
        else
        {
            std::string str_json = out.str(); // 返回值
            HGBase_WriteInfo(HGBASE_INFOTYPE_DESC, "str_json=%s", Utf8ToStdString(str_json).c_str());

            cJSON* json = cJSON_Parse(str_json.c_str());
            if (NULL != json)
            {
                cJSON* p = json->child;
                while (NULL != p)
                {
                    if (0 == strcmp(p->string, "code") && p->type == cJSON_Number)
                    {
                        if (1 == p->valueint)
                            ret = HGBASE_ERR_OK;
                    }
                    else if (0 == strcmp(p->string, "data") && p->type == cJSON_Array)
                    {
                        cJSON* p2 = p->child;
                        while (NULL != p2)
                        {
                            VersionInfoImpl version;

                            cJSON* p3 = p2->child;
                            while (NULL != p3)
                            {
                                if (0 == strcmp(p3->string, "full") && p3->type == cJSON_String)
                                    version.url = p3->valuestring;
                                else if (0 == strcmp(p3->string, "size") && p3->type == cJSON_String)
                                    version.size = atoll(p3->valuestring);
                                else if (0 == strcmp(p3->string, "desc") && p3->type == cJSON_String)
                                    version.desc = p3->valuestring;
                                else if (0 == strcmp(p3->string, "bug") && p3->type == cJSON_String)
                                    version.bugInfo = p3->valuestring;
                                else if (0 == strcmp(p3->string, "md5") && p3->type == cJSON_String)
                                    version.md5 = p3->valuestring;
                                else if (0 == strcmp(p3->string, "v") && p3->type == cJSON_String)
                                    version.version = p3->valuestring;

                                p3 = p3->next;
                            }

                            versionList.push_back(version);
                            p2 = p2->next;
                        }
                    }

                    p = p->next;
                }

                cJSON_Delete(json);
            }
        }

        curl_slist_free_all(headers);
        /* always cleanup */
        curl_easy_cleanup(curl);
    }

    return ret;
}

HGResult HGVersionMgrImpl::GetDriverVersionList(const HGChar* devType, HGVersionInfo** info, HGUInt* count)
{
    if (NULL == info || NULL == count)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    std::list<VersionInfoImpl> versionList;
    HGResult ret = ::GetDriverVersionList(devType, versionList);
    if (HGBASE_ERR_OK != ret)
    {
        return ret;
    }

    if (versionList.empty())
    {
        return HGBASE_ERR_FAIL;
    }

    HGUInt count2 = (HGUInt)versionList.size();
    HGVersionInfo* info2 = new HGVersionInfo[count2];

    HGUInt index = 0;
    std::list<VersionInfoImpl>::const_iterator iter;
    for (iter = versionList.begin(); iter != versionList.end(); ++iter)
    {
        const VersionInfoImpl& ver = *iter;
        info2[index].version = new HGChar[ver.version.size() + 1];
        strcpy(info2[index].version, ver.version.c_str());
        info2[index].desc = new HGChar[ver.desc.size() + 1];
        strcpy(info2[index].desc, ver.desc.c_str());
        info2[index].bugInfo = new HGChar[ver.bugInfo.size() + 1];
        strcpy(info2[index].bugInfo, ver.bugInfo.c_str());
        info2[index].url = new HGChar[ver.url.size() + 1];
        strcpy(info2[index].url, ver.url.c_str());
        info2[index].size = ver.size;
        info2[index].md5 = new HGChar[ver.md5.size() + 1];
        strcpy(info2[index].md5, ver.md5.c_str());

        ++index;
    }

    *info = info2;
    *count = count2;
    return HGBASE_ERR_OK;
}

void HGAPI HGVersionMgrImpl::ThreadFunc(HGThread thread, HGPointer param)
{
    HGVersionMgrImpl* p = (HGVersionMgrImpl*)param;

    HGServerConfig config;
    ::GetServerConfig(config);
    HGBase_EnterLock(p->m_lock);
    memcpy(&p->m_serverCfg, &config, sizeof(HGServerConfig));
    HGBase_LeaveLock(p->m_lock);

    HGBase_RunMsgPump(p->m_msgPump, MsgPumpFunc, p);
}

void HGAPI HGVersionMgrImpl::MsgPumpFunc(HGMsgPump msgPump, const HGMsg* msg, HGPointer param)
{
    (void)msgPump;
    assert(NULL != msg);
    HGVersionMgrImpl* p = (HGVersionMgrImpl*)param;

    switch (msg->id)
    {
    case MsgId_PostDeviceOpenInfo:
    {
        PostDeviceInfoParam* param = (PostDeviceInfoParam*)msg->data;
        ::PostDeviceInfo(param->devName, param->devSN, param->devType, param->devFW, 1, 0, 0, 0, -1, -1, 0);
        delete param;
    }
    break;
    case MsgId_PostDeviceCloseInfo:
    {
        PostDeviceInfoParam* param = (PostDeviceInfoParam*)msg->data;
        ::PostDeviceInfo(param->devName, param->devSN, param->devType, param->devFW, 0, 1, 0, 0, -1, -1, 0);
        delete param;
    }
    break;
    case MsgId_PostDeviceScanCountInfo:
    {
        PostDeviceScanCountInfoParam* param = (PostDeviceScanCountInfoParam*)msg->data;
        ::PostDeviceInfo(param->baseInfo.devName, param->baseInfo.devSN, param->baseInfo.devType,
            param->baseInfo.devFW, 0, 0, param->scanCount, 0, -1, -1, 0);
        delete param;
    }
    break;
    case MsgId_PostDeviceClearRollerInfo:
    {
        PostDeviceInfoParam* param = (PostDeviceInfoParam*)msg->data;
        ::PostDeviceInfo(param->devName, param->devSN, param->devType, param->devFW, 0, 0, 0, 1, -1, -1, 0);
        delete param;
    }
    break;
    case MsgId_PostDeviceHistroyCountInfo:
    {
        PostDeviceHistroyCountInfoParam* param = (PostDeviceHistroyCountInfoParam*)msg->data;
        ::PostDeviceInfo(param->baseInfo.devName, param->baseInfo.devSN, param->baseInfo.devType,
            param->baseInfo.devFW, 0, 0, 0, 0, -1, param->histroyCount, 0);
        delete param;
    }
    break;
    case MsgId_PostDeviceRollerCountInfo:
    {
        PostDeviceRollerCountInfoParam* param = (PostDeviceRollerCountInfoParam*)msg->data;
        ::PostDeviceInfo(param->baseInfo.devName, param->baseInfo.devSN, param->baseInfo.devType,
            param->baseInfo.devFW, 0, 0, 0, 0, param->rollerCount, -1, 0);
        delete param;
    }
    break;
    case MsgId_PostDevicePaperJamInfo:
    {
        PostDeviceInfoParam* param = (PostDeviceInfoParam*)msg->data;
        ::PostDeviceInfo(param->devName, param->devSN, param->devType, param->devFW, 0, 0, 0, 0, -1, -1, 1);
        delete param;
    }
    break;
    case MsgId_PostUserOpenInfo:
    {
        PostUserInfoParam* param = (PostUserInfoParam*)msg->data;
        ::PostUserInfo(param->appName, param->oemName, 1, 0, 0, 0);
        delete param;
    }
    break;
    case MsgId_PostUserCloseInfo:
    {
        PostUserInfoParam* param = (PostUserInfoParam*)msg->data;
        ::PostUserInfo(param->appName, param->oemName, 0, 1, 0, 0);
        delete param;
    }
    break;
    case MsgId_PostUserLoginInfo:
    {
        PostUserInfoParam* param = (PostUserInfoParam*)msg->data;
        ::PostUserInfo(param->appName, param->oemName, 0, 0, 1, 0);
        delete param;
    }
    break;
    case MsgId_PostUserLogoutInfo:
    {
        PostUserInfoParam* param = (PostUserInfoParam*)msg->data;
        ::PostUserInfo(param->appName, param->oemName, 0, 0, 0, 1);
        delete param;
    }
    break;
    case MsgId_PostDeviceLockInfo:
    {
        PostDeviceLockInfoParam* param = (PostDeviceLockInfoParam*)msg->data;
        ::PostDeviceLockInfo(param->baseInfo.devName, param->baseInfo.devSN, param->baseInfo.devType, 
            param->baseInfo.devFW, param->islock);
        delete param;
    }
    break;
    }
}