#include "datamanager.h"

DataManager::DataManager(const bool &dryMode)
{
    db = new DatabaseManager("192.168.1.94", "deloitte", "postgres", "34rjkciea12", dryMode);
    //db = new DatabaseManager("localhost", "deloitte", "postgres", "34rjkciea12");
    Logger::setDBMan(db);
    nextLastSync = db->getNow();
    lastSync = db->getLastSync();
    this->dryMode = dryMode;
}

// load all tokens from colnod to comparing with working set from DB
void DataManager::fillFullTokensColnod(const QString& response)
{
    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (!items.empty())
    {
        for (QJsonValueRef item : items){
            auto token = new Token();
            token->fromJSON(item.toObject());
            allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
        }
    }
    else{
        qCritical() << "Colnod is Empty";
        auto token = new Token("empty");
        allTokensFromColnod.insert(token->idToStringWithoutBraces(), token);
    }
}

// load working set with updated tokens from Colnod
void DataManager::fillTokensToUpdateColnod(const QString& response)
{
    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (!items.empty())
    {
        for (QJsonValueRef item : items)
        {
            auto token = new Token();
            token->fromJSON(item.toObject());
            token->setDeleted(false);
            tokensToUpdateFromColnodToDB.insert(token->idToStringWithoutBraces(), token);
        }
        qInfo() << "Colnod:" << tokensToUpdateFromColnodToDB.size() << "tokens to update";
    }
    else
    {
        qInfo() << "Colnod: 0 tokens to update";
        auto token = new Token("empty");
        tokensToUpdateFromColnodToDB.insert(token->getName(), token);
    }
}

// load working set with updated subjects from Colnod
void DataManager::fillSubjectsToUpdateColnod(const QString& response)
{
    QJsonDocument doc = QJsonDocument::fromJson(response.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (!items.empty())
    {
        for (QJsonValueRef item : items)
        {
            auto subject = new Subject();
            subject->fromJSON(item.toObject());
            subjectsToUpdateFromColnodToDB.insert(subject->idToStringWithoutBraces(), subject);
        }
        qInfo() << "Colnod:" << subjectsToUpdateFromColnodToDB.size() << "subjects to update";
    }
    else
    {
        qInfo() << "Colnod:" << "0 subjects to update";
        Subject* subject = new Subject("empty");
        subjectsToUpdateFromColnodToDB.insert(subject->getName(), subject);
    }
}

// load working sets with updated/deleted tokens from DB
void DataManager::fillTokensToChangeDB()
{
    QSqlQuery* query = db->getUpdatedTokens();
    while (query->next())
    {
        auto token = new Token;
        token->fromSQLRecord(query);
        if (token->getDeleted()){                   // sort to delete / to update
            tokensFromDBToDeleteFromColnod.append(token->idToStringWithoutBraces());
        }
        else{
        tokensToUpdateFromDBToColnod.insert(token->idToStringWithoutBraces(), token);
        }
    }
    qDebug() << "DB:" << tokensToUpdateFromDBToColnod.size() << "tokens to update";
    qDebug() << "DB:" << tokensFromDBToDeleteFromColnod.size() << "tokens to delete";
}

void DataManager::fillSubjectsToUpdateDB()
{
   // Not needed yet
}

// load working set with subjest to delete from Colnod
void DataManager::fillSubjectsToDeleteColnod(const QString& json)
{
    QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (!items.empty())
    {
        for (QJsonValueRef item : items) {
            subjectsFromColnodToDeleteFromDB.append(item.toString());
        }
        qInfo() << "Colnod:" << subjectsFromColnodToDeleteFromDB.size() << "subjects to delete";
    }
    else {
        qInfo() << "Colnod: 0 subjects to delete";
        subjectsFromColnodToDeleteFromDB.append("empty");
    }
}

// load working set with tokens to delete from DB
void DataManager::fillTokensToDeleteColnod(const QString& json)
{
    QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8());
    QJsonArray items = doc.object()["items"].toArray();
    if (!items.empty())
    {
        for (QJsonValueRef item : items) {
            tokensFromColnodToDeleteFromDB.append(item.toString());
        }
        qInfo() << "Colnod:" << tokensFromColnodToDeleteFromDB.size() << "tokens to delete";
    }
    else {
        qInfo() << "Colnod: 0 tokens to delete";
        tokensFromColnodToDeleteFromDB.append("empty");
    }
}

void DataManager::fillSubjectsToDeleteDB()
{
    // Not needed yet
}

// update subjects from colnod to DB
void DataManager::pushSubjectsToDB()
{
    if (subjectsToUpdateFromColnodToDB.contains("empty")) {
        qInfo() << "DB: 0 subjects added";
        qInfo() << "DB: 0 subjects updated";
        return;
    }
    int updated = 0;
    int added = 0;
    for (const auto& subject : subjectsToUpdateFromColnodToDB)
    {
        if (db->saveSubject(subject, "colnod_subject") > 0){
                added++;
                Logger::logToDb(Logger::makeSubjectMsg( subject->idToStringWithoutBraces(),"added", "DB"));
        }
        else{
                updated++;
                Logger::logToDb(Logger::makeSubjectMsg( subject->idToStringWithoutBraces(),"updated", "DB"));
        }
        db->saveSubjectAttributes(subject, "colnod_subject_attribute");
    }
    qInfo() << "DB:" << added << "subjects added";
    qInfo() << "DB:" << updated << "subjects updated";
}

