#include "connectortoserver.h"
#include <QThread>

ConnectorToServer::ConnectorToServer(QObject *parent) :
    QObject(parent),
    connectionThread(nullptr),
    client(nullptr),
    dataParser(nullptr),
    sendSystem(nullptr),
    recognizeSystem(nullptr),
    fl_GetedOfflineMessages(false),
    nameInstructorLoggedInLocal(""),
    serverBlockState(false)
{
    initialize();
}

ConnectorToServer::~ConnectorToServer()
{
    delete client;
    delete recognizeSystem;
    delete sendSystem;
    delete dataParser;

    connectionThread->quit();
    connectionThread->wait();
    delete connectionThread;
}

ServerSettings ConnectorToServer::getServerSettings()
{
    return  serverSettings;
}

bool ConnectorToServer::getIsConnected()
{
    return client->getIsConnected();
}

void ConnectorToServer::SetConnectToServer()
{
    serverBlockState = false;

    qDebug() << "connectorToServer::SetConnectToServer() thread ID " << QThread::currentThreadId();
    serverSettings = *dataParser->getServerSettings();
    emit sigSetConnect(dataParser->getServerSettings(),connectionThread);
}

void ConnectorToServer::StopConnectToServer()
{
    serverBlockState = false;

    emit sigStopConnect();
    clearListModelDB();
}

void ConnectorToServer::setLoginName(QString name)
{
    //versionSelectWidget->setAuthor(name);
    nameInstructorLoggedInLocal = name;
}

QString ConnectorToServer::getLoginName()
{
    return nameInstructorLoggedInLocal;
}

void ConnectorToServer::slot_sendMessage(ClientMessage clientMessage)
{
     sendMessage(clientMessage);
}

void ConnectorToServer::slot_showServerList(QList<StreamingVersionData *> *serverList)
{
    //versionSelectWidget->fillView(serverList);
    emit signal_showServerList(serverList);
}

void ConnectorToServer::slot_HashReady()
{

}

void ConnectorToServer::slot_Auth(ServerAuthorization *serverAuth)
{
    this->serverAuth = *serverAuth;
    emit sigLoginResult(serverAuth);
}

void ConnectorToServer::slot_ServerBlocked()
{
    emit sigServerBlocked();
}

void ConnectorToServer::slot_ErrorAuth(QString error)
{
    emit sigErrorAuth(error);
}

void ConnectorToServer::slot_SendDeleteVersion(StreamingVersionData *streaming)
{
    emit signal_SendDeleteVersion(streaming);
}

void ConnectorToServer::slot_SendSwitchVersion(StreamingVersionData *selectVersion)
{
    emit signal_SendSwitchVersion(selectVersion);
}

void ConnectorToServer::slot_SendCopyVersion(QString versionPair)
{
    emit signal_SendCopyVersion(versionPair);
}

void ConnectorToServer::slot_getVersion()
{
    emit signal_SendGetVersion();
}

void ConnectorToServer::slot_NotifyVersionControl(QString text)
{
    emit signal_NotifyVersionControl(text);
}

void ConnectorToServer::slot_ServerBlockState(bool state)
{
    serverBlockState = state;
    emit signal_ServerBlockState(state);
}

void ConnectorToServer::initialize()
{
    createObjects();

    bindConnection();

    emit sigInitializeClient(recognizeSystem,sendSystem,connectionThread);

    //SetConnectToServer();
}

