RRJClient/coremanager.cpp

#include "coremanager.h"

CoreManager::CoreManager(QObject *parent) :
    QObject(parent),
    isRecovery(false)
{
    tcpClient = new TCPClient;
    dataParser = new DataParser;
    dataParserOutput = new DataParserOutput;
    updateController = new UpdateController;
    recognizeSystem = new RecognizeSystem;
    screenChecker = new ScreenChecker;
    externalExecuter = new ExternalExecuter;
    sendSystem = new SendSystem;
    hashComparer = new HashComparer;
    versionContainer = new VersionContainer;
    resourceManager = new ResourceManager;
    postProcessorSystem = new PostProcessorSystem;
    client = new Client;
    settings = new Settings;
}

void CoreManager::initialize(WidgetManager *widgetManager,QThread *workerThread)
{
    createNewServerSettings();

    this->workerThread = workerThread;
    this->widgetManager = widgetManager;

    tcpClient->moveToThread(workerThread);
    dataParser->moveToThread(workerThread);
    dataParserOutput->moveToThread(workerThread);
    sendSystem->moveToThread(workerThread);
    updateController->moveToThread(workerThread);
    recognizeSystem->moveToThread(workerThread);
    postProcessorSystem->moveToThread(workerThread);
    hashComparer->moveToThread(workerThread);

    workerThread->start();

    binding();
    initializeSystems();
    initializeWidgets();

    loadStaticData();
}

void CoreManager::start()
{
     checkAppAvailable();
}

void CoreManager::loadStaticData()
{
    settings = dataParser->getSettings();
    setLanguage(settings->Language);
    setLocalVersion();
    externalExecuter->setIsAutoStart(settings->isAutoStart);
    bool appAvailable = externalExecuter->findApp();
    widgetManager->setAppAvailable(appAvailable);
    emit sigSetLoadSettings(settings);
}

void CoreManager::binding()
{
    connect(recognizeSystem,&RecognizeSystem::sigAnimationActivated,widgetManager,&WidgetManager::slotActivateLoadAnimation,Qt::AutoConnection);

    connect(this,&CoreManager::sigInitializeClient,tcpClient,&TCPClient::initialize,Qt::AutoConnection);
    connect(this,&CoreManager::sigSetConnect,tcpClient,&TCPClient::setConnect,Qt::AutoConnection);
    connect(this,&CoreManager::sigSendPacketType,sendSystem,&SendSystem::sendPacketType,Qt::AutoConnection);
    connect(this,&CoreManager::sigSendCheckUpdate,sendSystem,&SendSystem::sendCheckHash,Qt::AutoConnection);
    connect(this,&CoreManager::sigSendXMLAnswer,sendSystem,&SendSystem::xmlAnswer,Qt::AutoConnection);
    connect(this,&CoreManager::sigSendAutorization,sendSystem,&SendSystem::sendClientAutorization,Qt::AutoConnection);
    connect(this,&CoreManager::sigGetClientSettings,dataParser,&DataParser::getSettings,Qt::DirectConnection);

    connect(this,&CoreManager::sigSendUpdateToServer,updateController,&UpdateController::checkCanUpdate,Qt::AutoConnection);
    connect(this,&CoreManager::sigGetConnected,tcpClient,&TCPClient::getIsConnected);
    connect(this,&CoreManager::sigCalculateHash,updateController,&UpdateController::calculateCommonHash);

    connect(this,&CoreManager::sigSetLoadSettings,widgetManager,&WidgetManager::slotSetLoadSettings,Qt::AutoConnection);

    connect(postProcessorSystem,&PostProcessorSystem::sigCallUpdateList,this,&CoreManager::callUpdateList,Qt::AutoConnection);
    connect(postProcessorSystem,&PostProcessorSystem::sigShowError,this,&CoreManager::showError,Qt::AutoConnection);
    connect(postProcessorSystem,&PostProcessorSystem::sigStartCompare,hashComparer,&HashComparer::CompareDeltas,Qt::AutoConnection);
    connect(postProcessorSystem,&PostProcessorSystem::sigSaveLoginData,this,&CoreManager::checkLoginResult,Qt::AutoConnection);

    connect(versionContainer,&VersionContainer::sigSetServerVersion,this,&CoreManager::setServerVersion,Qt::AutoConnection);

    connect(recognizeSystem,&RecognizeSystem::sigUpdateBytesAvailable,this,&CoreManager::calcUpdateProgress,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigLoadComplete,this,&CoreManager::loadComplete,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigNeedUpdate,this,&CoreManager::checkNeedUpdate,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigCheckUpdate,this,&CoreManager::checkUpdate,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigdRecalculateHashOnServerState,this,&CoreManager::recalculateState,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigSendPacketType,this,&CoreManager::sendPacketType,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigSendPacketTypeWithDelay,sendSystem,&SendSystem::sendPacketTypeWithDelay,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigSendToInlineLog,this,&CoreManager::setInlineDebug,Qt::AutoConnection);
    connect(recognizeSystem,&RecognizeSystem::sigCallUpdateList,this,&CoreManager::callUpdateList,Qt::AutoConnection);

    connect(hashComparer,&HashComparer::sigCallCheck,this,&CoreManager::checkUpdate);
    connect(hashComparer,&HashComparer::sigHaveDelta,this,&CoreManager::checkUpdateInfo);

    connect(updateController,&UpdateController::sigUpdateComplete,widgetManager,&WidgetManager::setCompeteState,Qt::AutoConnection);
    connect(updateController->getHashCalculator(),&FastHashCalculator::sigSendHashInfo,widgetManager->getMainWindow(),&MainWindow::updateInitInformation,Qt::AutoConnection);

    connect(tcpClient,&TCPClient::sigConnectionState,widgetManager,&WidgetManager::setConnectionState,Qt::AutoConnection);
    connect(tcpClient,&TCPClient::sigServerDisconnect,widgetManager,&WidgetManager::setServerDisconnectState,Qt::AutoConnection);

    connect(sendSystem,&SendSystem::sigSend,this,&CoreManager::calcUpdateProgress,Qt::AutoConnection);

    connect(sendSystem,&SendSystem::sigGetXmlAnswer,dataParserOutput,&DataParserOutput::xmlAnswer_notify,Qt::DirectConnection);

}

