#include "syncmanager.h"

SyncManager::SyncManager(bool dryMode)
{
    reqMan = std::make_unique<RequestManager>();
    dataMan = std::make_unique<DataManager>(dryMode);
    this->dryMode = dryMode;

    connect(reqMan.get(), &RequestManager::error, this, &SyncManager::error);
    connect(dataMan.get(), &DataManager::error, this, &SyncManager::error);
}

void SyncManager::loadDataFromColnod()
{
    loadTokensFromColnod();
    loadUpdatedDataFromColnod();
    loadDeletedDataFromColnod();
}

// download all tokens form colnod for comparing with tokens to update from DB
void SyncManager::loadTokensFromColnod()
{
    Response* resp = reqMan->getTokens();
    connect(resp, &Response::ready, [=](){
        dataMan->fillFullTokensColnod(resp->getJson());
        areChangedDataReady();
        resp->deleteLater();
    });
}

// fill tokens/subjects to update in data manager
void SyncManager::loadUpdatedDataFromColnod()
{
    uint64_t lastUpdate = dataMan->getLastSync();
    Response* resp0 = reqMan->getSubjectsUpdated(lastUpdate);
    connect(resp0, &Response::ready, [=](){
        dataMan->fillSubjectsToUpdateColnod(resp0->getJson());
        areChangedDataReady();
        resp0->deleteLater();
    });

    Response* resp1 = reqMan->getTokensUpdated(lastUpdate);
    connect(resp1, &Response::ready, [=](){
        dataMan->fillTokensToUpdateColnod(resp1->getJson());
        areChangedDataReady();
        resp1->deleteLater();
    });
}

// fill tokens/subjects to delete in data manager
void SyncManager::loadDeletedDataFromColnod()
{
    uint64_t lastUpdate = dataMan->getLastSync();
    Response* resp2 = reqMan->getSubjectsDeleted(lastUpdate);
    connect(resp2, &Response::ready, [=](){
        dataMan->fillSubjectsToDeleteColnod(resp2->getJson());
        areChangedDataReady();
        resp2->deleteLater();
    });

    Response* resp3 = reqMan->getTokensDeleted(lastUpdate);
    connect(resp3, &Response::ready, [=](){
        dataMan->fillTokensToDeleteColnod(resp3->getJson());
        areChangedDataReady();
        resp3->deleteLater();
    });

}

// fill structures in data manager (tokens to updata/to delte)
void SyncManager::loadDataFromDB()
{
    dataMan->fillTokensToChangeDB();
}

void SyncManager::syncDataFromColnodToDB()
{
    syncUpdatedDataFromColnodToDB();
    if (dataMan->getLastSync() != 0)
        syncDeletedDataFromColnodToDB();
}

// push data from colnod to DB
void SyncManager::syncUpdatedDataFromColnodToDB()
{
    dataMan->pushSubjectsToDB();
    dataMan->pushTokensToDB();
}

// set deleted tokens from Colnod, delete subject
void SyncManager::syncDeletedDataFromColnodToDB()
{
    dataMan->deleteSubjectsFromDB();
    dataMan->setDeletedToTokensFromDB();
}

// push changes form DB to Colnod
void SyncManager::syncDataFromDBToColnod()
{

    connect(this, &SyncManager::dataUpdatedToColnod, dataMan.get(), &DataManager::clear);
    //connect(this, &SyncManager::dataUpdatedToColnod, dataMan.get(), &DataManager::setLastSync);
    if (!dryMode)
        connect(this, &SyncManager::dataUpdatedToColnod, [=](){
            auto resp = reqMan->getTokensUpdated(dataMan->getCurrentSync());
            connect(resp, &Response::ready, [=](){
                dataMan->fillTokensToUpdateColnod(resp->getJson());
                dataMan->setLastUpdate();
                dataMan->clear();
                dataMan->updateLastSync();
                emit syncFinished();
                resp->deleteLater();
            });
        });
    else
        connect(this, &SyncManager::dataUpdatedToColnod, [=](){
            dataMan->updateLastSync();
            emit syncFinished();
        });
    if (!dataMan->getTokensToUpdateFromDB().contains("empty")){
        syncUpdatedDataFromDBToColnod();
    }
    else
        updateFinished = true;
    if (!dataMan->getTokensToDeleteDB().contains("empty")){
        syncDeletedDataFromDBToColnod();
    }
    else
        deleteFinished = true;
}

// add or update tokens to Colnod
void SyncManager::syncUpdatedDataFromDBToColnod()
{
    dataMan->filterTokensDB();
    auto tokensToUpdate = dataMan->getTokensToUpdateFromDB();
    if (dryMode){
        for (const auto &token : tokensToUpdate)
            qInfo() << "Updating token:" << token->idToStringWithoutBraces() << "to Colnod";
        updateFinished = true;
        areDataUpdatedToColnod();
    }
    else {
        Response* resp0 = reqMan->setTokens(tokensToUpdate);
        connect(resp0, &Response::ready, [=](){
            qInfo() << "Colnod:" << tokensToUpdate.size() << "tokens updated";
            for(const auto &token : tokensToUpdate)
                Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), "updated", "Colnod"));
            updateFinished = true;
            areDataUpdatedToColnod();
            resp0->deleteLater();
        });
    }
}

// delete tokens in Colnod
void SyncManager::syncDeletedDataFromDBToColnod()
{
    auto tokensToDelete = dataMan->getTokensToDeleteDB();
    if (dryMode){
        for (const auto &token : tokensToDelete)
            qInfo() << "Deleting token:" << token << "from Colnod";
        deleteFinished = true;
        areDataUpdatedToColnod();
    }
    else {
        Response* resp1 = reqMan->deleteTokens(tokensToDelete);
        connect(resp1, &Response::ready, [=](){
            qInfo() << "Colnod:" << tokensToDelete.size() << "tokens deleted";
            for (const auto &id : tokensToDelete){
                dataMan->setLastUpdate(id);
                Logger::logToDb(Logger::makeTokenMsg(id, "deleted", "Colnod"));
            }
            deleteFinished = true;
            areDataUpdatedToColnod();
            resp1->deleteLater();
        });
    }
}

// For full sync
void SyncManager::prepareDatabase()
{
    dataMan->emptyDatabase();
}

// emit signal when all data is downloaded from Colnod
void SyncManager::areChangedDataReady()
{
    if (++dataCounter == 5)
        emit dataDownloaded();
}

// emit signal when writing to Colnod is finised
void SyncManager::areDataUpdatedToColnod()
{
    if (deleteFinished && updateFinished)
    {
        emit dataUpdatedToColnod();
    }
}