// SPDX-FileCopyrightText: 2024 Yury Gubich <blue@macaw.me>
// SPDX-License-Identifier: GPL-3.0-or-later

#include "router.h"

#include "module/module.h"
#include "connection/connection.h"

Router::Router(const Shared::Logger& logger) :
    Shared::Loggable(logger, {"Router"}),
    modules(),
    actors(),
    defaultGroup("Stranger"),
    responses({
        {Shared::forbidden, {"Forbidden"}},
        {Shared::error, {"Command error"}},
        {Shared::unhandled, {"No such command"}},
    }),
    generator(std::random_device{}()),
    dialogs() {}

void Router::registerModule(const std::shared_ptr<Module::Module>& module) {
    info("Registering module " + module->name + " as " + module->alias);
    modules[module->alias] = module;
}

void Router::registerActor(const std::string& key, const std::string& group) {
    if (key == "default") {
        defaultGroup = group;
        return;
    }

    Actors::iterator act = actors.find(key);
    if (act == actors.end())
        actors.emplace(key, std::make_shared<Actor>(key, group));
    else
        act->second->setGroup(group);
}

void Router::routeMessage(const std::string& sender, const std::string& body) {
    Shared::VC::const_iterator dItr = dialogs.find(sender);
    if (dItr != dialogs.end()) {
        if (body != "cancel")
            return routeToModule(dItr->second, sender, body);

        onMessageResult(cancelDialog(sender), sender);
        return;
    }

    std::string_view view(body);
    std::string_view aliasView = Module::Module::pop(view);
    if (aliasView.size() > 100) {
        warn("Received a message with the first word larger than 100 symbols from " + sender);
        onMessageResult(Shared::unhandled, sender);
        return;
    }

    routeToModule(std::string(aliasView), sender, view);
}

void Router::routeToModule(const std::string& alias, const std::string& sender, const std::string_view& message) {
    if (message.empty()) {
        debug("Incoming message from " + sender + " consists of only one word, modules have nothing to process");
        onMessageResult(Shared::unhandled, sender);
        return;
    }

    Modules::iterator mItr = modules.find(alias);
    if (mItr == modules.end()) {
        debug("could not find module \"" + alias + "\" to handle message from " + sender);
        onMessageResult(Shared::unhandled, sender);
        return;
    }

    std::shared_ptr<Module::Module> module = mItr->second.lock();
    if (!module) {
        error("could not lock module \"" + mItr->first + "\" to handle message from " + sender);
        onMessageResult(Shared::error, sender);
        return;
    }

    Shared::Result result = Shared::error;
    try {
        result = module->message(getActor(sender), message);
        if (result == Shared::success)
            debug("module \"" + mItr->first + "\" successfully handled message from " + sender);
    } catch (const std::exception& e) {
        error("module \"" + mItr->first + "\" thew an exception handling message from " + sender + ": " + e.what());
    } catch (...) {
        error("module \"" + mItr->first + "\" thew an unhandled exception handling message from " + sender);
    }

    switch (result) {
        case Shared::grab:
            startDialog(sender, alias);
            break;
        default:
            finishDialog(sender);
            break;
    }

    onMessageResult(result, sender);
}

bool Router::startDialog(const std::string& actor, const std::string& alias) {
    std::pair<Shared::VC::iterator, bool> result = dialogs.emplace(actor, alias);
    if (alias == result.first->second) {
        if (result.second)
            debug("Starting dialog of " + actor + " and " + alias);
        else
            debug("Continuing dialog of " + actor + " and " + alias);

        result.second = true;
    }

    if (!result.second)
        warn("There was a request from the module " + alias + " to start dialog with " + actor + " but the module " +
             result.first->second + " is already in a dialog with this user right now");

    return result.second;
}

void Router::finishDialog(const std::string& actor) {
    Shared::VC::const_iterator itr = dialogs.find(actor);
    if (itr != dialogs.end())
        return debug("Dialogue of " + actor + " and " + itr->second + " is complete");

    dialogs.erase(itr);
}

Shared::Result Router::cancelDialog(const std::string& actor) {
    Shared::VC::const_iterator dItr = dialogs.find(actor);
    if (dItr == dialogs.end()) {
        warn("There was a request to cancel dialog with " + actor + " but there is no dialog with him open right now");
        return Shared::unhandled;
    }

    Modules::iterator mItr = modules.find(dItr->second);
    if (mItr == modules.end()) {
        error("could not find module \"" + dItr->second + "\" to cancel dialog with " + actor);
        return Shared::unhandled;
    }

    std::shared_ptr<Module::Module> module = mItr->second.lock();
    if (!module) {
        error("could not lock module \"" + mItr->first + "\" to cancel dialog with " + actor);
        return Shared::error;
    }

    debug("canceling dialog with " + actor);
    try {
        module->cancelDialog(getActor(actor));
        dialogs.erase(dItr); 
        return Shared::success;
    } catch (const std::exception& e) {
        error("Caught exception canceling dialog in module " + dItr->second + ": " + e.what());
    } catch (...) {
        error("Caught unhandled exception canceling dialog in module " + dItr->second);
    }

    return Shared::error;
}

std::map<std::string, std::string> Router::getActors() const {
    std::map<std::string, std::string> result;

    for (const std::pair<const std::string, std::shared_ptr<Actor>>& pair : actors)
        result.emplace(pair.first, pair.second->getGroup());

    return result;
}

std::string Router::getDefaultGroup() const {
    return defaultGroup;
}

void Router::setConnection(const std::shared_ptr<Connection>& cn) {
    connection = cn;
}

void Router::setResponses(Shared::Result result, const Shared::Strings& options) {
    responses[result] = options;
}

std::string Router::getGroup(const std::string& key) const {
    Actors::const_iterator itr = actors.find(key);
    if (itr == actors.end())
        return defaultGroup;

    return itr->second->getGroup();
}

void Router::onMessageResult(Shared::Result result, const std::string& sender) {
    Responses::const_iterator rItr = responses.find(result);
    if (rItr == responses.end() || rItr->second.empty())
        return;

    std::shared_ptr<Connection> cn = connection.lock();
    if (!cn) {
        warn("Couldn't send a message to " + sender + ", connection is not available");
        return;
    }

    const List& options = rItr->second;
    std::uniform_int_distribution<std::size_t> dist(0, options.size() - 1);
    cn->send(sender, options[dist(generator)]);
}

std::shared_ptr<::Actor> Router::getActor(const std::string& jid) {
    Actors::iterator itr = actors.find(jid);
    if (itr == actors.end())
        itr = actors.emplace(jid, std::make_shared<Actor>(jid, defaultGroup)).first;

    return itr->second;
}