void CoreManager::initializeSystems()
{
    updateController->initialize(versionContainer,dataParserOutput,sendSystem);
    screenChecker->initialize(dataParserOutput,widgetManager->getMainWindow()->getDisplayLayout());
    hashComparer->initialize(versionContainer,widgetManager->getUpdateWidget());
    postProcessorSystem->initialize(dataParserOutput,hashComparer,versionContainer,updateController);
    dataParser->initialize(postProcessorSystem);
    recognizeSystem->initialize(dataParser,versionContainer,postProcessorSystem,client);
    resourceManager->painting();

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

    screenChecker->check();

    emit sigSetConnect(dataParser->getSettings());
}

void CoreManager::initializeWidgets()
{
    widgetManager->getMainWindow()->initialize(resourceManager);
    widgetManager->getWaitAnimationWidget()->initialize(resourceManager);
    widgetManager->getUpdateWidget()->setVersionContainer(versionContainer);

    connect(widgetManager->getUpdateWidget(),&UpdateNotifyWidget::sigLoadToServerBehaviour,this,&CoreManager::loadToServer,Qt::AutoConnection);
    connect(widgetManager->getUpdateWidget(),&UpdateNotifyWidget::sigUndoCurrentChanges,this,&CoreManager::undoCurrentChanges,Qt::AutoConnection);
    connect(widgetManager->getUpdateWidget(),&UpdateNotifyWidget::sigStartUnityClient,this,&CoreManager::startUnityClient,Qt::AutoConnection);

    connect(widgetManager->getEntryWidget(),&EntryWidget::sigTryLogin,this,&CoreManager::tryLogin,Qt::AutoConnection);
    connect(widgetManager->getEntryWidget(),&EntryWidget::sigSaveServerSettings,this,&CoreManager::saveServerSettingsWithConnect,Qt::AutoConnection);

    connect(widgetManager->getInstructorButtonGroupWiget(),&InstructorButtonGroupWidget::sigLoadToServer,this,&CoreManager::loadToServer, Qt::AutoConnection);
    connect(widgetManager->getInstructorButtonGroupWiget(),&InstructorButtonGroupWidget::sigUndoCurrentChanges,this,&CoreManager::undoCurrentChanges, Qt::AutoConnection);
    connect(widgetManager->getInstructorButtonGroupWiget(),&InstructorButtonGroupWidget::sigStartUnityClient,this,&CoreManager::startUnityClient, Qt::AutoConnection);

    connect(widgetManager->getCommonButtonGroupWidget(),&CommonButtonGroupWidget::sigSendPacket,sendSystem,&SendSystem::sendPacketType,Qt::AutoConnection);
    connect(widgetManager->getCommonButtonGroupWidget(),&CommonButtonGroupWidget::sigStartUnityClient,this,&CoreManager::startUnityClient,Qt::AutoConnection);

    connect(widgetManager->getMainWindow(),&MainWindow::sigChangeLanguage,this,&CoreManager::setLanguage,Qt::AutoConnection);
    connect(widgetManager->getMainWindow(),&MainWindow::sigShowUpdateInfo,this,&CoreManager::checkUpdateInfo,Qt::AutoConnection);
    connect(widgetManager->getMainWindow(),&MainWindow::sigExit,this,&CoreManager::exit,Qt::AutoConnection);
    connect(widgetManager->getMainWindow(),&MainWindow::sigTryLogin,this,&CoreManager::tryLogin,Qt::AutoConnection);
    connect(widgetManager->getMainWindow(),&MainWindow::sigStartOffline,this,&CoreManager::startOffline,Qt::AutoConnection);

}

