#include "tcpclient.h"
#include "UpdateController.h"
#include "externalexecuter.h"

#include <QDir>

TCPClient::TCPClient(QObject *parent) :
    QObject(parent)
{
    //socket = NULL;
    socket = new QTcpSocket();
    socket->setParent(this);
    socket->moveToThread(this->thread());
}

void TCPClient::initialize(RecognizeSystem *recognize,ExternalExecuter *externalExecuter)
{
    this->recognizeSystem = recognize;
    this->externalExecuter = externalExecuter;


    emit sigSendDebugLog(Tools::getTime() + " Client started");
}

void TCPClient::setConnect(ServerSettings *serverSettings)
{
    if (socket != NULL && socket->state() == QTcpSocket::ConnectedState)
    {
        emit sigSendDebugLog("already connected");
        return;
    }

    connect(socket,&QTcpSocket::readyRead,this,&TCPClient::slotReadyRead,Qt::DirectConnection);
    connect(socket,&QTcpSocket::disconnected,this,&TCPClient::setDisconnect);
    connect(socket,&QTcpSocket::connected,this,&TCPClient::slotConnectNotify);
    connect(this,&TCPClient::sigRecognize,recognizeSystem,&RecognizeSystem::recognize,Qt::DirectConnection);

    socket->connectToHost(serverSettings->Address,serverSettings->Port.toShort());
    emit sigSendDebugLog("Try connect...");
}

void TCPClient::sendClientAutorization()
{
    QDataStream stream(socket);
    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    if(socket->state() != QTcpSocket::ConnectedState){
        emit sigConnectionState(false);
        return;
    }

    QFile file(tempName);
    file.open(QIODevice::ReadOnly);

    QByteArray array = file.readAll();
    stream << PacketType::TYPE_XMLANSWER;
    stream << array;
    socket->waitForBytesWritten();
}

void TCPClient::sendFile()
{
    QDataStream stream(socket);
    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);
    quint64 fileSize = 0;
    int countSend = 0;

    QFile file(hashFilename);       //Открываем файл для чтения

    stream << PacketType::TYPE_FILE; //Отправляем тип блока
    QFileInfo fileInfo(file);

    fileSize = fileInfo.size();
    stream << fileSize;

    if(file.open(QFile::ReadOnly | QFile::Text)){
        while(!file.atEnd()){
            QByteArray data = file.readAll();//file.read(1025*250);
            stream << data;
            countSend++;
        }

        qDebug() << Tools::getTime() << "count end Final: " << countSend;
    }

    file.close();

    qDebug() << "Transaction after send file: " << socket->isTransactionStarted();
    countSend = 0;
}


void TCPClient::sendQTConnect()
{
    QString value = QString::number(PacketType::TYPE_QT);
    socket->write(value.toUtf8());
    socket->waitForBytesWritten();
}

void TCPClient::setDisconnect()
{
    socket->disconnect();
    emit sigServerDisconnect();
    emit sigSendDebugLog("Server disabled");
}

void TCPClient::sendDisable()
{
        QDataStream stream(socket);
        stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);

        QByteArray data;
        data = emit sigGetXmlAnswer("DISABLE");

        stream << PacketType::TYPE_XMLANSWER;
        stream << data;
        socket->waitForBytesWritten();
}

void TCPClient::waitRead(int time)
{
    socket->waitForReadyRead(time);
}

QTcpSocket *TCPClient::getSocket()
{
    return socket;
}

void TCPClient::slotMessageEntered(QString message)
{
    QDataStream stream(socket);
    QByteArray data;
    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    if(!message.isEmpty() && socket->state() == QTcpSocket::ConnectedState){

        if(message == "check")
        {
            stream << PacketType::TYPE_COMMAND;
            stream << message;
            socket->waitForBytesWritten();

            sendFile();
            emit sigSendDebugLog(Tools::getTime() + " Local checkFile sended");

            socket->waitForReadyRead(1000);
        }
        else if(message == "update"){
            emit sigSendDebugLog("Update started");
            stream << PacketType::TYPE_COMMAND;
            stream << message;
            socket->waitForBytesWritten();
        }
        else if(message == "run"){
            externalExecuter->callApp();
        }
    }else{
        emit sigSendDebugLog("WRONG SOCKET AFTER ENTERED");
    }
}

void TCPClient::slotConnectNotify()
{
    if(socket->state() != QTcpSocket::ConnectedState)
    {
        emit sigSendDebugLog("Connect invalid");
        emit sigConnectionState(false);
        return;
    }
    else
    {
        emit sigSendDebugLog("Connect complete");
        emit sigConnectionState(true);
        sendQTConnect();
    }
}

void TCPClient::slotReadyRead()
{
    if(!socket){
        emit sigSendDebugLog("WRONG SOCKET");
        return;
    }

    //    qDebug() << "Transaction before recognize: " << socket->isTransactionStarted();

    //    if(socket->isTransactionStarted()) return;

    emit sigRecognize(socket);
}

TCPClient::~TCPClient()
{

}