#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "updatenotifywidget.h"
#include "updatenotifywidget.h"

#include <QFontDatabase>
#include <QMessageBox>
#include <QMovie>
#include <QPaintEvent>
#include <QPainter>
#include <QTimer>

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    isRecovery = false;
    setWindowFlag(Qt::FramelessWindowHint);
    painting();
}

void MainWindow::bindWidgets(UpdateNotifyWidget *widget,CommonButtonGroupWidget *commonButtonGroup,
                             InstructorButtonGroupWidget *instructorButtonGroup)
{
    updateWidget = widget;
    this->commonButtonGroupWidget = commonButtonGroup;
    this->instructorButtonGroupWidget = instructorButtonGroup;
}

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

    commonButtonGroupWidget->initialize(externalExecuter,sendSystem,client);
    commonButtonGroupWidget->show();

    instructorButtonGroupWidget->initialize(this);
    ui->settingsWidget->hide();
    ui->notificationLabel->hide();
    ui->offlineWidget->hide();
    ui->offlineStartButton->show();
    ui->offlineStartButton->setEnabled(false);
    ui->offlineStartButton->setGeometry(540,552,250,35);

    ui->displayGroupWidget->show();
    ui->autostartCheckBox->hide();

    ui->loginWidget->hide();
    ui->updateWidget->hide();

    bindConnection();

    emit sigCalculateHash();
    emit sigInitializeClient(recognizeSystem,externalExecuter,sendSystem,connectionThread);

    recognizeSystem->initialize(updateController,dataParser,this,hashComparer,client);
    screenChecker->check();

    loadStaticData();
    emit sigSetConnect(dataParser->getServerSettings(),connectionThread);

    checkAppAvailable();

    //test

}

void MainWindow::createObjects()
{
    updateWidget = new UpdateNotifyWidget;
    commonButtonGroupWidget = new CommonButtonGroupWidget;
    instructorButtonGroupWidget = new InstructorButtonGroupWidget;

    ui->changButtonGroup->addWidget(commonButtonGroupWidget);
    ui->changButtonGroup->addWidget(instructorButtonGroupWidget);

    connectionThread = new QThread;
    animationThread = new QThread;

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

    dataParser = new DataParser;

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

    updateController = new UpdateController(dataParser,sendSystem);
    updateController->moveToThread(connectionThread);

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

    screenChecker = new ScreenChecker(this,dataParser,ui->displayLayout);
    externalExecuter = new ExternalExecuter;

    hashComparer = new HashComparer(dataParser);

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

    timer = new QTimer;
}

void MainWindow::bindConnection()
{
    connect(timer,&QTimer::timeout,this,&MainWindow::slotDisableNotify);

    connect(updateController,&UpdateController::sigUpdateComplete,this,&MainWindow::showCompleteDialogBox);

    connect(hashComparer,&HashComparer::sigCallCheck,this,&MainWindow::checkUpdate);
    connect(hashComparer,&HashComparer::sigHaveDelta,this,&MainWindow::showUpdateInfo);

    connect(sendSystem,&SendSystem::sigSend,this,&MainWindow::updateProgress);
    connect(sendSystem,&SendSystem::sigGetXmlAnswer,dataParser,&DataParser::slotGetXmlAnswer);

    connect(this,&MainWindow::sigUpdateFilesOnServer,updateController,&UpdateController::updateFilesOnServer);
    connect(this,&MainWindow::sigInitializeClient,client,&TCPClient::initialize,Qt::AutoConnection);
    connect(this,&MainWindow::sigSetConnect,client,&TCPClient::setConnect,Qt::AutoConnection);
    connect(this,&MainWindow::sigSendCommand,client,&TCPClient::slotSendCommand,Qt::AutoConnection);

    connect(client,&TCPClient::sigConnectionState,this,&MainWindow::slotConnectionState,Qt::AutoConnection);
    connect(client,&TCPClient::sigServerDisconnect,this,&MainWindow::slotServerDisconnect);

    connect(this,&MainWindow::sigGetConnected,client,&TCPClient::getIsConnected);
    connect(this,&MainWindow::sigCalculateHash,updateController,&UpdateController::calculateCommonHash);
    connect(this,&MainWindow::sigSendAutorization,sendSystem,&SendSystem::sendClientAutorization);
}

