#include "HGVersion.h"
#include "HGVersionImpl.hpp"
#include "../base/HGInc.h"
#include <vector>
#include <assert.h>
#include <string>

HGResult HGAPI HGVersion_CreateMgr(HGVersionMgr* mgr)
{
	if (NULL == mgr)
	{
		return HGBASE_ERR_INVALIDARG;
	}

	HGVersionMgrImpl* versionMgrImpl = new HGVersionMgrImpl;
	*mgr = (HGVersionMgr)versionMgrImpl;
	return HGBASE_ERR_OK;
}

HGResult HGAPI HGVersion_DestroyMgr(HGVersionMgr mgr)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl *)mgr;
    delete versionMgrImpl;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGVersion_GetServerConfig(HGVersionMgr mgr, HGServerConfig* config)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->GetServerConfig(config);
}

HGResult HGAPI HGVersion_PostInstallInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName, const HGChar* desc)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostInstallInfo(appName, oemName, desc);
}

HGResult HGAPI HGVersion_PostUninstallInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName, const HGChar* desc)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostUninstallInfo(appName, oemName, desc);
}

HGResult HGAPI HGVersion_PostCrashInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName, const HGChar* desc, const HGChar* crashFilePath, const HGChar* exceptionAddr)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostCrashInfo(appName, oemName, desc, crashFilePath, exceptionAddr);
}

HGResult HGAPI HGVersion_PostUserFeedback(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName, const HGChar* desc, const HGChar* feedback, const HGChar* contact)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostUserFeedback(appName, oemName, desc, feedback, contact);
}

HGResult HGAPI HGVersion_PostDeviceOpenInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceOpenInfo(devName, devSN, devType, devFW);
}

HGResult HGAPI HGVersion_PostDeviceCloseInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceCloseInfo(devName, devSN, devType, devFW);
}

HGResult HGAPI HGVersion_PostDeviceScanCountInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW, HGUInt scanCount)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceScanCountInfo(devName, devSN, devType, devFW, scanCount);
}

HGResult HGAPI HGVersion_PostDeviceClearRollerInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceClearRollerInfo(devName, devSN, devType, devFW);
}

HGResult HGAPI HGVersion_PostDeviceHistroyCountInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW, HGUInt histroyCount)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceHistroyCountInfo(devName, devSN, devType, devFW, histroyCount);
}

HGResult HGAPI HGVersion_PostDeviceRollerCountInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW, HGUInt rollerCount)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceRollerCountInfo(devName, devSN, devType, devFW, rollerCount);
}

HGResult HGAPI HGVersion_PostDevicePaperJamInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDevicePaperJamInfo(devName, devSN, devType, devFW);
}

HGResult HGAPI HGVersion_PostUserOpenInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostUserOpenInfo(appName, oemName);
}

HGResult HGAPI HGVersion_PostUserCloseInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostUserCloseInfo(appName, oemName);
}

HGResult HGAPI HGVersion_PostUserLoginInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostUserLoginInfo(appName, oemName);
}

HGResult HGAPI HGVersion_PostUserLogoutInfo(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostUserLogoutInfo(appName, oemName);
}

HGResult HGAPI HGVersion_PostDeviceLockInfo(HGVersionMgr mgr, const HGChar* devName, const HGChar* devSN,
    const HGChar* devType, const HGChar* devFW, HGBool isLock)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->PostDeviceLockInfo(devName, devSN, devType, devFW, isLock);
}

HGResult HGAPI HGVersion_GetVersionList(HGVersionMgr mgr, const HGChar* appName, const HGChar* oemName, HGVersionInfo** info, HGUInt* count)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->GetVersionList(appName, oemName, info, count);
}

HGResult HGAPI HGVersion_HttpDownload(HGVersionMgr mgr, const HGChar* url, const HGChar* saveFilePath, HGHttpDownloadFunc func, HGPointer param)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->HttpDownload(url, saveFilePath, func, param);
}

HGResult HGAPI HGVersion_ReleaseVersionList(HGVersionInfo* info, HGUInt count)
{
    return HGVersionMgrImpl::ReleaseVersionList(info, count);
}

HGResult HGAPI HGVersion_GetCurrVersion(const HGChar* appName, const HGChar* oemName, HGChar* version, HGUInt maxLen)
{
	return HGVersionMgrImpl::GetCurrVersion(appName, oemName, version, maxLen);
}

static std::vector<std::string> split(std::string strtem, char a)
{
    std::vector<std::string> strvec;

    std::string::size_type pos1, pos2;
    pos2 = strtem.find(a);
    pos1 = 0;
    while (std::string::npos != pos2)
    {
        strvec.push_back(strtem.substr(pos1, pos2 - pos1));

        pos1 = pos2 + 1;
        pos2 = strtem.find(a, pos1);
    }
    strvec.push_back(strtem.substr(pos1));

    return strvec;
}

static int CompareVersion(const std::string& version1, const std::string& version2)
{
    std::vector<std::string> versionList1 = split(version1, '.');
    std::vector<std::string> versionList2 = split(version2, '.');

    int size1 = (int)versionList1.size();
    int size2 = (int)versionList2.size();

    int i = 0;
    while (i < size1 && i < size2)
    {
        if (atoi(versionList1[i].c_str()) < atoi(versionList2[i].c_str()))
        {
            return -1;
        }
        else if (atoi(versionList1[i].c_str()) > atoi(versionList2[i].c_str()))
        {
            return 1;
        }

        ++i;
    }

    if (i == size1 && i < size2)
        return -1;
    else if (i < size1 && i == size2)
        return 1;

    assert(i == size1 && i == size2);
    return 0;
}

HGResult HGAPI HGVersion_CompareVersion(const HGChar* version1, const HGChar* version2, HGInt* result)
{
    if (NULL == result)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    int ret = ::CompareVersion(version1, version2);
    *result = ret;
    return HGBASE_ERR_OK;
}

HGResult HGAPI HGVersion_BlackListCheck(HGVersionMgr mgr, const HGChar* devSN, HGBool* inList)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->BlackListCheck(devSN, inList);
}

HGResult HGAPI HGVersion_GetDriverVersionList(HGVersionMgr mgr, const HGChar* devType, HGVersionInfo** info, HGUInt* count)
{
    if (NULL == mgr)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    HGVersionMgrImpl* versionMgrImpl = (HGVersionMgrImpl*)mgr;
    return versionMgrImpl->GetDriverVersionList(devType, info, count);
}