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

#include "ApplicationCalendar.hpp"
#include "DialogMetadataMessage.hpp"
#include "NoEvents.hpp"
#include "Dialog.hpp"

#include <application-calendar/windows/CalendarMainWindow.hpp>
#include <application-calendar/windows/DayEventsWindow.hpp>
#include <application-calendar/windows/CalendarEventsOptionsWindow.hpp>
#include <application-calendar/windows/AllEventsWindow.hpp>
#include <application-calendar/windows/EventDetailWindow.hpp>
#include <application-calendar/windows/NewEditEventWindow.hpp>
#include <application-calendar/windows/CustomRepeatWindow.hpp>
#include <application-calendar/windows/EventReminderWindow.hpp>
#include <module-apps/messages/DialogMetadataMessage.hpp>
#include <module-db/queries/calendar/QueryEventsAdd.hpp>
#include <service-db/DBServiceAPI.hpp>
#include <service-db/QueryMessage.hpp>
#include <service-db/DBNotificationMessage.hpp>

#include <ctime>

namespace app
{
    const std::map<Reminder, const char *> ApplicationCalendar::reminderOptions = {
        {Reminder::never, "app_calendar_reminder_never"},
        {Reminder::event_time, "app_calendar_reminder_event_time"},
        {Reminder::five_min_before, "app_calendar_reminder_5_min_before"},
        {Reminder::fifteen_min_before, "app_calendar_reminder_15_min_before"},
        {Reminder::thirty_min_before, "app_calendar_reminder_30_min_before"},
        {Reminder::one_hour_before, "app_calendar_reminder_1_hour_before"},
        {Reminder::two_hour_before, "app_calendar_reminder_2_hour_before"},
        {Reminder::one_day_before, "app_calendar_reminder_1_day_before"},
        {Reminder::two_days_before, "app_calendar_reminder_2_days_before"},
        {Reminder::one_week_before, "app_calendar_reminder_1_week_before"}};

    const std::map<Repeat, const char *> ApplicationCalendar::repeatOptions = {
        {Repeat::never, "app_calendar_repeat_never"},
        {Repeat::daily, "app_calendar_repeat_daily"},
        {Repeat::weekly, "app_calendar_repeat_weekly"},
        {Repeat::biweekly, "app_calendar_repeat_two_weeks"},
        {Repeat::monthly, "app_calendar_repeat_month"},
        {Repeat::yearly, "app_calendar_repeat_year"}};

    ApplicationCalendar::ApplicationCalendar(std::string name,
                                             std::string parent,
                                             sys::phone_modes::PhoneMode mode,
                                             StartInBackground startInBackground,
                                             uint32_t stackDepth,
                                             sys::ServicePriority priority)
        : Application(name, parent, mode, startInBackground, stackDepth, priority)
    {
        bus.channels.push_back(sys::BusChannel::ServiceDBNotifications);
        addActionReceiver(manager::actions::ShowReminder, [this](auto &&data) {
            switchWindow(style::window::calendar::name::event_reminder_window, std::move(data));
            return actionHandled();
        });
    }

    sys::MessagePointer ApplicationCalendar::DataReceivedHandler(sys::DataMessage *msgl, sys::ResponseMessage *resp)
    {
        auto retMsg = Application::DataReceivedHandler(msgl);
        // if message was handled by application's template there is no need to process further.
        if (retMsg && (dynamic_cast<sys::ResponseMessage *>(retMsg.get())->retCode == sys::ReturnCodes::Success)) {
            return retMsg;
        }

        auto msg = dynamic_cast<db::NotificationMessage *>(msgl);
        if (msg != nullptr) {
            LOG_DEBUG("Received notification");
            // window-specific actions
            if (msg->interface == db::Interface::Name::Events) {
                for (auto &[name, window] : windowsStack.windows) {
                    window->onDatabaseMessage(msg);
                }
            }
            return std::make_shared<sys::ResponseMessage>();
        }

        // this variable defines whether message was processed.
        bool handled = false;
        // handle database response
        if (resp != nullptr) {
            handled = true;
            if (auto command = callbackStorage->getCallback(resp); command->execute()) {
                refreshWindow(gui::RefreshModes::GUI_REFRESH_FAST);
            }
        }
        if (handled) {
            return std::make_shared<sys::ResponseMessage>();
        }
        else {
            return std::make_shared<sys::ResponseMessage>(sys::ReturnCodes::Unresolved);
        }
    }

