#include "ReconManager.h"
#include "ReconClient.h"
#include "json/jsonobject.h"
#include "log/SystemOperationLog.h"

#include <QTimer>
#include "QDebug"
#include "json/cJSON.h"

namespace
{
    const std::string CRT_FILE = "./cfgs/client.crt";
    const std::string KEY_FILE = "./cfgs/client.key";

    std::string toReconServerAddress(const QString& aIp, const QString& aPort)
    {
        return ("https://" + aIp + ":" + aPort).toStdString();
    }
}

ReconManager* ReconManager::getInstance()
{
    static ReconManager instance;
    return &instance;
}

ReconManager::ReconManager(QObject* aParent)
    : QObject(aParent)
    , mReconClient(new ReconClient(CRT_FILE, KEY_FILE))
    , mIsConnected(false)
{
    init();
}

ReconManager::~ReconManager()
{
    delete mReconClient;
}

void ReconManager::init()
{
    host reconServerInfo = JsonObject::Instance()->getServer(JsonObject::RECON);
    mReconClient->SetHost(toReconServerAddress(reconServerInfo.ip , reconServerInfo.port));
}

void ReconManager::setReconIpAndPort(const QString& aIp, const QString& aPort)
{
    mReconClient->SetHost(toReconServerAddress(aIp, aPort));
}

void ReconManager::createEmptyScan(const QString& aScanID, const QString& aPath)
{
    Scan empty{aScanID.toStdString(), "", "", "", aPath.toStdString(),0};
    auto result = mReconClient->Create(empty);
    if(result.good())
    {
        qDebug()<< "create empty scan success, scanID: "<< aScanID;
        LOG_SYS_OPERATION("create empty scan success, scanID: " + aScanID)
        emit createEmptyScanResponsed(true, aScanID);
    }
    else
    {
        qDebug()<< "Create empty scan fail by %s\n" << result.error().data();
        LOG_SYS_OPERATION("Create empty scan failed. " + QString(result.error().data()))
        emit createEmptyScanResponsed(false, aScanID, result.error().data());
    }
}

void ReconManager::createScan(const QString& aScanID, const QString& aStudyUID,const QString& aMPPSUID, const QString& aReferenceID, const QString& aPath)
{
    Scan scan{aScanID.toStdString(), aStudyUID.toStdString(), aMPPSUID.toStdString(), aReferenceID.toStdString(), aPath.toStdString(),1};
    auto response = mReconClient->Create(scan);
    if(response.good())
    {
        qDebug()<< "Recon create scan success, scanID: "<< aScanID;
        LOG_SYS_OPERATION("Recon create scan success, scanID: " + aScanID)
        emit createScanResponsed(true, aScanID);
    }
    else
    {
        qDebug()<< "Recon create scan failed by " << response.error().data();
        LOG_SYS_OPERATION("Recon create scan failed" + QString(response.error().data()))
        emit createScanResponsed(false, aScanID, response.error().data());
    }
}

void ReconManager::queryReconStatus(const QStringList& aScanIDs)
{
    QMap<QString, int> result;
    for(QString scanID : aScanIDs)
    {
        int state;
        auto response = mReconClient->QueryScan(scanID.toStdString(), state);
        if(response.bad())
        {
            QString msg = QString("Recon query failed by ") + response.error().data();
            qDebug()<< msg;
            emit queryReconStateResponsed(false, QVariant::fromValue(msg));
            continue;
        }
        result.insert(scanID, state);
    }
    emit queryReconStateResponsed(true, QVariant::fromValue(result));
}

void ReconManager::checkReconConnection()
{
    auto response = mReconClient->CheckActive();
    if(mIsConnected != response.good())
    {
        emit checkReconConnectionResponsed(response.good());
    }
    if(mIsConnected == false && response.good())
    {
        emit restartCreatReconRecord();
    }
    mIsConnected = response.good();
    int state = 0;
    if (mIsConnected)
    {
        cJSON* json = cJSON_Parse(response.message().data());
        cJSON* stateProperty = cJSON_GetObjectItem(json, "State");
        state = stateProperty->valueint;
        cJSON_Delete(json);
        qDebug()<<"Recon State:"<<state;
    }
    emit reconStateResponsed(mIsConnected, state);
}

void ReconManager::setPacsSettings(const QString& aClientAETitle, const QString& aServerAETitle, const QString& aServerIP, int aServerPort)
{
    PACSSetting settings = {aClientAETitle.toStdString(), aServerAETitle.toStdString(), aServerIP.toStdString(), aServerPort};
    auto response = mReconClient->SetPACSSetting(settings);
    if(response.bad())
    {
        QString msg = QString("Set PACS settings failed : ") + response.error().data();
        qDebug()<< msg;
        LOG_SYS_OPERATION(msg)
        emit setPacsSettingsResponsed(false, QVariant::fromValue(msg));
        return;
    }
    QString message = "Set PACS settings succeed.";
    LOG_SYS_OPERATION(message)
    emit setPacsSettingsResponsed(true, QVariant::fromValue(message));
}

void ReconManager::setMppsSettings(bool aIsOpen, const QString& aServerAETitle, const QString& aServerIP, int aServerPort)
{
    MPPSSetting settings = {aIsOpen ? 1 : 0, aServerAETitle.toStdString(), aServerIP.toStdString(), aServerPort};
    auto response = mReconClient->SetMPPSSetting(settings);
    if(response.bad())
    {
        QString msg = QString("Set MPPS settings failed : ") + response.error().data();
        qDebug()<< msg;
        LOG_SYS_OPERATION(msg)
        emit setMppsSettingsResponsed(false, QVariant::fromValue(msg));
        return;
    }
    QString message = "Set MPPS settings succeed.";
    LOG_SYS_OPERATION(message)
    emit setMppsSettingsResponsed(true, QVariant::fromValue(message));
}

void ReconManager::getReconVersion()
{
    auto result = mReconClient->QueryVersion();
    if(result.good())
    {
        emit getReconVersionResponsed(QString::fromStdString(result.message()));
    }
}

bool ReconManager::isConnected()
{
    return mIsConnected;
}