RecognizeSystem *CoreManager::getRecognizeSystem() const
{
    return recognizeSystem;
}

void CoreManager::callUpdateList()
{
    emit sigSendXMLAnswer(cmd_GetServerHash);
}

void CoreManager::showError(ErrorsEnum errorEnum)
{
    widgetManager->getMainWindow()->showError(errorEnum);

    if (errorEnum == ErrorsEnum::BLOCKED)
    {
        widgetManager->getEntryWidget()->showLoginWidget(true);
    }
}


void CoreManager::setServerVersion(StreamingVersionData *version)
{
    widgetManager->getMainWindow()->setServerVersion(version);

    if (version->getViewName() == settings->versionData.getViewName())
    {
        settings->versionData.setIsChangeable(version->getIsChangeable());
        versionContainer->getLocalVersionData()->setIsChangeable(version->getIsChangeable());
        dataParserOutput->updateServerSettings(settings);
    }
}

void CoreManager::setLocalVersion()
{
    StreamingVersionData *version = new StreamingVersionData;
    version->setName(settings->LocalVersionName);
    version->setIsChangeable(settings->versionData.getIsChangeable());

    versionContainer->setLocalVersionData(version);
    widgetManager->getMainWindow()->setClientVersionName(versionContainer->getLocalVersion());
}

void CoreManager::checkLoginResult(ServerAuthorization *auth)
{
    if (auth->Result)
    {
        widgetManager->activateLoadingAnimation(true);
        checkAccessType(auth->AccessType);
        dataParserOutput->createAuthData(auth);
        //setLocalVersion();
        widgetManager->setLoginSuccess();
        widgetManager->getMainWindow()->setClientVersionName(versionContainer->getLocalVersion());
        client->setLogin(auth->ClientName);
        client->setIsLoggedIn(true);
    }
    else
    {
        widgetManager->setLoginFailed();
        client->setIsLoggedIn(false);
    }
}

void CoreManager::tryLogin()
{
    if (!tcpClient->getIsConnected())
    {
         widgetManager->getMainWindow()->showConnectionEmpty();
         return;
    }

    widgetManager->getEntryWidget()->showLoginWidget(false);
    ClientAutorization *auth = widgetManager->getEntryWidget()->getAuthData();
    dataParserOutput->createAuthMessage(auth);
    emit sigSendAutorization();
}

void CoreManager::checkUpdate()
{
    widgetManager->activateLoadingAnimation(true);
    emit sigSendCheckUpdate();
    setInlineDebug(tr("Проверка обновлений..."));
}

void CoreManager::recalculateState()
{
    widgetManager->activateLoadingAnimation(true);
    setInlineDebug(tr("Пересчет хэша на сервере..."));
}

void CoreManager::setInlineDebug(QString text)
{
     widgetManager->getMainWindow()->setInlineDebug(text);
}

void CoreManager::checkAccessType(const QString& accessType)
{
    if (accessType == traineeTypeName)
    {
        checkUpdate();
    }
    else
    {
        emit sigSendXMLAnswer(cmd_CheckVersionList);
    }
}

void CoreManager::checkUpdateInfo()
{
    fileCountForUpdate = hashComparer->getFileUpdateCount();
    widgetManager->showUpdateInfo();
}