    sys::ReturnCodes ApplicationCalendar::InitHandler()
    {
        applicationStartTime = std::time(nullptr);
        auto ret             = Application::InitHandler();
        createUserInterface();
        return ret;
    }

    sys::ReturnCodes ApplicationCalendar::DeinitHandler()
    {
        return sys::ReturnCodes::Success;
    }

    void ApplicationCalendar::createUserInterface()
    {
        using namespace style::window::calendar::name;

        windowsFactory.attach(gui::name::window::main_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::CalendarMainWindow>(app, name);
        });
        windowsFactory.attach(day_events_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::DayEventsWindow>(app);
        });
        windowsFactory.attach(no_events_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::NoEvents>(app, name);
        });
        windowsFactory.attach(style::window::calendar::name::events_options,
                              [](Application *app, const std::string &name) {
                                  return std::make_unique<gui::CalendarEventsOptions>(app);
                              });
        windowsFactory.attach(dialog_yes_no, [](Application *app, const std::string &name) {
            return std::make_unique<gui::DialogYesNo>(app, dialog_yes_no);
        });
        windowsFactory.attach(all_events_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::AllEventsWindow>(app, all_events_window);
        });
        windowsFactory.attach(details_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::EventDetailWindow>(app, details_window);
        });
        windowsFactory.attach(new_edit_event, [](Application *app, const std::string &name) {
            return std::make_unique<gui::NewEditEventWindow>(app, new_edit_event);
        });
        windowsFactory.attach(custom_repeat_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::CustomRepeatWindow>(app, custom_repeat_window);
        });
        windowsFactory.attach(event_reminder_window, [](Application *app, const std::string &name) {
            return std::make_unique<gui::EventReminderWindow>(app, event_reminder_window);
        });
        windowsFactory.attach(gui::window::name::dialog_confirm, [](Application *app, const std::string &name) {
            return std::make_unique<gui::DialogConfirm>(app, name);
        });

        attachPopups(
            {gui::popup::ID::Volume, gui::popup::ID::Tethering, gui::popup::ID::PhoneModes, gui::popup::ID::PhoneLock});
    }

    void ApplicationCalendar::destroyUserInterface()
    {}

    void ApplicationCalendar::switchToNoEventsWindow(const std::string &title, const TimePoint &dateFilter)
    {
        if (equivalentWindow == EquivalentWindow::DayEventsWindow) {
            popToWindow(gui::name::window::main_window);
        }
        if (equivalentWindow == EquivalentWindow::AllEventsWindow) {
            popToWindow(gui::name::window::main_window);
        }

        LOG_DEBUG("Switch to no events window");

        auto metaData = std::make_unique<gui::DialogMetadataMessage>(gui::DialogMetadata{
            title,
            "phonebook_empty_grey_circle_W_G",
            utils::translate("app_calendar_no_events_information"),
            "",
            [=]() -> bool {
                LOG_DEBUG("Switch to new event window");
                auto event       = std::make_shared<EventsRecord>();
                event->date_from = dateFilter;
                event->date_till = dateFilter + std::chrono::hours(utils::time::Locale::max_hour_24H_mode) +
                                   std::chrono::minutes(utils::time::Locale::max_minutes);

                auto eventData = std::make_unique<EventRecordData>(std::move(event));
                eventData->setDescription(style::window::calendar::new_event);
                switchWindow(
                    style::window::calendar::name::new_edit_event, gui::ShowMode::GUI_SHOW_INIT, std::move(eventData));
                return true;
            }});

        switchWindow(style::window::calendar::name::no_events_window, std::move(metaData));
    }

} /* namespace app */