// update tokens from colnod to DB
void DataManager::pushTokensToDB()
{
    if (tokensToUpdateFromColnodToDB.contains("empty")){
        qInfo() << "DB: 0 tokens added";
        qInfo() << "DB: 0 tokens updated";
        return;
    }
    filterTokensColnod();
    int updated = 0;
    int added = 0;
    for (const auto& token : tokensToUpdateFromColnodToDB)
    {
        if (db->saveToken(token, "colnod_token") > 0){
                added++;
                Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), "added", "DB"));
        }
        else{
                updated++;
                Logger::logToDb(Logger::makeTokenMsg(token->idToStringWithoutBraces(), "updated", "DB"));
        }
    }
    qInfo() << "DB:" << added << " tokens added";
    qInfo() << "DB:" << updated << " tokens updated";

}

void DataManager::deleteSubjectsFromDB()
{
    if (subjectsFromColnodToDeleteFromDB[0] == "empty")
    {
        qInfo() << "DB: 0 subjects deleted";
        return;
    }
    for (const auto& subjectId : subjectsFromColnodToDeleteFromDB)
    {
        db->setDeleted(subjectId, "colnod_subject");
        Logger::logToDb(Logger::makeSubjectMsg(subjectId, "deleted", "DB"));
    }
    qInfo() << "DB:" << subjectsFromColnodToDeleteFromDB.size() << " subject deleted";
}

// "delete" (set deleted true) tokens in DB depends on Colnod
void DataManager::setDeletedToTokensFromDB()
{
    if (tokensFromColnodToDeleteFromDB[0] == "empty")
    {
        qDebug() << "DB: 0 tokens deleted";
        return;
    }
    int alreadyDeleted = 0;
    for (const auto& tokenId : tokensFromColnodToDeleteFromDB)
    {
        if (!db->checkDeletedToken(tokenId)){
            db->setDeleted(tokenId, "colnod_token");
            Logger::logToDb(Logger::makeTokenMsg(tokenId, "deleted", "DB"));
        }
        else
            alreadyDeleted++;
    }
    qDebug() << "DB:" << tokensFromColnodToDeleteFromDB.size() - alreadyDeleted << "tokens deleted";
}

// do I have loaded all data
bool DataManager::haveChangedData()
{
    return !subjectsToUpdateFromColnodToDB.isEmpty() &&
         !tokensToUpdateFromColnodToDB.isEmpty() &&
         !subjectsFromColnodToDeleteFromDB.isEmpty() &&
         !tokensFromColnodToDeleteFromDB.isEmpty() &&
         !allTokensFromColnod.isEmpty();
}

// recreate working tables
void DataManager::emptyDatabase()
{
    db->dropTables();
    db->createTables();
}

//clear all structures
void DataManager::clear()
{
    subjectsToUpdateFromColnodToDB.clear();
    subjectsFromColnodToDeleteFromDB.clear();
    tokensToUpdateFromColnodToDB.clear();
    tokensFromColnodToDeleteFromDB.clear();
   //subjectsDB.clear();            // not need yet
   // subjectsToDeleteDB.clear();   // not need yet
    tokensToUpdateFromDBToColnod.clear();
    tokensFromDBToDeleteFromColnod.clear();
    allTokensFromColnod.clear();
}

// on the very end of sync update last sync time to begin time of this sync
void DataManager::updateLastSync()
{
    db->updateLastSync(nextLastSync);
}

// these to filter functions solve colision tokens -> remove when change on this token is earlier then change on the same token on the other side (Colnod/DB)
void DataManager::filterTokensDB()
{
    for (const auto& token : tokensToUpdateFromDBToColnod)
    {
        QString id = token->idToStringWithoutBraces();
        Q_ASSERT(token != allTokensFromColnod.value(id));        // if working sets are loading correctly equels should never happend
        if (allTokensFromColnod.contains(id) && *token < *allTokensFromColnod.value(id))
            tokensToUpdateFromDBToColnod.remove(id);
    }
}

void DataManager::filterTokensColnod()
{
    for (const auto &token : tokensToUpdateFromColnodToDB)
    {
        QString id = token->idToStringWithoutBraces();
        auto record = db->getToken(id);
        if (!record)
            continue;
        auto tokenDB = new Token;
        tokenDB->fromSQLRecord(record);
        Q_ASSERT(tokenDB != token);
        if (*tokenDB > *token)
            tokensToUpdateFromColnodToDB.remove(id);
    }
}

// sync last update from colnod to DB
void DataManager::setLastUpdate()
{
    for (const auto &token : tokensToUpdateFromColnodToDB){
        db->setLastUpdate(token->idToStringWithoutBraces(), token->getLastUpdate());
    }
}