void CoreManager::checkNeedUpdate(bool isNeedUpdate,quint64 size, quint64 fileCount,quint64 deleteCount)
{
    filesLoaded = 0;
    fileCountForUpdate = fileCount;
    QString availableSizeText;

    if (isNeedUpdate && isRecovery)
    {
        widgetManager->setRecoveryState();
    }
    else if(isNeedUpdate)
    {
        widgetManager->setNeedUpdateState(size,fileCount,deleteCount);
        setLocalVersion();
    }
    else
    {
        widgetManager->setLastVersionState();
        checkAutoStart();
        dataParserOutput->changeVersion(versionContainer->getServerVersionData());
        setLocalVersion();
    }

    widgetManager->activateLoadingAnimation(false);
}

void CoreManager::calcUpdateProgress()
{
    filesLoaded++;
    float value = 100 / ((float)fileCountForUpdate / filesLoaded);
    widgetManager->getCommonButtonGroupWidget()->updateProgressBar(value);
}

void CoreManager::checkAutoStart()
{
    if (externalExecuter->getIsAutoStart())
    {
        startUnityClient();
    }
}

void CoreManager::startUnityClient()
{
    externalExecuter->callApp();
    emit sigSendXMLAnswer(cmd_Disable);
}

VersionContainer *CoreManager::getVersionContainer() const
{
    return versionContainer;
}

void CoreManager::loadComplete()
{
    widgetManager->setLoadCompleteState();
    externalExecuter->findApp();
    externalExecuter->setIsAutoStart(widgetManager->getMainWindow()->getIsAutoStart());
    dataParserOutput->changeVersion(versionContainer->getServerVersionData());
    setLocalVersion();
    checkAutoStart();
    widgetManager->getMainWindow()->setClientVersionName(versionContainer->getServerVersionData()->getViewName());
}

void CoreManager::loadToServer()
{
    widgetManager->setSendFileToServerState();
    widgetManager->activateLoadingAnimation(true);
    emit sigSendUpdateToServer();
}

void CoreManager::undoCurrentChanges()
{
    isRecovery = true;
    widgetManager->setUndoCurrentChangesState();
    emit sigSendCheckUpdate();
    emit sigSendPacketType(PacketType::TYPE_UPDATE);
    //тут был таймер
    isRecovery = false;
}

void CoreManager::startOffline()
{
    QString username = "offlineUser";
    QString password = "000000";

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

void CoreManager::sendPacketType(PacketType packetType)
{
    emit sigSendPacketType(packetType);
}

void CoreManager::saveServerSettingsWithConnect()
{
    widgetManager->activateLoadingAnimation(true);
    EntryWidget *entryWidget = widgetManager->getEntryWidget();

    entryWidget->isActive(false);
    settings->LocalVersionName = dataParser->getSettings()->LocalVersionName;
    settings->Address = entryWidget->getAddress();
    settings->Port = entryWidget->getPort();
    dataParserOutput->updateServerSettings(settings);

    if(tcpClient->getIsConnected())
    {
        emit sigSendXMLAnswer(cmd_Disable);
        tcpClient->setDisconnect();
        entryWidget->showLoginWidget(true);
        widgetManager->getMainWindow()->showOfflineButton(true);
        widgetManager->activateLoadingAnimation(false);
    }

    emit sigSetConnect(settings);
}

void CoreManager::createNewServerSettings()
{
    dataParserOutput->createServerSettings();
}

void CoreManager::checkAppAvailable()
{
    bool isAvailable = externalExecuter->findApp();
    widgetManager->setAppAvailable(isAvailable);
}

void CoreManager::setLanguage(const QString& language)
{
    if (language == "RUS")
    {
        translator.load("QtLanguage_ru_RU",".");
    }
    else if(language == "ENG")
    {
        translator.load("QtLanguage_eng_EN",".");
    }
    qApp->installTranslator(&translator);

    dataParserOutput->saveClientSettings(language,widgetManager->getMainWindow()->getIsAutoStart());
}

void CoreManager::exit()
{
    emit sigSendXMLAnswer(cmd_Disable);
    tcpClient->disconnect();

    workerThread->quit();
    workerThread->wait();

    delete workerThread;
}

ResourceManager *CoreManager::getResourceManager() const
{
    return resourceManager;
}

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