#pragma once

#include <ipc/IpcMessage.h>

#include <functional>
#include <string>
#include <tuple>
#include <unordered_map>

class RpcInvoker {
public:
    template<typename Obj, typename Ret, typename... Args>
    void registerMethod(Obj* instance,
                        const std::string& name,
                        Ret (Obj::*method)(Args...)) {
        handlers[name] =
            [instance, method](const IpcMessage& req) -> IpcMessage {
                IpcMessage msg = req;

                // пропустить имя метода
                (void)msg.template get<std::string>();

                // читать аргументы и вызвать метод
                return callMethod<Ret, Obj, Args...>(instance, method, msg);
            };
    }

    IpcMessage dispatch(const IpcMessage& request) {
        IpcMessage tmp = request;
        const std::string method = tmp.get<std::string>();

        auto it = handlers.find(method);
        if (it == handlers.end()) {
            return IpcMessage{};
        }

        return it->second(request);
    }

private:
    template<typename Ret, typename Obj, typename... Args>
    static IpcMessage callMethod(Obj* obj,
                                 Ret (Obj::*method)(Args...),
                                 IpcMessage& msg) {
        auto tuple = readArgs<Args...>(msg);
        Ret result =
            std::apply(method, std::tuple_cat(std::make_tuple(obj), tuple));

        IpcMessage out;
        out.add(result);
        return out;
    }

    template<typename... Args>
    static std::tuple<Args...> readArgs(IpcMessage& msg) {
        return std::tuple<Args...>{msg.template get<Args>()...};
    }

    std::unordered_map<std::string,
                       std::function<IpcMessage(const IpcMessage&)>>
        handlers;
};