#include "HGVersion.h"
#include "HGVersionImpl.hpp"
#include "../base/HGInc.h"
#include <vector>
#include <assert.h>
#include <string>
#if defined(HG_CMP_MSC)
#include <shellapi.h>
#include <tlhelp32.h>
#include <psapi.h>
#endif

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_GetAppStatus(const HGChar* appName, const HGChar* oemName, HGBool *isRun)
{
    if (NULL == appName || NULL == oemName || NULL == isRun)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    *isRun = HGFALSE;

    if (0 == strcmp(appName, HGVERSION_APPNAME_SCANNER))
    {
    #if defined(HG_CMP_MSC)

        std::wstring appPath;
        std::wstring regName;

        if (0 == strcmp(oemName, HGVERSION_OEMNAME_HANVON))
            regName = L"SOFTWARE\\HanvonScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_LANXUM))
            regName = L"SOFTWARE\\LanxumScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_CUMTENN))
            regName = L"SOFTWARE\\CumtennScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_MICROTEK))
            regName = L"SOFTWARE\\MicrotekScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_UNIS))
            regName = L"SOFTWARE\\UniScan";
        else
            regName = L"SOFTWARE\\HuaGoScan";

        HKEY hKey = nullptr;
        RegOpenKeyExW(HKEY_LOCAL_MACHINE, regName.c_str(), 0, KEY_QUERY_VALUE, &hKey);
        if (nullptr != hKey)
        {
            WCHAR szData[MAX_PATH] = { 0 };
            DWORD cbData = MAX_PATH;
            if (ERROR_SUCCESS == RegQueryValueExW(hKey, L"Application", nullptr, nullptr, (LPBYTE)szData, &cbData))
            {
                appPath = szData;
            }

            RegCloseKey(hKey);
        }

        if (!appPath.empty())
        {
            HANDLE hSnapshot = ::CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
            if (hSnapshot != INVALID_HANDLE_VALUE)
            {
                PROCESSENTRY32 pe;
                pe.dwSize = sizeof(PROCESSENTRY32);
                BOOL bFindFirstProcess = ::Process32First(hSnapshot, &pe);
                if (bFindFirstProcess)
                {
                    do
                    {
                        WCHAR exeFullPath[1024] = { 0 };
                        HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pe.th32ProcessID);
                        if (nullptr != hProcess)
                        {
                            ::GetModuleFileNameExW(hProcess, NULL, exeFullPath, 1024);
                            ::CloseHandle(hProcess);
                        }

                        if (0 == wcsicmp(exeFullPath, appPath.c_str()))
                        {
                            *isRun = HGTRUE;
                            break;
                        }

                    } while (::Process32Next(hSnapshot, &pe));
                }

                ::CloseHandle(hSnapshot);
            }
        }

    #else
        std::string cmd;
        std::string appPath;

        std::string osName;
        FILE *file = popen("cat /etc/issue | cut -d\' \' -f1", "r");
        if (NULL != file)
        {
            char data[1024] = {0};
            if (NULL != fgets(data, 1024, file))
                osName = data;
            pclose(file);
        }

        printf("osName=%s\n", osName.c_str());
        if (osName.find("UnionTech") != std::string::npos)
        {
            if (0 == strcmp(oemName, HGVERSION_OEMNAME_HANVON))
            {
                cmd = "ps -wef | grep HanvonScan";
                appPath = "/opt/apps/com.hanvonchina.hanvonscan/files/bin/HanvonScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_LANXUM))
            {
                cmd = "ps -wef | grep LanxumScan";
                appPath = "/opt/apps/com.lanxumchina.lanxumscan/files/bin/LanxumScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_CUMTENN))
            {
                cmd = "ps -wef | grep CumtennScan";
                appPath = "/opt/apps/com.cumtennchina.cumtennscan/files/bin/CumtennScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_MICROTEK))
            {
                cmd = "ps -wef | grep MicrotekScan";
                appPath = "/opt/apps/com.microtekchina.microtekscan-ex/files/bin/MicrotekScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_UNIS))
            {
                cmd = "ps -wef | grep UniScan";
                appPath = "/opt/apps/com.unischina.uniscan/files/bin/UniScan";
            }
            else
            {
                cmd = "ps -wef | grep HuaGoScan";
                appPath = "/opt/apps/com.huagaochina.huagoscan/files/bin/HuaGoScan";
            }
        }
        else
        {
            if (0 == strcmp(oemName, HGVERSION_OEMNAME_HANVON))
            {
                cmd = "ps -wef | grep HanvonScan";
                appPath = "/opt/apps/scanner-driver-hanvon/bin/HanvonScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_LANXUM))
            {
                cmd = "ps -wef | grep LanxumScan";
                appPath = "/opt/apps/scanner-driver-lanxum/bin/LanxumScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_CUMTENN))
            {
                cmd = "ps -wef | grep CumtennScan";
                appPath = "/opt/apps/scanner-driver-cumtenn/bin/CumtennScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_MICROTEK))
            {
                cmd = "ps -wef | grep MicrotekScan";
                appPath = "/opt/apps/scanner-driver-microtek-ex/bin/MicrotekScan";
            }
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_UNIS))
            {
                cmd = "ps -wef | grep UniScan";
                appPath = "/opt/apps/scanner-driver-unis/bin/UniScan";
            }
            else
            {
                cmd = "ps -wef | grep HuaGoScan";
                appPath = "/opt/apps/scanner-driver-huagao/bin/HuaGoScan";
            }
        }

        FILE *fp = popen(cmd.c_str(), "r");
        if (nullptr != fp)
        {
            char data[2048] = {0};
            while (data == fgets(data, 2048, fp))
            {
                if (nullptr != strstr(data, appPath.c_str()))
                {
                    *isRun = HGTRUE;
                    break;
                }
            }

            pclose(fp);
        }

    #endif
    }

    return HGBASE_ERR_OK;
}

HGResult HGAPI HGVersion_RunApp(const HGChar* appName, const HGChar* oemName)
{
    if (NULL == appName || NULL == oemName)
    {
        return HGBASE_ERR_INVALIDARG;
    }

    if (0 == strcmp(appName, HGVERSION_APPNAME_SCANNER))
    {
    #if defined(HG_CMP_MSC)

        std::wstring appPath;
        std::wstring regName;

        if (0 == strcmp(oemName, HGVERSION_OEMNAME_HANVON))
            regName = L"SOFTWARE\\HanvonScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_LANXUM))
            regName = L"SOFTWARE\\LanxumScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_CUMTENN))
            regName = L"SOFTWARE\\CumtennScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_MICROTEK))
            regName = L"SOFTWARE\\MicrotekScan";
        else if (0 == strcmp(oemName, HGVERSION_OEMNAME_UNIS))
            regName = L"SOFTWARE\\UniScan";
        else
            regName = L"SOFTWARE\\HuaGoScan";

        HKEY hKey = nullptr;
        RegOpenKeyExW(HKEY_LOCAL_MACHINE, regName.c_str(), 0, KEY_QUERY_VALUE, &hKey);
        if (nullptr != hKey)
        {
            WCHAR szData[MAX_PATH] = { 0 };
            DWORD cbData = MAX_PATH;
            if (ERROR_SUCCESS == RegQueryValueExW(hKey, L"Application", nullptr, nullptr, (LPBYTE)szData, &cbData))
            {
                appPath = szData;
            }

            RegCloseKey(hKey);
        }

        if (!appPath.empty())
        {
            ShellExecuteW(nullptr, L"open", appPath.c_str(), nullptr, nullptr, SW_SHOW);
        }

    #else
        std::string appPath;

        std::string osName;
        FILE *file = popen("cat /etc/issue | cut -d\' \' -f1", "r");
        if (NULL != file)
        {
            char data[1024] = {0};
            if (NULL != fgets(data, 1024, file))
                osName = data;
            pclose(file);
        }

        printf("osName=%s\n", osName.c_str());
        if (osName.find("UnionTech") != std::string::npos)
        {
            if (0 == strcmp(oemName, HGVERSION_OEMNAME_HANVON))
                appPath = "sh /opt/apps/com.hanvonchina.hanvonscan/files/bin/HanvonScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_LANXUM))
                appPath = "sh /opt/apps/com.lanxumchina.lanxumscan/files/bin/LanxumScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_CUMTENN))
                appPath = "sh /opt/apps/com.cumtennchina.cumtennscan/files/bin/CumtennScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_MICROTEK))
                appPath = "sh /opt/apps/com.microtekchina.microtekscan-ex/files/bin/MicrotekScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_UNIS))
                appPath = "sh /opt/apps/com.unischina.uniscan/files/bin/UniScan.sh &";
            else
                appPath = "sh /opt/apps/com.huagaochina.huagoscan/files/bin/HuaGoScan.sh &";
        }
        else
        {
            if (0 == strcmp(oemName, HGVERSION_OEMNAME_HANVON))
                appPath = "sh /opt/apps/scanner-driver-hanvon/bin/HanvonScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_LANXUM))
                appPath = "sh /opt/apps/scanner-driver-lanxum/bin/LanxumScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_CUMTENN))
                appPath = "sh /opt/apps/scanner-driver-cumtenn/bin/CumtennScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_MICROTEK))
                appPath = "sh /opt/apps/scanner-driver-microtek-ex/bin/MicrotekScan.sh &";
            else if (0 == strcmp(oemName, HGVERSION_OEMNAME_UNIS))
                appPath = "sh /opt/apps/scanner-driver-unis/bin/UniScan.sh &";
            else
                appPath = "sh /opt/apps/scanner-driver-huagao/bin/HuaGoScan.sh &";
        }

        system(appPath.c_str());

    #endif
    }

    return HGBASE_ERR_OK;
}

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);
}