#include <Variable/Variable.h>

#include <Data/ScalarSeries.h>

#include <QObject>
#include <QtTest>

#include <memory>

namespace {

/// Generates a date in double
auto date = [](int year, int month, int day, int hours, int minutes, int seconds) {
    return DateUtils::secondsSinceEpoch(
        QDateTime{{year, month, day}, {hours, minutes, seconds}, Qt::UTC});
};

/// Generates a series of test data for a range
std::shared_ptr<ScalarSeries> dataSeries(const SqpRange &range)
{
    auto xAxisData = std::vector<double>{};
    auto valuesData = std::vector<double>{};

    auto value = 0;
    for (auto x = range.m_TStart; x <= range.m_TEnd; ++x, ++value) {
        xAxisData.push_back(x);
        valuesData.push_back(value);
    }

    return std::make_shared<ScalarSeries>(std::move(xAxisData), std::move(valuesData), Unit{},
                                          Unit{});
}

} // namespace

Q_DECLARE_METATYPE(std::shared_ptr<ScalarSeries>)

class TestVariable : public QObject {
    Q_OBJECT

private slots:
    void testClone_data();
    void testClone();

    void testNotInCacheRangeList();
    void testInCacheRangeList();

    void testNbPoints_data();
    void testNbPoints();

    void testRealRange_data();
    void testRealRange();
};

void TestVariable::testClone_data()
{
    // ////////////// //
    // Test structure //
    // ////////////// //

    QTest::addColumn<QString>("name");
    QTest::addColumn<QVariantHash>("metadata");
    QTest::addColumn<SqpRange>("range");
    QTest::addColumn<SqpRange>("cacheRange");
    QTest::addColumn<std::shared_ptr<ScalarSeries> >("dataSeries");

    // ////////// //
    // Test cases //
    // ////////// //

    auto cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 13, 0, 0)};
    QTest::newRow("clone1") << QStringLiteral("var1")
                            << QVariantHash{{"data1", 1}, {"data2", "abc"}}
                            << SqpRange{date(2017, 1, 1, 12, 30, 0), (date(2017, 1, 1, 12, 45, 0))}
                            << cacheRange << dataSeries(cacheRange);
}

void TestVariable::testClone()
{
    // Creates variable
    QFETCH(QString, name);
    QFETCH(QVariantHash, metadata);
    QFETCH(SqpRange, range);
    QFETCH(SqpRange, cacheRange);
    QFETCH(std::shared_ptr<ScalarSeries>, dataSeries);

    Variable variable{name, metadata};
    variable.setRange(range);
    variable.setCacheRange(cacheRange);
    variable.mergeDataSeries(dataSeries);

    // Clones variable
    auto clone = variable.clone();

    // Checks cloned variable's state
    QCOMPARE(clone->name(), name);
    QCOMPARE(clone->metadata(), metadata);
    QCOMPARE(clone->range(), range);
    QCOMPARE(clone->cacheRange(), cacheRange);

    // Compares data series
    if (dataSeries != nullptr) {
        QVERIFY(clone->dataSeries() != nullptr);
        QVERIFY(std::equal(dataSeries->cbegin(), dataSeries->cend(), clone->dataSeries()->cbegin(),
                           clone->dataSeries()->cend(), [](const auto &it1, const auto &it2) {
                               return it1.x() == it2.x() && it1.value() == it2.value();
                           }));
    }
    else {
        QVERIFY(clone->dataSeries() == nullptr);
    }
}

void TestVariable::testNotInCacheRangeList()
{
    auto varRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
    auto varRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 40, 0}};

    auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};

    auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
    auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};

    auto sqpCR
        = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};

    Variable var{"Var test"};
    var.setRange(sqpR);
    var.setCacheRange(sqpCR);

    // 1: [ts,te] < varTS
    auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
    auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
    auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};

    auto notInCach = var.provideNotInCacheRangeList(sqp);

    QCOMPARE(notInCach.size(), 1);

    auto notInCachRange = notInCach.first();

    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));

    // 2: ts < varTS < te < varTE
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideNotInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRS));

    // 3: varTS < ts < te < varTE
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideNotInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 0);


    // 4: varTS < ts < varTE < te
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideNotInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRE));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));

    // 5: varTS < varTE < ts < te
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 20, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideNotInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));

    // 6: ts <varTS < varTE < te
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideNotInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 2);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRS));
    notInCachRange = notInCach[1];
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRE));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));
}


void TestVariable::testInCacheRangeList()
{
    auto varRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
    auto varRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 40, 0}};

    auto sqpR = SqpRange{DateUtils::secondsSinceEpoch(varRS), DateUtils::secondsSinceEpoch(varRE)};

    auto varCRS = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 0, 0}};
    auto varCRE = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 0, 0}};
    auto sqpCR
        = SqpRange{DateUtils::secondsSinceEpoch(varCRS), DateUtils::secondsSinceEpoch(varCRE)};

    Variable var{"Var test"};
    var.setRange(sqpR);
    var.setCacheRange(sqpCR);

    // 1: [ts,te] < varTS
    auto ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
    auto te = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
    auto sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};

    auto notInCach = var.provideInCacheRangeList(sqp);

    QCOMPARE(notInCach.size(), 0);

    // 2: ts < varTS < te < varTE
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 0, 0, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    auto notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRS));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));

    // 3: varTS < ts < te < varTE
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 30, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(te));

    // 4: varTS < ts < varTE < te
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 3, 20, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(ts));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRE));

    // 5: varTS < varTE < ts < te
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 4, 20, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 0);

    // 6: ts <varTS < varTE < te
    ts = QDateTime{QDate{2017, 01, 01}, QTime{2, 1, 0, 0}};
    te = QDateTime{QDate{2017, 01, 01}, QTime{2, 5, 0, 0}};
    sqp = SqpRange{DateUtils::secondsSinceEpoch(ts), DateUtils::secondsSinceEpoch(te)};
    notInCach = var.provideInCacheRangeList(sqp);
    QCOMPARE(notInCach.size(), 1);
    notInCachRange = notInCach.first();
    QCOMPARE(notInCachRange.m_TStart, DateUtils::secondsSinceEpoch(varCRS));
    QCOMPARE(notInCachRange.m_TEnd, DateUtils::secondsSinceEpoch(varCRE));
}