void ConnectorToServer::bindConnection()
{
    connect(this,&ConnectorToServer::sigInitializeClient,client,&TCPClient::initialize,Qt::AutoConnection);
    connect(this,&ConnectorToServer::sigSetConnect,client,&TCPClient::setConnect,Qt::AutoConnection);
    connect(this,&ConnectorToServer::sigStopConnect,client,&TCPClient::setDisconnect,Qt::AutoConnection);

    connect(this,&ConnectorToServer::sigSendAnswerToServer,sendSystem,&SendSystem::sendXMLAnswer,Qt::AutoConnection);

    connect(recognizeSystem,&RecognizeSystem::sigAuth,this,&ConnectorToServer::slot_Auth);
    connect(recognizeSystem,&RecognizeSystem::sigDeAuth,this,&ConnectorToServer::sigDeLoginResult);

    connect(recognizeSystem,&RecognizeSystem::sigServerBlocked,this,&ConnectorToServer::slot_ServerBlocked);
    connect(recognizeSystem,&RecognizeSystem::sigErrorAuth,this,&ConnectorToServer::slot_ErrorAuth);

    connect(recognizeSystem,&RecognizeSystem::signal_ReceiveMessage,this,&ConnectorToServer::signal_receiveMessage,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigShowServerDataList,this,&ConnectorToServer::slot_showServerList);

    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListInstructors,this,&ConnectorToServer::slot_AnswerQueryToDB_ListInstructors);
    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListGroups,this,&ConnectorToServer::slot_AnswerQueryToDB_ListGroups);
    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListTrainees,this,&ConnectorToServer::slot_AnswerQueryToDB_ListTrainees);
    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListComputers,this,&ConnectorToServer::slot_AnswerQueryToDB_ListComputers);
    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListClassrooms,this,&ConnectorToServer::slot_AnswerQueryToDB_ListClassrooms);

    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListTasksAMMforTrainee,this,&ConnectorToServer::slot_AnswerQueryToDB_ListTasksAMMforTrainee);
    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryToDB_ListTasksFIMforTrainee,this,&ConnectorToServer::slot_AnswerQueryToDB_ListTasksFIMforTrainee);

    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryTasksXML_FIM,this,&ConnectorToServer::slot_AnswerQueryTasksXML_FIM);
    connect(recognizeSystem,&RecognizeSystem::sigAnswerQueryTasksXML_AMM,this,&ConnectorToServer::slot_AnswerQueryTasksXML_AMM);

    connect(recognizeSystem,&RecognizeSystem::sigAnswerQuerySubProc,this,&ConnectorToServer::slot_AnswerQuerySubProc);

    connect(client,&TCPClient::signal_ConnectedToServer,this,&ConnectorToServer::signal_ConnectedToServer,Qt::AutoConnection);

    connect(recognizeSystem,&RecognizeSystem::sigNotifyVersionControl,this,&ConnectorToServer::slot_NotifyVersionControl,Qt::AutoConnection);

    connect(recognizeSystem,&RecognizeSystem::sigHashReady,this,&ConnectorToServer::slot_HashReady);

    connect(recognizeSystem,&RecognizeSystem::signal_AnswerDocsChanged,this,&ConnectorToServer::slot_AnswerDocsChanged);

    connect(recognizeSystem, &RecognizeSystem::sigSetVersion, this, &ConnectorToServer::signal_SetVersion);

    connect(recognizeSystem,&RecognizeSystem::signal_ServerBlockState,this,&ConnectorToServer::slot_ServerBlockState);

    connect(this, &ConnectorToServer::signal_SendCopyVersion, sendSystem, &SendSystem::sendCopyVersion);
    connect(this, &ConnectorToServer::signal_SendDeleteVersion, sendSystem, &SendSystem::sendDeleteVersion);
    connect(this, &ConnectorToServer::signal_SendSwitchVersion, sendSystem, &SendSystem::sendChangeVersion);

    connect(this, &ConnectorToServer::signal_SendGetVersion, sendSystem, &SendSystem::sendGetVersion);
}

void ConnectorToServer::createObjects()
{
    connectionThread = new QThread;

    client = new TCPClient;
    client->moveToThread(connectionThread);

    dataParser = new DataParser;    

    sendSystem = new SendSystem;
    sendSystem->moveToThread(connectionThread);

    recognizeSystem = new RecognizeSystem;
    recognizeSystem->moveToThread(connectionThread);

    connectionThread->start();
    connectionThread->setPriority(QThread::HighestPriority);
}

bool ConnectorToServer::getServerBlockState() const
{
    return serverBlockState;
}

SendSystem *ConnectorToServer::getSendSystem() const
{
    return sendSystem;
}