#include "Core/recognizesystem.h"
#include <QMessageBox>

RecognizeSystem::RecognizeSystem(QObject *parent):
    QObject(parent),
    versionContainer(nullptr),
    dataParser(nullptr),
    postProcessorSystem(nullptr)
{
    packetType = PacketType::TYPE_NONE;
    filePath.clear();
    fileSize = 0;
    sizeReceiveData = 0;
    tmpBlock.clear();
    countSend = 0;
}

void RecognizeSystem::initialize(DataParser *dataParser, VersionContainer *versionContainer,PostProcessorSystem *postProcessorSystem,Client *client)
{
    this->versionContainer = versionContainer;
    this->postProcessorSystem = postProcessorSystem;
    this->dataParser = dataParser;
    this->client = client;
}

const int BLOCK_SIZE = 1024 * 1024; // Размер блока

void RecognizeSystem::recognize(QTcpSocket *socket)
{
    qDebug() << "RecognizeThreadId " << QThread::currentThreadId();

    QDataStream stream(socket);
    stream.setVersion(QDataStream::Qt_DefaultCompiledVersion);

    while(socket->bytesAvailable())
    {

      if (socket->state() != QTcpSocket::ConnectedState) return;

        if(packetType == PacketType::TYPE_NONE){    //определение первичного пакета

            stream.startTransaction();
            stream >> packetType;

            if(!stream.commitTransaction())
            {
                emit sigSendDebugLog(Tools::getTime() + " CLIENT: packetType - FAIL commitTransaction");

                if(socket->waitForReadyRead(TCP_READ_TIMEOUT)){
                    emit sigSendDebugLog("ERROR: PACKET TYPE READ TIMEOUT");
                    return;
                }
                continue;

            }

            //qDebug() << Tools::GetTime() << "CLIENT: type: " << packetType;
        }

        if(packetType == PacketType::TYPE_FOLDER){  //создание папок
            stream.startTransaction();
            stream >> filePath;

            if(!stream.commitTransaction()){
                continue;
            }

            filePath = Tools::createReceiveFullPath(filePath,versionContainer->getServerVersionData());

            QDir dir(filePath);
            if(!dir.exists()){
                if(dir.mkpath(filePath)){
                    qDebug() << "Dir Created";
                }
            }

            packetType = PacketType::TYPE_NONE;
            emit sigUpdateBytesAvailable();
            continue;
        }

        if(packetType == PacketType::TYPE_FILE)     //загрузка файлов
        {
            //ПОЛУЧЕНИЕ ПУТИ
            //ПОЛУЧЕНИЕ РАЗМЕРА ФАЙЛА
            forever
            {
                stream.startTransaction();
                stream >> filePath;
                stream >> fileSize;

                if(!stream.commitTransaction()){
                    emit sigSendDebugLog(Tools::getTime() + "CLIENT: filePath, fileSize - FAIL commitTransaction");

                    if (!socket->waitForReadyRead(TCP_READ_TIMEOUT)) {
                        emit sigSendDebugLog(Tools::getTime() + "CLIENT: ERROR! readyRead timeout - filePath, fileSize!!!");
                        return;
                    }
                    continue;

                }

                filePath = Tools::createReceiveFullPath(filePath,versionContainer->getServerVersionData());

                emit sigSendDebugLog("CLIENT: filesize: " + QString::number(fileSize));
                emit sigSendDebugLog("CLIENT: filePath: " + filePath);

                socket->waitForReadyRead(100);
                break;
            }


            //ПОЛУЧЕНИЕ САМОГО ФАЙЛА
            emit sigSendDebugLog(Tools::getTime() + "AfterRead size and path BytesAvailable: " + socket->bytesAvailable());

            //УКАЗАНИЕ ПУТИ ФАЙЛА
            QFile file(filePath);

            if (file.exists())
            {
                file.remove();  //удаление файла, если он уже есть, но необходимо обновить
                emit sigSendDebugLog(Tools::getTime() + "Delete exist file: " + filePath);
                socket->waitForReadyRead(100);
            }

            tmpBlock.clear();
            sizeReceiveData = 0;
            countSend = 0;

            file.open(QFile::WriteOnly);

            if(! file.isOpen())
            {
                int marker = 0;
                QMessageBox::critical(nullptr, "P31", "POINT 31");
            }
            if(! file.isWritable())
            {
                int marker = 0;
                QMessageBox::critical(nullptr, "P32", "POINT 32");
            }

            while(true)
            {
                socket->waitForReadyRead(10);

                if(socket->bytesAvailable() <= 0)
                        continue;

                if(fileSize - sizeReceiveData >= BLOCK_SIZE)
                    tmpBlock = socket->read(BLOCK_SIZE);
                else
                    tmpBlock = socket->read(fileSize - sizeReceiveData);

                qint64 bytesReceived = tmpBlock.length();

                if(bytesReceived <= 0)
                    continue;

                sizeReceiveData += bytesReceived;
                countSend++;

                qint64 toFile = file.write(tmpBlock);

                if(toFile <= 0)
                {
                    //emit sigUpdateBytesAvailable();
                    QMessageBox::critical(nullptr, "P2", "POINT 33");
                    break;
                }

                tmpBlock.clear();

                if(sizeReceiveData == fileSize)
                {
                    emit sigSendDebugLog(Tools::getTime() + "FINAL Count send: " + QString::number(countSend));
                    emit sigSendDebugLog(Tools::getTime() + "FINAL Size received: " + QString::number(sizeReceiveData));
                    emit sigSendDebugLog(Tools::getTime() + "FINAL File size" + QString::number(fileSize));
                    emit sigUpdateBytesAvailable();
                    break;
                }
                else if(sizeReceiveData > fileSize)
                {
                    int marker = 0;
                    QMessageBox::critical(nullptr, "P40", "POINT 34");
                }
            }

            file.close();
            emit sigSendDebugLog(Tools::getTime() + "File loaded");

            //ОЧИСТКА ПОСЛЕ ПЕРЕДАЧИ

            filePath.clear();
            fileSize = 0;
            tmpBlock.clear();
            sizeReceiveData = 0;
            countSend = 0;
        }

        if(packetType == PacketType::TYPE_DELETE)   //удаление лишних файлов (рекурсивно удаляет все содежимое)
        {
            stream.startTransaction();
            stream >> filePath;

            if(!stream.commitTransaction()){
                continue;
            }

            filePath = Tools::createReceiveFullPath(filePath,versionContainer->getServerVersionData());

            QFileInfo fileInfo(filePath);


            if(fileInfo.exists())
            {
                if(fileInfo.isFile())
                {
                    QFile file(filePath);
                    file.remove();
                }

                if(fileInfo.isDir()){
                    QDir dir(filePath);
                    dir.removeRecursively();
                }

                qDebug() << Tools::getTime() << "Deleted: " << filePath;
            }

            packetType = PacketType::TYPE_NONE;
            continue;

        }

        if(packetType == PacketType::TYPE_NEEDUPDATE)
        {  //нужно обновление

            bool flag = false;
            quint64 size = 0;
            quint64 fileCount = 0;
            quint64 fileDelete = 0;

            stream.startTransaction();
            stream >> flag;
            stream >> size;
            stream >> fileCount;
            stream >> fileDelete;

            if(!stream.commitTransaction()){
                continue;
            }

            emit sigNeedUpdate(flag,size,fileCount,fileDelete);
            packetType = PacketType::TYPE_NONE;
        }

        if(packetType == PacketType::TYPE_XMLANSWER){   //ответы формата XML
            QByteArray array;
            stream.startTransaction();
            stream >> array;

            if(!stream.commitTransaction()){
                continue;
            }

            dataParser->xmlParser(array);

            packetType = PacketType::TYPE_NONE;
        }

        if(packetType == PacketType::HASH_READY)
        {
            emit sigCheckUpdate();
        }

        if(packetType == PacketType::RECALCULATE_HASH)
        {
            emit sigdRecalculateHashOnServerState();
        }

        if(packetType == PacketType::BUSY)
        {
            emit sigAnimationActivated(true);
        }

        if(packetType == PacketType::FREE)
        {
            emit sigAnimationActivated(false);
        }

        if (packetType == PacketType::TYPE_XMLANSWER_DOCS_CHANGED) //на случай общего обновления
        {
            if (client->getIsLoggedIn())
            {
                emit sigSendPacketType(PacketType::GET_DOCS);
            }
        }

        if (packetType == PacketType::UPDATE_FILE_COMPLETE)
        {
            postProcessorSystem->calculateCommonHash();
            emit sigLoadComplete();
            emit sigSendPacketType(PacketType::GET_DOCS);
            packetType = PacketType::TYPE_NONE;
        }

        packetType = PacketType::TYPE_NONE;
    }
}