#include <QtTest>

#include "syncmanager.h"
// add necessary includes here

class SyncManagerTest : public QObject
{
    Q_OBJECT
private:
    std::shared_ptr<Token> tokenFromString(const QString &text);
private slots:
    void tokenFromString_test();
    void sync_init_test();
    void prepareData_test();
    void prepareData_tokens();
    void prepareData_tokens_data();

};

std::shared_ptr<Token> SyncManagerTest::tokenFromString(const QString &text)
{
    auto split = text.split(",");
    if (split.count() != 2)
        return nullptr;

    auto token = std::make_shared<Token>();
    token->setId(split.first());
    token->setDescription("mobile");
    token->setLastUpdate(QDateTime::fromString(split.last(), "yyyyMMdd:HHmmss"));
    return token;
}

void SyncManagerTest::tokenFromString_test()
{
    auto token = tokenFromString("id1,20191010:232300");
    QCOMPARE(token->id(), QStringLiteral("id1"));
    QCOMPARE(token->lastUpdate(), QDateTime::fromString("20191010:232300", "yyyyMMdd:HHmmss"));
}

void SyncManagerTest::sync_init_test()
{
    SyncManager sync(true);
    QVERIFY(sync.databaseInitialization());
}


void SyncManagerTest::prepareData_test()
{
    SyncManager sync(true);
    QVERIFY(sync.databaseInitialization());
    auto dbData = std::make_shared<Data>();
    auto colnodData = std::make_shared<Data>();

    auto token = std::make_shared<Token>();
    token->setDescription("mobile");
    token->setId("id1");
    dbData->updatedTokens.insert("id1", token);

    auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
    auto newPreparedData = sync.prepareDataNew(dbData, colnodData);
    QVERIFY(oldPreparedData->databaseData->updatedTokens.contains("id1"));
    QVERIFY(newPreparedData->databaseData->updatedTokens.contains("id1"));
    QVERIFY(oldPreparedData->databaseData->updatedSubjects.isEmpty());
    QVERIFY(newPreparedData->databaseData->updatedSubjects.isEmpty());
    QVERIFY(oldPreparedData->databaseData->deletedTokens.isEmpty());
    QVERIFY(newPreparedData->databaseData->deletedTokens.isEmpty());
    QVERIFY(oldPreparedData->databaseData->deletedSubjects.isEmpty());
    QVERIFY(newPreparedData->databaseData->deletedSubjects.isEmpty());
}

void SyncManagerTest::prepareData_tokens()
{
    SyncManager sync(true);
    QVERIFY(sync.databaseInitialization());



    QFETCH(QString, db_token_updated);
    QFETCH(QString, db_token_deleted);
    QFETCH(QString, colnod_token_updated);
    QFETCH(QString, colnod_token_deleted);
    QFETCH(QString, expected_db_tokens_toupdate);
    QFETCH(QString, expected_db_tokens_todelete);
    QFETCH(QString, expected_colnod_tokens_toupdate);
    QFETCH(QString, expected_colnod_tokens_todelete);

    // fake data
    auto dbData = std::make_shared<Data>();
    auto colnodData = std::make_shared<Data>();

    // Database
    auto utoken = tokenFromString(db_token_updated);
    if ( utoken )
        dbData->updatedTokens.insert(utoken->id(), utoken);
    auto dtoken = tokenFromString(db_token_deleted);
    if ( dtoken )
        dbData->deletedTokens.append(dtoken->id());

    // Colnod
    auto colnod_utoken = tokenFromString(colnod_token_updated);
    if ( colnod_utoken )
        colnodData->updatedTokens.insert(colnod_utoken->id(), colnod_utoken);
    auto colnod_dtoken = tokenFromString(colnod_token_deleted);
    if ( colnod_dtoken )
        colnodData->deletedTokens.append(colnod_dtoken->id());

    auto oldPreparedData = sync.prepareDataUsindOld(dbData, colnodData);
    auto newPreparedData = sync.prepareDataNew(dbData, colnodData);


    auto testTokens = [=](const QSet<QString> &set, const QString &expectedId) {
        if (expectedId.isEmpty()) {
            QVERIFY(set.isEmpty());
        } else {
            QVERIFY(set.contains(expectedId));
        }
    };

    testTokens(newPreparedData->databaseData->updatedTokens.keys().toSet(), expected_db_tokens_toupdate);
    testTokens(newPreparedData->databaseData->deletedTokens.toSet(), expected_db_tokens_todelete);

    testTokens(newPreparedData->colnodData->updatedTokens.keys().toSet(), expected_colnod_tokens_toupdate);
    testTokens(newPreparedData->colnodData->deletedTokens.toSet(), expected_colnod_tokens_todelete);

    testTokens(oldPreparedData->databaseData->updatedTokens.keys().toSet(), expected_db_tokens_toupdate);
    testTokens(oldPreparedData->databaseData->deletedTokens.toSet(), expected_db_tokens_todelete);

    testTokens(oldPreparedData->colnodData->updatedTokens.keys().toSet(), expected_colnod_tokens_toupdate);
    testTokens(oldPreparedData->colnodData->deletedTokens.toSet(), expected_colnod_tokens_todelete);

//    QVERIFY(newPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
//    QVERIFY(newPreparedData->databaseData->deletedTokens.contains(expected_db_tokens_todelete));
//    QVERIFY(newPreparedData->colnodData->updatedTokens.contains(expected_colnod_tokens_toupdate));
//    QVERIFY(newPreparedData->colnodData->deletedTokens.contains(expected_colnod_tokens_todelete));

//    QVERIFY(oldPreparedData->databaseData->updatedTokens.contains(expected_db_tokens_toupdate));
//    QVERIFY(oldPreparedData->databaseData->deletedTokens.contains(expected_db_tokens_todelete));
//    QVERIFY(oldPreparedData->colnodData->updatedTokens.contains(expected_colnod_tokens_toupdate));
//    QVERIFY(oldPreparedData->colnodData->deletedTokens.contains(expected_colnod_tokens_todelete));

}

void SyncManagerTest::prepareData_tokens_data()
{
    QTest::addColumn<QString>("db_token_updated");
    QTest::addColumn<QString>("db_token_deleted");
    QTest::addColumn<QString>("colnod_token_updated");
    QTest::addColumn<QString>("colnod_token_deleted");
    QTest::addColumn<QString>("expected_db_tokens_toupdate");
    QTest::addColumn<QString>("expected_db_tokens_todelete");
    QTest::addColumn<QString>("expected_colnod_tokens_toupdate");
    QTest::addColumn<QString>("expected_colnod_tokens_todelete");

    // in: db 1 new token
    // out: 1 db token must be updated in colnod
    QTest::newRow("db 1 update") << "id1,20191010:23:23:00" << ""
                             << "" << ""
                             // expected database: toupdate << todelete
                             << "id1" << ""
                             // expected colnod: toupdate << todelete
                             << "" << "";
    // in: id1 in database new/updated
    // in: id1 deleted in colnod
    // out: 1 colnod token must be deleted from database
    QEXPECT_FAIL("delete 1 existing token in database", "Rare case, not sure if handling is needed", Continue);
    QTest::newRow("delete 1 existing token in database") << "id1,20191010:23:23:00" << ""
                             << "" << "id1,20191010:23:23:00"
                             // expected database: toupdate << todelete
                             << "" << ""
                             // expected colnod: toupdate << todelete
                             << "" << "id1";
}

QTEST_MAIN(SyncManagerTest)

#include "tst_syncmanager.moc"