void MainWindow::updateProgress()
{
    filesLoaded++;
    float value = 100 / ((float)fileCountForUpdate / filesLoaded);
    commonButtonGroupWidget->updateProgressBar(value);
}

void MainWindow::loadComplete()
{
    externalExecuter->findApp();
    commonButtonGroupWidget->loadCompleteState();
    autoStart();
    ui->inlineTextDebug->setText(tr("Обновление завершено"));
    ui->offlineStartButton->setEnabled(true);
    ui->autostartCheckBox->hide();
    ui->offlineStartButton->show();
}

void MainWindow::setNeedUpdate(bool flag,quint64 size, quint64 fileCount)
{
    fileCountForUpdate = 0;
    filesLoaded = 0;
    fileCountForUpdate = fileCount;
    QString availableSizeText;

    if (flag && isRecovery)
    {
        ui->inlineTextDebug->setText(tr("Восстановление версии..."));

    }
    else if(flag)
    {
        QString result = tr("Доступно обновление: ") + Tools::convertFileSize(size);
        result += tr("Количество файлов: ") + QString::number(fileCount);
        ui->inlineTextDebug->setText(result);
        commonButtonGroupWidget->needUpdateState(flag);
        ui->autostartCheckBox->show();
        stopLoadingMovie();
    }
    else
    {
        ui->inlineTextDebug->setText(tr("Установлена последняя версия"));
        autoStart();
        commonButtonGroupWidget->lastVerInstalledState();
        ui->offlineStartButton->setEnabled(true);
        stopLoadingMovie();
    }
}

void MainWindow::lostConnection()
{
    commonButtonGroupWidget->updateProgressBar(0);
    slotConnectionState(false);
}

void MainWindow::serverBlocked()
{
    ui->notificationLabel->show();
    QPalette palette = ui->notificationLabel->palette();
    QColor orangeColor(255,165,0);
    palette.setColor(ui->notificationLabel->foregroundRole(),orangeColor);
    ui->notificationLabel->setText(tr("Сервер заблокирован"));

    ui->notificationLabel->setPalette(palette);
    timer->start(3000);
}

void MainWindow::checkLoginResult(ServerAuthorization *serverAuth)
{
    if (serverAuth->Result)
    {

        if (serverAuth->AccessType != "instructor") //временно для отладки загрузки на сервер
        {
            checkUpdate();
        }

        dataParser->createAuthData(serverAuth);
        ui->loginWidget->hide();
        ui->LanguageWidget->hide();
        ui->settingsButton->hide();
        ui->offlineStartButton->show();
        startLoadingAnim();
    }
    else
    {
        ui->notificationLabel->setText(tr("Неверный логин/пароль"));
        timer->setInterval(3000);
        timer->start();

        QPalette palette = ui->notificationLabel->palette();
        palette.setColor(ui->notificationLabel->foregroundRole(), Qt::red);

        ui->notificationLabel->setPalette(palette);
        ui->notificationLabel->show();
    }

}

void MainWindow::checkAppAvailable()
{
    bool isAvailable = externalExecuter->findApp();
    commonButtonGroupWidget->startButtonActive(isAvailable);
    ui->offlineStartButton->setEnabled(isAvailable);
}

void MainWindow::checkLanguage(QString language)
{
    if (language == "RUS")
    {
        translator.load("QtLanguage_ru_RU",".");
    }
    else if(language == "ENG")
    {
        translator.load("QtLanguage_eng_EN",".");
    }

    qApp->installTranslator(&translator);
    ui->retranslateUi(this);
}

void MainWindow::autoStart()
{
    if(ui->autostartCheckBox->isChecked()){
        startUnityClient();
    }
}

void MainWindow::loadStaticData()
{
    ServerSettings *currentSettings = dataParser->getServerSettings();

    ui->serverInputField->setText(currentSettings->Address);
    ui->portInputField->setText(currentSettings->Port);
    ui->languageComboBox->setCurrentText(currentSettings->Language);
    ui->autostartCheckBox->setChecked(currentSettings->isAutoStart);

    checkLanguage(currentSettings->Language);
}