namespace {

/// Struct used to represent an operation for @sa TestVariable::testNbPoints()
struct NbPointsOperation {
    SqpRange m_CacheRange;                      /// Range to set for the variable
    std::shared_ptr<ScalarSeries> m_DataSeries; /// Series to merge in the variable
    int m_ExpectedNbPoints; /// Number of points in the variable expected after operation
};

using NbPointsOperations = std::vector<NbPointsOperation>;

} // namespace

Q_DECLARE_METATYPE(NbPointsOperations)

void TestVariable::testNbPoints_data()
{
    // ////////////// //
    // Test structure //
    // ////////////// //

    QTest::addColumn<NbPointsOperations>("operations");

    // ////////// //
    // Test cases //
    // ////////// //
    NbPointsOperations operations{};

    // Sets cache range (expected nb points = values data)
    auto cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 9)};
    operations.push_back({cacheRange, dataSeries(cacheRange), 10});

    // Doubles cache but don't add data series (expected nb points don't change)
    cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 19)};
    operations.push_back({cacheRange, dataSeries(INVALID_RANGE), 10});

    // Doubles cache and data series (expected nb points change)
    cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 12, 0, 19)};
    operations.push_back({cacheRange, dataSeries(cacheRange), 20});

    // Decreases cache (expected nb points decreases as the series is purged)
    cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 5), date(2017, 1, 1, 12, 0, 9)};
    operations.push_back({cacheRange, dataSeries(INVALID_RANGE), 5});

    QTest::newRow("nbPoints1") << operations;
}

void TestVariable::testNbPoints()
{
    // Creates variable
    Variable variable{"var"};
    QCOMPARE(variable.nbPoints(), 0);

    QFETCH(NbPointsOperations, operations);
    for (const auto &operation : operations) {
        // Sets cache range and merge data series
        variable.setCacheRange(operation.m_CacheRange);
        if (operation.m_DataSeries != nullptr) {
            variable.mergeDataSeries(operation.m_DataSeries);
        }

        // Checks nb points
        QCOMPARE(variable.nbPoints(), operation.m_ExpectedNbPoints);
    }
}

namespace {

/// Struct used to represent a range operation on a variable
/// @sa TestVariable::testRealRange()
struct RangeOperation {
    SqpRange m_CacheRange;                      /// Range to set for the variable
    std::shared_ptr<ScalarSeries> m_DataSeries; /// Series to merge in the variable
    SqpRange m_ExpectedRealRange; /// Real Range expected after operation on the variable
};

using RangeOperations = std::vector<RangeOperation>;

} // namespace

Q_DECLARE_METATYPE(RangeOperations)

void TestVariable::testRealRange_data()
{
    // ////////////// //
    // Test structure //
    // ////////////// //

    QTest::addColumn<RangeOperations>("operations");

    // ////////// //
    // Test cases //
    // ////////// //
    RangeOperations operations{};

    // Inits cache range and data series (expected real range = cache range)
    auto cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 13, 0, 0)};
    operations.push_back({cacheRange, dataSeries(cacheRange), cacheRange});

    // Changes cache range and updates data series (expected real range = cache range)
    cacheRange = SqpRange{date(2017, 1, 1, 14, 0, 0), date(2017, 1, 1, 15, 0, 0)};
    operations.push_back({cacheRange, dataSeries(cacheRange), cacheRange});

    // Changes cache range and update data series but with a lower range (expected real range =
    // data series range)
    cacheRange = SqpRange{date(2017, 1, 1, 12, 0, 0), date(2017, 1, 1, 16, 0, 0)};
    auto dataSeriesRange = SqpRange{date(2017, 1, 1, 14, 0, 0), date(2017, 1, 1, 15, 0, 0)};
    operations.push_back({cacheRange, dataSeries(dataSeriesRange), dataSeriesRange});

    // Changes cache range but DON'T update data series (expected real range = cache range
    // before operation)
    cacheRange = SqpRange{date(2017, 1, 1, 10, 0, 0), date(2017, 1, 1, 17, 0, 0)};
    operations.push_back({cacheRange, nullptr, dataSeriesRange});

    QTest::newRow("realRange1") << operations;
}

void TestVariable::testRealRange()
{
    // Creates variable (real range is invalid)
    Variable variable{"var"};
    QCOMPARE(variable.realRange(), INVALID_RANGE);

    QFETCH(RangeOperations, operations);
    for (const auto &operation : operations) {
        // Sets cache range and merge data series
        variable.setCacheRange(operation.m_CacheRange);
        if (operation.m_DataSeries != nullptr) {
            variable.mergeDataSeries(operation.m_DataSeries);
        }

        // Checks real range
        QCOMPARE(variable.realRange(), operation.m_ExpectedRealRange);
    }
}


QTEST_MAIN(TestVariable)
#include "TestVariable.moc"