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

#include "Service.hpp"
#include "FreeRTOSConfig.h"    // for configASSERT
#include "MessageType.hpp"     // for MessageType, MessageType::MessageType...
#include "Service/Common.hpp"  // for BusChannels, ReturnCodes, ReturnCodes...
#include "Service/Mailbox.hpp" // for Mailbox
#include "Service/Message.hpp" // for Message, MessagePointer, DataMessage, Resp...
#include "Timer.hpp"           // for Timer
#include "TimerMessage.hpp"    // for TimerMessage
#include "log/debug.hpp"       // for DEBUG_SERVICE_MESSAGES
#include "log/log.hpp"         // for LOG_ERROR, LOG_DEBUG, LOG_FATAL
#include "mutex.hpp"           // for cpp_freertos
#include "portmacro.h"         // for UBaseType_t
#include "thread.hpp"          // for Thread
#include "ticks.hpp"           // for Ticks
#include <algorithm>           // for remove_if
#include <cstdint>             // for uint32_t, uint64_t, UINT32_MAX
#include <iosfwd>              // for std
#include <typeinfo>            // for type_info

#if (DEBUG_SERVICE_MESSAGES > 0)
#include <cxxabi.h>
#endif

// this could use Scoped() class from utils to print execution time too
void debug_msg(sys::Service *srvc, const sys::Message *ptr)
{
#if (DEBUG_SERVICE_MESSAGES > 0)

    int status     = -1;
    char *realname = nullptr;
    realname       = abi::__cxa_demangle(typeid(*ptr).name(), 0, 0, &status);

    LOG_DEBUG("Handle message ([%s] -> [%s] (%s) data: %s",
              ptr->sender.c_str(),
              srvc->GetName().c_str(),
              realname,
              std::string(*ptr).c_str());

    free(realname);
#else
#endif
}

namespace sys
{
    using namespace cpp_freertos;
    using namespace std;

    Service::Service(std::string name, std::string parent, uint32_t stackDepth, ServicePriority priority)
        : cpp_freertos::Thread(name, stackDepth / 4 /* Stack depth in bytes */, static_cast<UBaseType_t>(priority)),
          parent(parent), bus{this}, mailbox(this), pingTimestamp(UINT32_MAX), isReady(false), enableRunLoop(false)
    {
    }

    Service::~Service()
    {
        enableRunLoop = false;
        LOG_DEBUG("%s", (GetName() + ":Service base destructor").c_str());
    }

    void Service::StartService()
    {
        bus.connect();
        enableRunLoop = true;
        if (!Start()) {
            LOG_FATAL("FATAL ERROR: Start service failed!:%s", GetName().c_str());
            configASSERT(0);
        }
    }

    void Service::CloseService()
    {
        bus.disconnect();
    }

    void Service::Run()
    {
        while (enableRunLoop) {
            auto msg = mailbox.pop();
            if (!msg) {
                continue;
            }

            // Remove all staled messages
            uint32_t timestamp = cpp_freertos::Ticks::GetTicks();
            staleUniqueMsg.erase(std::remove_if(staleUniqueMsg.begin(),
                                                staleUniqueMsg.end(),
                                                [&](const auto &id) {
                                                    return ((id.first == msg->uniID) ||
                                                            ((timestamp - id.second) >= 15000));
                                                }),
                                 staleUniqueMsg.end());

            const bool respond = msg->type != Message::Type::Response && GetName() != msg->sender;
            auto response      = msg->Execute(this);
            if (response == nullptr || !respond) {
                continue;
            }

            bus.sendResponse(response, msg);
        }
        CloseService();
    };

    auto Service::MessageEntry(Message *message, ResponseMessage *response) -> MessagePointer
    {
        return response == nullptr ? HandleMessage(message) : HandleResponse(response);
    }

    auto Service::HandleMessage(Message *message) -> MessagePointer
    {
        debug_msg(this, message);

        if (const auto &[handled, ret] = ExecuteMessageHandler(message); handled) {
            return ret;
        }
        if (auto dataMsg = dynamic_cast<DataMessage *>(message); dataMsg != nullptr) {
            return DataReceivedHandler(dataMsg, nullptr);
        }

        LOG_ERROR("Failed to handle message of type [%s]", typeid(*message).name());
        return nullptr;
    }

    auto Service::HandleResponse(ResponseMessage *message) -> MessagePointer
    {
        debug_msg(this, message);

        if (const auto &[handled, ret] = ExecuteMessageHandler(message); handled) {
            return ret;
        }
        DataMessage dummy(MessageType::MessageTypeUninitialized);
        return DataReceivedHandler(&dummy, message);
    }

    auto Service::ExecuteMessageHandler(Message *message) -> std::pair<bool, MessagePointer>
    {
        const auto idx = type_index(typeid(*message));
        if (const auto handler = message_handlers.find(idx); handler != message_handlers.end()) {
            const auto &handlerFunction = handler->second;
            return {true, handlerFunction(message)};
        }
        return {false, nullptr};
    }

    bool Service::connect(const type_info &type, MessageHandler handler)
    {
        auto idx   = type_index(type);
        if (message_handlers.find(idx) == message_handlers.end()) {
            LOG_DEBUG("Registering new message handler on %s", type.name());
            message_handlers[idx] = handler;
            return true;
        }
        LOG_ERROR("Handler for: %s already registered!", type.name());
        return false;
    }

    bool Service::connect(Message *msg, MessageHandler handler)
    {
        auto &type = typeid(*msg);
        return connect(type, handler);
    }

    bool Service::connect(Message &&msg, MessageHandler handler)
    {
        return connect(&msg, handler);
    }

    void Service::CloseHandler()
    {
        timers.stop();
        enableRunLoop = false;
    }

    auto Service::TimerHandle(SystemMessage &message) -> ReturnCodes
    {
        auto timer_message = dynamic_cast<sys::TimerMessage *>(&message);
        if (timer_message == nullptr) {
            LOG_ERROR("Wrong message in system message handler");
            return ReturnCodes::Failure;
        }

        auto timer = timers.get(timer_message->getTimer());
        if (timer == timers.noTimer()) {
            LOG_ERROR("No such timer registered in Service");
            return ReturnCodes::Failure;
        }

        (*timer)->onTimeout();
        return ReturnCodes::Success;
    }

    void Service::Timers::stop()
    {
        for (auto timer : list) {
            timer->stop();
        }
    }

    auto Proxy::handleMessage(Service *service, Message *message, ResponseMessage *response) -> MessagePointer
    {
        if (service->isReady) {
            return service->MessageEntry(message, response);
        }
        return std::make_shared<ResponseMessage>(ReturnCodes::ServiceDoesntExist);
    }

    auto Proxy::handleSystemMessage(Service *service, SystemMessage *message) -> MessagePointer
    {
        auto ret = ReturnCodes::Success;
        switch (message->systemMessageType) {
        case SystemMessageType::Ping:
            service->pingTimestamp = cpp_freertos::Ticks::GetTicks();
            break;
        case SystemMessageType::SwitchPowerMode:
            service->SwitchPowerModeHandler(message->powerMode);
            break;
        case SystemMessageType::Exit:
            ret = service->DeinitHandler();
            service->CloseHandler();
            break;
        case SystemMessageType::Timer:
            ret = service->TimerHandle(*message);
            break;
        case SystemMessageType::Start:
            ret = service->InitHandler();
            if (ret == ReturnCodes::Success) {
                service->isReady = true;
            }
            break;
        }
        return std::make_shared<ResponseMessage>(ret);
    }
} // namespace sys