void MainWindow::showConnectionEmpty()
{
    QPalette palette = ui->notificationLabel->palette();
    palette.setColor(ui->notificationLabel->foregroundRole(),Qt::red);
    ui->notificationLabel->setText(tr("Соединение отсутсвует"));
    ui->offlineWidget->show();
    ui->offlineStartButton->show();
    ui->offlineStartButton->setGeometry(280,340,250,35);
    ui->settingsButton->show();
    ui->loginWidget->hide();
    ui->updateWidget->hide();
    instructorButtonGroupWidget->hide();
}

void MainWindow::slotConnectionState(bool flag)
{
    ui->notificationLabel->show();
    QPalette palette = ui->notificationLabel->palette();

    stopLoadingMovie();

    if(flag)
    {
        palette.setColor(ui->notificationLabel->foregroundRole(),Qt::green);
        ui->notificationLabel->setText(tr("Соединение установлено"));
        ui->loginWidget->show();

        ui->offlineStartButton->show();
        ui->offlineStartButton->setGeometry(540,552,250,35);
    }
    else
    {
        showConnectionEmpty();
    }

    ui->notificationLabel->setPalette(palette);
    timer->start(3000);
}

void MainWindow::slotServerDisconnect()
{
    commonButtonGroupWidget->disconnectState();
    ui->autostartCheckBox->hide();
    ui->inlineTextDebug->setText("");
    slotConnectionState(false);
}

void MainWindow::slotDisableNotify()
{
    ui->notificationLabel->hide();

    QPalette palette = ui->notificationLabel->palette();
    palette.setColor(ui->notificationLabel->foregroundRole(), Qt::black);

    ui->notificationLabel->setPalette(palette);
    timer->stop();
}

void MainWindow::callUpdateList()
{
    hashComparer->setWidget(updateWidget);

    QByteArray answer = dataParser->xmlAnswer_notify("GETSERVERDATALIST");
    sendSystem->sendXMLAnswer(answer);

    updateWidget->initialize(this);
}


void MainWindow::on_loginButton_clicked()
{
    if (!client->getIsConnected())
    {
        showConnectionEmpty();
        return;
    }

    QString username = ui->loginInputField->text();
    QString password = ui->passwordInputField->text();

    ClientAutorization *autorization = new ClientAutorization;
    autorization->Login = username;
    autorization->Password = password;

    dataParser->createAuthMessage(autorization);
    emit sigSendAutorization();

}

void MainWindow::on_saveServerButton_clicked()
{
    startLoadingAnim();
    ui->settingsWidget->hide();

    if(client->getIsConnected())
    {
        ui->loginWidget->show();
        ui->offlineStartButton->show();
        stopLoadingMovie();
        return;
    }

    QString server = ui->serverInputField->text();
    QString port = ui->portInputField->text();

    dataParser->createServerSettings(server,port);

    emit sigSetConnect(dataParser->getServerSettings(),connectionThread);
}

void MainWindow::on_settingsButton_clicked()
{
    ui->settingsWidget->show();
    ui->loginWidget->hide();
    ui->offlineWidget->hide();
    ui->offlineStartButton->hide();
}

void MainWindow::on_languageComboBox_activated(const QString &arg1)
{
    qDebug() << arg1;
    dataParser->saveClientSettrings(arg1,ui->autostartCheckBox->isChecked());
    checkLanguage(arg1);
    ui->retranslateUi(this);
}

void MainWindow::loadToServer()
{
    ui->inlineTextDebug->setText(tr("Отправка файлов..."));
    commonButtonGroupWidget->showProgressBar(true);
    instructorButtonGroupWidget->hide();
    ui->offlineStartButton->setEnabled(false);
    ui->updateWidget->hide();
    emit sigUpdateFilesOnServer(hashComparer->getFilesForUpdate());
}

void MainWindow::undoCurrentChanges()
{
    isRecovery = true;
    emit sigSendCommand("check");

    commonButtonGroupWidget->showProgressBar(true);
    ui->offlineStartButton->setEnabled(false);
    instructorButtonGroupWidget->hide();
    ui->updateWidget->hide();

    startLoadingAnim();

    //delay

    QTime dieTime= QTime::currentTime().addSecs(10);
    while (QTime::currentTime() < dieTime)
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);

    startLoadingAnim();

    emit sigSendCommand("update");
    commonButtonGroupWidget->startUpdateState();

    isRecovery = false;
    stopLoadingMovie();
}

