#include "lhhttpapi.h"
#include <QCoreApplication>
#include <QDebug>

int g_nHttpTimeOut = 0;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
DoInterfaceObject::DoInterfaceObject(lhhttpapi *pApi, const QString &strToken, int nOperatorType, const QString &strParamXml)
    : ThreadWorker()
    , m_pApi(pApi)
    , m_strToken(strToken)
    , m_nOperatorType(nOperatorType)
    , m_strParamXml(strParamXml)
    , m_nResult(-1)
{

}

void DoInterfaceObject::DoWork()
{
    if(m_pApi != nullptr)
    {
        QString serid = m_pApi->GetServerID();
        QString appType = m_pApi->GetClientType();
        std::unique_ptr<char[]> buffer(new char[LHAPI_BUFFER_SIZE_NEW]{0});
        m_nResult = m_pApi->fnDBDoInterface(serid.toUtf8().data(),appType.toUtf8().data(),m_strToken.toUtf8().data(),
                                            m_nOperatorType,m_strParamXml.toUtf8().data(),buffer.get(),LHAPI_BUFFER_SIZE_NEW);
        m_strRetXml = QString::fromUtf8(buffer.get());
    }
    emit sig_WorkFinished();
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
lhhttpapi::lhhttpapi(QObject *parent)
    : QObject(parent),
    m_pQLib(nullptr),
    fnDBInit(nullptr),
    fnDBLogin(nullptr),
    fnDBGettServerList(nullptr),
    fnDBGetChannelList(nullptr),
    fnDBGetServerInfo(nullptr),
    fnSetHttpTimeOut(nullptr),
    fnGetHttpFileSize(nullptr),
    fnGetHttpFileContent(nullptr),
    fnGetLastError(nullptr),
    fnDoWord2Pyjc(nullptr),
    fnDoUploadFtpFile(nullptr),
    fnDoUploadFtpFileContent(nullptr),
    fnDoCurlDeleteFtpFile(nullptr),
    fnDoCurlUploadFtpFile(nullptr),
    fnDoCurlUploadFtpFileContent(nullptr),
    fnDoGetDBInfo(nullptr),
    fnDBDoInterface(nullptr),
    m_tUpToken(nullptr)
{
#if defined(Q_OS_WIN)
    QString exePath = QCoreApplication::applicationDirPath();

#ifdef QT_DEBUG
// #ifdef C_DEBUG
    exePath += "/LHSqlWebInterfaced.dll";
    Load(exePath.toLatin1());
#else
    exePath += "/LHSqlWebInterface.dll";
    Load(exePath.toLatin1());
#endif // debug

#elif defined (Q_OS_LINUX)
    Load(QString("%1/%2").arg(QCoreApplication::applicationDirPath(), "LHSqlWebInterface.so"));
#endif // win

    m_tUpToken = new QTimer(this);
    m_tUpToken->setInterval(25 * 60 * 1000);
    m_tUpToken->start();
    connect(m_tUpToken, &QTimer::timeout, this, [this] {
        QString token("");
        //qInfo() << "WebApi timeout, old token: " << m_token;
        DBQLogin("", m_serID, m_clientType, token);
        //qInfo() << "new token: " << m_token;
    });
}


lhhttpapi::~lhhttpapi()
{
    UnLoad();
}

bool lhhttpapi::Load(QString file)
{
    m_pQLib = new QLibrary(file);
    if (!m_pQLib->load())
    {
        QString strLog = QString("Module %1 load failed -1").arg(file);
        qInfo() << strLog;
        qInfo() << m_pQLib->errorString();
        return false;
    }
    fnDBInit = reinterpret_cast<FunDBInit>(m_pQLib->resolve("DBInit"));
    fnDBLogin = reinterpret_cast<FunDBLogin>(m_pQLib->resolve("DBLogin"));
    fnDBGettServerList = reinterpret_cast<FunDBGetServerList>(m_pQLib->resolve("DBGetServerList"));
    fnDBGetChannelList = reinterpret_cast<FunDBGetChannelList>(m_pQLib->resolve("DBGetChannelList"));
    fnDBGetServerInfo = reinterpret_cast<FunDBGetServerInfo>(m_pQLib->resolve("DBGetServerInfo"));
    fnDBDoInterface = reinterpret_cast<FunDBDoInterface>(m_pQLib->resolve("DBDoInterface"));

    fnSetHttpTimeOut = reinterpret_cast<FunSetHttpTimeOut>(m_pQLib->resolve("SetHttpTimeOut"));
    fnGetLastError = reinterpret_cast<FunDoGetLastError>(m_pQLib->resolve("DBGetLastError"));
    fnGetHttpFileSize = reinterpret_cast<FunDoGetHttpFileSize>(m_pQLib->resolve("DoGetHttpFileSize"));
    fnGetHttpFileContent = reinterpret_cast<FunDoGetHttpFileContent>(m_pQLib->resolve("DoGetHttpFileContent"));
    fnDoWord2Pyjc = reinterpret_cast<FunDoWord2Pyjc>(m_pQLib->resolve("DoWord2Pyjc"));
    fnDoUploadFtpFile = reinterpret_cast<FunDoUploadFtpFile>(m_pQLib->resolve("DoUploadFtpFile"));
    fnDoUploadFtpFileContent = reinterpret_cast<FunDoUploadFtpFileContent>(m_pQLib->resolve("DoUploadFtpFileContent"));

    fnDoCurlUploadFtpFile = reinterpret_cast<FunDoCurlUploadFtpFile>(m_pQLib->resolve("DoCurlUploadFtpFile"));
    fnDoCurlDeleteFtpFile = reinterpret_cast<FunDoCurlDeleteFtpFile>(m_pQLib->resolve("DoCurlDeleteFtpFile"));
    fnDoCurlUploadFtpFileContent = reinterpret_cast<FunDoCurlUploadFtpFileContent>(m_pQLib->resolve("DoCurlUploadFtpFileContent"));

    fnDoGetDBInfo = reinterpret_cast<FunDoGetDBInfo>(m_pQLib->resolve("DoGetDBInfo"));

    if(fnDBInit == nullptr||fnDBLogin == nullptr||fnDBGetChannelList == nullptr||fnSetHttpTimeOut == nullptr||
            fnDBDoInterface == nullptr|| fnDBGettServerList == nullptr || fnGetLastError == nullptr)
    {
        QString strLog = QString("Module %1 load failed,lack interface").arg(file);
        qInfo() << strLog;
        return false;
    }
    return true;
}

bool lhhttpapi::UnLoad()
{
    if(m_pQLib == nullptr) return false;
    int ret = m_pQLib->unload();
    m_pQLib = nullptr;
    return ret;
}

int lhhttpapi::SetHttpTimeOut(int nTimeout)
{
    if(fnSetHttpTimeOut == nullptr) return -1;
    return fnSetHttpTimeOut(nTimeout);
}

QString lhhttpapi::DoGetLastError(int *nErrorCode)
{
    if(fnGetLastError == nullptr) return QString();

    int nLen = LHAPI_BUFFER_SIZE_NEW;
    char *pError = new char[LHAPI_BUFFER_SIZE_NEW]{0};
    int nRet = fnGetLastError(pError, nLen, nErrorCode);

    if(nRet != 0)
    {
        delete [] pError; pError = nullptr;
        return QString();
    }

    QString strRet2 = QString::fromUtf8(pError);

    delete [] pError; pError = nullptr;
    return strRet2;
}

int lhhttpapi::DBQInit(QString strUrl)
{
    char *szUrl = nullptr;
    QByteArray baUrl = strUrl.toUtf8();
    szUrl = baUrl.data();

    if(fnDBInit == nullptr) return -1;

    //SetHttpTimeOut(g_nHttpTimeOut);
    return fnDBInit(szUrl);
}

int lhhttpapi::DBQGetServerList(QString& serverList)
{
    if(fnDBGettServerList == nullptr) return -1;
    serverList.clear();
    char* pBuff = new char[LHAPI_BUFFER_SIZE_NEW]{0};
    int nRet = fnDBGettServerList(pBuff, LHAPI_BUFFER_SIZE_NEW);
    serverList = QString(pBuff);
    delete[] pBuff;
    pBuff = nullptr;
    return nRet;
}

int lhhttpapi::DBQGetServerInfo(const QString &serid, QString &serverInfo)
{
    if (nullptr == fnDBGetServerInfo) return -1;
    serverInfo.clear();
    char* pBuff = new char[LHAPI_BUFFER_SIZE_NEW]{0};
    int nRet = fnDBGetServerInfo(serid.toUtf8(), m_token.toUtf8(), pBuff, LHAPI_BUFFER_SIZE_NEW);
    if (LH_HTTPAPI_SUCC == nRet) {
        serverInfo = QString::fromUtf8(pBuff);
    }
    delete[] pBuff;
    pBuff = nullptr;

    return nRet;
}

int lhhttpapi::DBQLogin(QString LocalIP, QString Serid, QString CType, QString &strUserToken)
{
    //QMutexLocker locker(&m_mtx);
    std::unique_ptr<char[]> charlist(new char[LHAPI_BUFFER_SIZE_NEW]{0});

    char *szIP = nullptr;
    QByteArray baIP = LocalIP.toUtf8();
    szIP = baIP.data();

    char *szDBID = nullptr;
    QByteArray baDBID = Serid.toUtf8();
    szDBID = baDBID.data();

    char *szCType = nullptr;
    QByteArray baCType = CType.toUtf8();
    szCType = baCType.data();

    if(fnDBLogin == nullptr) {
        return -1;
    }
    int nRet = fnDBLogin(szIP, szDBID, szCType, charlist.get(), LHAPI_BUFFER_SIZE_NEW);
    if (LH_HTTPAPI_SUCC == nRet)
    {
        m_token = QString::fromUtf8(charlist.get());
        m_serID = Serid;
        m_clientType = CType;

        strUserToken = m_token;
    }

    return nRet;
}

void lhhttpapi::OnWorkerFinished()
{
    m_Condition.wakeAll();
}

int lhhttpapi::DBQDoInterface(int nOperatorType, const QString &strParamXml, QString &strRetXml, bool wait)
{
    if(fnDBDoInterface == nullptr) return -1;

    //QMutexLocker locker(&m_mtx);
    int ret = 0;
    if(wait)
    {
        DoInterfaceObject *pWorker = new DoInterfaceObject(this, m_token, nOperatorType, strParamXml);
        connect(pWorker, &DoInterfaceObject::sig_WorkFinished, this, &lhhttpapi::OnWorkerFinished, Qt::DirectConnection);
        pWorker->Start(100000);
        QMutexLocker locker(&m_mutexWorkerDestroy);
        m_Condition.wait(&m_mutexWorkerDestroy);
        strRetXml = pWorker->GetRetXML();
        ret = pWorker->GetResult();
        pWorker->BlockStop();
        if(ret != 0)
        {
            int nerror = 0;
            QString strerror = DoGetLastError(&nerror);
            qDebug()<<"返回错误为：" << strerror;
            if (strerror.compare("票据非法") == 0) {
            }
        }
        return ret;
    }

    std::unique_ptr<char[]> buffer(new char[LHAPI_BUFFER_SIZE_NEW]{0});
    ret = fnDBDoInterface(m_serID.toUtf8().data(),m_clientType.toUtf8().data(),m_token.toUtf8().data(),
                              nOperatorType,strParamXml.toUtf8().data(),buffer.get(),LHAPI_BUFFER_SIZE_NEW);
    strRetXml = QString::fromUtf8(buffer.get());
    return ret;
}