// Copyright (c) 2017-2020, Mudita Sp. z.o.o. All rights reserved.
// For licensing, see https://github.com/mudita/MuditaOS/LICENSE.md

#include <catch2/catch.hpp>

#include "Database/Database.hpp"
#include "Databases/EventsDB.hpp"

#include "Tables/EventsTable.hpp"

#include <vfs.hpp>
#include <stdint.h>
#include <string>
#include <algorithm>
#include <iostream>

TEST_CASE("Events Table tests")
{
    Database::initialize();

    vfs.remove(EventsDB::GetDBName());

    EventsDB eventsDb;
    REQUIRE(eventsDb.isInitialized());

    auto &eventsTbl = eventsDb.events;
    REQUIRE(eventsTbl.count() == 0);

    SECTION("Default Constructor")
    {
        EventsTableRow testRow;
        REQUIRE(testRow.ID == DB_ID_NONE);
        REQUIRE(testRow.UID == "");
        REQUIRE(testRow.title == "");
        REQUIRE(testRow.date_from == TIME_POINT_INVALID);
        REQUIRE(testRow.date_till == TIME_POINT_INVALID);
        REQUIRE(testRow.reminder == 0);
        REQUIRE(testRow.repeat == 0);
        REQUIRE(testRow.reminder_fired == TIME_POINT_INVALID);
        REQUIRE_FALSE(testRow.isValid());
    }

    REQUIRE(eventsTbl.add({{.ID = 0},
                           .UID            = "test",
                           .title          = "Event3",
                           .date_from      = TimePointFromString("2019-10-20 14:24:00"),
                           .date_till      = TimePointFromString("2019-10-20 15:36:00"),
                           .reminder       = 1,
                           .repeat         = 2,
                           .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));

    REQUIRE(eventsTbl.add({{.ID = 0},
                           .UID            = "test",
                           .title          = "Event4",
                           .date_from      = TimePointFromString("2021-10-20 12:24:00"),
                           .date_till      = TimePointFromString("2021-10-20 15:36:00"),
                           .reminder       = 0,
                           .repeat         = 3,
                           .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));

    REQUIRE(eventsTbl.count() == 2);

    SECTION("Get entry by ID")
    {
        auto entry = eventsTbl.getById(2);
        REQUIRE(entry.ID == 2);
        REQUIRE(entry.title == "Event4");
        REQUIRE(entry.date_from == TimePointFromString("2021-10-20 12:24:00"));
        REQUIRE(entry.date_till == TimePointFromString("2021-10-20 15:36:00"));
        REQUIRE(entry.reminder == 0);
        REQUIRE(entry.repeat == 3);
        REQUIRE(entry.isValid());
    }

    SECTION("Remove entry by ID")
    {
        auto response = eventsTbl.removeById(2);
        REQUIRE(response);
        REQUIRE_FALSE(eventsTbl.count() == 2);
        REQUIRE_NOTHROW(eventsTbl.getById(2));
        auto entry = eventsTbl.getById(1);
        REQUIRE(entry.ID == 1);
        REQUIRE(entry.title == "Event3");
        REQUIRE(entry.date_from == TimePointFromString("2019-10-20 14:24:00"));
        REQUIRE(entry.date_till == TimePointFromString("2019-10-20 15:36:00"));
        REQUIRE(entry.reminder == 1);
        REQUIRE(entry.repeat == 2);
        REQUIRE(entry.isValid());
    }

    SECTION("Update entry by ID")
    {
        auto entry = EventsTableRow({{.ID = 2},
                                     "test",
                                     "TestUpdateEvent",
                                     TimePointFromString("2019-10-20 15:00:00"),
                                     TimePointFromString("2019-10-20 18:54:00"),
                                     0,
                                     2,
                                     TIME_POINT_INVALID});
        REQUIRE(eventsTbl.update(entry));
        auto record = eventsTbl.getById(2);
        REQUIRE(record.ID == 2);
        REQUIRE(record.title == "TestUpdateEvent");
        REQUIRE(record.date_from == TimePointFromString("2019-10-20 15:00:00"));
        REQUIRE(record.date_till == TimePointFromString("2019-10-20 18:54:00"));
        REQUIRE(record.reminder == 0);
        REQUIRE(record.repeat == 2);
        REQUIRE(record.isValid());
    }

    SECTION("Select entry by date")
    {
        REQUIRE(eventsTbl.add({{.ID = 0},
                               .UID            = "test",
                               .title          = "Event5",
                               .date_from      = TimePointFromString("2019-10-20 14:24:00"),
                               .date_till      = TimePointFromString("2019-10-20 15:36:00"),
                               .reminder       = 1,
                               .repeat         = 2,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 1},
                               .UID            = "test",
                               .title          = "Event6",
                               .date_from      = TimePointFromString("2021-04-19 12:24:00"),
                               .date_till      = TimePointFromString("2021-04-20 15:36:00"),
                               .reminder       = 0,
                               .repeat         = 3,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 2},
                               .UID            = "test",
                               .title          = "Event7",
                               .date_from      = TimePointFromString("2019-10-20 15:24:00"),
                               .date_till      = TimePointFromString("2019-10-20 15:36:00"),
                               .reminder       = 1,
                               .repeat         = 2,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 3},
                               .UID            = "test",
                               .title          = "Event8",
                               .date_from      = TimePointFromString("2021-04-19 12:24:00"),
                               .date_till      = TimePointFromString("2019-10-20 15:36:00"),
                               .reminder       = 0,
                               .repeat         = 3,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 4},
                               .UID            = "test",
                               .title          = "Event9",
                               .date_from      = TimePointFromString("2025-10-20 15:24:00"),
                               .date_till      = TimePointFromString("2025-10-20 15:36:00"),
                               .reminder       = 1,
                               .repeat         = 2,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 5},
                               .UID            = "test",
                               .title          = "Event10",
                               .date_from      = TimePointFromString("2021-12-19 12:24:00"),
                               .date_till      = TimePointFromString("2021-12-20 15:36:00"),
                               .reminder       = 0,
                               .repeat         = 3,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));

        auto entries = eventsTbl.selectByDatePeriod(
            TimePointFromString("2000-01-01 00:00:00"), TimePointFromString("2012-12-31 23:59:00"), 0, UINT32_MAX);

        REQUIRE(entries.size() == 0);
    }
    for (uint32_t i = 1; i <= 8; ++i) {
        auto response = eventsTbl.removeById(i);
        REQUIRE(response);
    }
    REQUIRE(eventsTbl.count() == 0);

    SECTION("Get all limited by date")
    {
        for (uint32_t i = 1; i <= 3; ++i) {
            auto response = eventsTbl.removeById(i);
            REQUIRE(response);
        }
        REQUIRE(eventsTbl.count() == 0);

        const std::array<TimePoint, 6> paramDate{TimePointFromString("2018-10-20 15:24"),
                                                 TimePointFromString("2019-10-30 14:24"),
                                                 TimePointFromString("2020-10-20 14:24"),
                                                 TimePointFromString("2021-12-20 14:24"),
                                                 TimePointFromString("2022-10-20 14:24"),
                                                 TimePointFromString("2023-10-20 14:24")};
        const std::array<uint32_t, 6> paramID{3, 4, 5, 6, 7, 8};
        const std::array<std::string, 6> paramName{"Event1", "Event2", "Event3", "Event4", "Event5", "Event6"};
        REQUIRE(eventsTbl.add({{.ID = 1},
                               .UID            = "test",
                               .title          = "Event1",
                               .date_from      = paramDate[0],
                               .date_till      = TimePointFromString("2030-10-20 15:24"),
                               .reminder       = 0,
                               .repeat         = 0,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 2},
                               .UID            = "test",
                               .title          = "Event2",
                               .date_from      = paramDate[5],
                               .date_till      = TimePointFromString("2030-10-20 15:24"),
                               .reminder       = 0,
                               .repeat         = 0,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 3},
                               .UID            = "test",
                               .title          = "Event3",
                               .date_from      = paramDate[2],
                               .date_till      = TimePointFromString("2030-10-20 15:24"),
                               .reminder       = 0,
                               .repeat         = 0,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 4},
                               .UID            = "test",
                               .title          = "Event4",
                               .date_from      = paramDate[3],
                               .date_till      = TimePointFromString("2030-10-20 15:24"),
                               .reminder       = 0,
                               .repeat         = 0,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 5},
                               .UID            = "test",
                               .title          = "Event5",
                               .date_from      = paramDate[4],
                               .date_till      = TimePointFromString("2030-10-20 15:24"),
                               .reminder       = 0,
                               .repeat         = 0,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));
        REQUIRE(eventsTbl.add({{.ID = 6},
                               .UID            = "test",
                               .title          = "Event6",
                               .date_from      = paramDate[1],
                               .date_till      = TimePointFromString("2030-10-20 15:24"),
                               .reminder       = 0,
                               .repeat         = 0,
                               .reminder_fired = TimePointFromString("2019-10-20 15:36:00")}));

        auto entries = eventsTbl.getLimitOffsetByDate(0, 6);
        REQUIRE(entries.size() == 6);
        uint32_t index = 0;
        for (auto entry : entries) {
            REQUIRE(entry.ID == paramID[index]);
            REQUIRE(entry.title == paramName[index]);
            REQUIRE(entry.date_from == paramDate[index]);
            REQUIRE(entry.date_till == TimePointFromString("2030-10-20 15:24"));
            REQUIRE(entry.reminder == 0);
            REQUIRE(entry.repeat == 0);
            REQUIRE(entry.isValid());
            ++index;
        }
    }

    SECTION("Select first upcoming event")
    {
        for (uint32_t i = 1; i <= 10; ++i) {
            auto response = eventsTbl.removeById(i);
            REQUIRE(response);
        }
        REQUIRE(eventsTbl.count() == 0);

        const std::array<TimePoint, 6> paramDate{TimePointFromString("2018-10-20 15:24:00"),
                                                 TimePointFromString("2019-10-30 14:24:00"),
                                                 TimePointFromString("2020-10-20 14:24:00"),
                                                 TimePointFromString("2021-12-20 14:24:00"),
                                                 TimePointFromString("2022-10-20 14:24:00"),
                                                 TimePointFromString("2023-10-20 14:24:00")};
        TimePoint startDate1 = TimePointFromString("2018-10-20 14:24:00");
        TimePoint startDate2 = TimePointFromString("2020-10-20 14:24:00");

        TimePoint tillDate  = TimePointFromString("2030-10-20 15:24:00");
        TimePoint firedDate = TimePointFromString("2018-10-20 14:24:00");

        REQUIRE(eventsTbl.add({{.ID = 1},
                               .UID            = "test",
                               .title          = "Event1",
                               .date_from      = paramDate[0],
                               .date_till      = tillDate,
                               .reminder       = 120,
                               .repeat         = 0,
                               .reminder_fired = TIME_POINT_INVALID}));
        REQUIRE(eventsTbl.add({{.ID = 2},
                               .UID            = "test",
                               .title          = "Event2",
                               .date_from      = paramDate[1],
                               .date_till      = tillDate,
                               .reminder       = 120,
                               .repeat         = 0,
                               .reminder_fired = TIME_POINT_INVALID}));
        REQUIRE(eventsTbl.add({{.ID = 3},
                               .UID            = "test",
                               .title          = "Event3",
                               .date_from      = paramDate[2],
                               .date_till      = tillDate,
                               .reminder       = 120,
                               .repeat         = 0,
                               .reminder_fired = firedDate}));
        REQUIRE(eventsTbl.add({{.ID = 4},
                               .UID            = "test",
                               .title          = "Event4",
                               .date_from      = paramDate[3],
                               .date_till      = tillDate,
                               .reminder       = 120,
                               .repeat         = 0,
                               .reminder_fired = firedDate}));
        REQUIRE(eventsTbl.add({{.ID = 5},
                               .UID            = "test",
                               .title          = "Event5",
                               .date_from      = paramDate[4],
                               .date_till      = tillDate,
                               .reminder       = 120,
                               .repeat         = 0,
                               .reminder_fired = TIME_POINT_INVALID}));
        REQUIRE(eventsTbl.add({{.ID = 6},
                               .UID            = "test",
                               .title          = "Event6",
                               .date_from      = paramDate[5],
                               .date_till      = tillDate,
                               .reminder       = 120,
                               .repeat         = 0,
                               .reminder_fired = TIME_POINT_INVALID}));

        auto entries = eventsTbl.SelectFirstUpcoming(startDate1, tillDate);
        REQUIRE(entries.size() == 1);
        for (auto entry : entries) {
            REQUIRE(entry.title == "Event2");
        }

        entries = eventsTbl.SelectFirstUpcoming(startDate2, tillDate);
        REQUIRE(entries.size() == 1);
        for (auto entry : entries) {
            REQUIRE(entry.title == "Event5");
        }

        for (uint32_t i = 1; i <= 10; ++i) {
            auto response = eventsTbl.removeById(i);
            REQUIRE(response);
        }
        REQUIRE(eventsTbl.count() == 0);
    }

    Database::deinitialize();
}