void MainWindow::on_updateListGuideLabel_linkActivated(const QString &)
{
    updateWidget->show();
}

void MainWindow::on_offlineStartButton_clicked()
{
    QString username = "offlineUser";
    QString password = "000000";

    dataParser->createAuthDataOffline(username,password);
    startUnityClient();
}

void MainWindow::on_exitButton_clicked()
{
    exit(0);
}

void MainWindow::checkUpdate()
{
    emit sigSendCommand("check");
    ui->inlineTextDebug->setText(tr("Проверка обновлений..."));
}

void MainWindow::showUpdateInfo()
{
    stopLoadingMovie();

    QString text = tr("Есть изменения в локальных файлах <A HREF=\"LINK\" style=color:rgb(45,84,130)>(список)</A> ");
    QString list = tr("Возможные действия:\n"
                      " 1. Выгрузить изменения на сервер\n"
                      " 2. Отменить изменения с загрузкой версии с сервера \n"
                      " 3. Запустить без отправки файлов, но с текущими изменениями");


    ui->updateListGuideLabel->setText(text);
    ui->updateActionListLabel->setText(list);

    ui->updateWidget->show();
    instructorButtonGroupWidget->show();
    ui->offlineStartButton->setGeometry(540,552,250,35);
    fileCountForUpdate = hashComparer->getFilesForUpdate()->length();

    filesLoaded = 0;
}

void MainWindow::showCompleteDialogBox()
{
    ui->inlineTextDebug->setText(tr("Загрузка завершена"));
    startLoadingAnim();

    QTime dieTime= QTime::currentTime().addSecs(10);
    while (QTime::currentTime() < dieTime)
        QCoreApplication::processEvents(QEventLoop::AllEvents, 100);

    stopLoadingMovie();
    checkUpdate();
}

void MainWindow::startUnityClient()
{
    externalExecuter->callApp();
    sendSystem->sendDisable();
}

void MainWindow::keyPressEvent(QKeyEvent *event)
{

    if (event->key() == Qt::Key_Enter || event->key() == Qt::Key_Return)
    {
        if (ui->loginInputField->text().length() <= 0 || ui->passwordInputField->text() <= 0) return;

        on_loginButton_clicked();
    }
}

void MainWindow::painting()
{
    QFontDatabase::addApplicationFont(":/resource/Fonts/Kanit Cyrillic.ttf");
    QFontDatabase::addApplicationFont(":/resource/Fonts/HelveticaNeue-Medium.ttf");

    //settings
    QPixmap settingIcon(":resource/Icons/settingWhite.png");
    QPainter painter;
    QColor color(45,84,130);

    painter.begin(&settingIcon);
    painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
    painter.fillRect(settingIcon.rect(),color);
    painter.end();

    QIcon icon;
    icon.addPixmap(settingIcon,QIcon::Normal,QIcon::Off);

    ui->settingsButton->setIcon(icon);

    //exit
    QPixmap crossPixmap(":resource/Icons/crossInCircle.png");
    QPainter painterCross;
    QSize iconSize(30,30);

    painter.begin(&crossPixmap);
    painter.setCompositionMode(QPainter::CompositionMode_SourceIn);
    painter.fillRect(crossPixmap.rect(),color);
    painter.end();

    QIcon crossIcon;
    crossIcon.addPixmap(crossPixmap,QIcon::Normal,QIcon::Off);

    ui->exitButton->setIcon(crossIcon);
    ui->exitButton->setIconSize(iconSize);

    //loading

    movie = new QMovie(":/resource/Icons/762.gif");
    movieLabel = new QLabel("No movie");
    movieLabel->setParent(this);
    movieLabel->setGeometry(367,300,70,70);
    movieLabel->setSizePolicy(QSizePolicy::Minimum,QSizePolicy::Minimum);
    movieLabel->setMovie(movie);
    startLoadingAnim();
}

void MainWindow::startLoadingAnim()
{
    movie->start();
    movieLabel->show();
}

void MainWindow::stopLoadingMovie()
{
    movie->stop();
    movieLabel->hide();
}

MainWindow::~MainWindow()
{
    connectionThread->quit();
    connectionThread->wait();

    sendSystem->sendDisable();

    delete connectionThread;
    delete ui;
}