register_callback.h

#ifndef TGBOT_REGISTER_CB_H
#define TGBOT_REGISTER_CB_H

#include "methods/api.h"
#include "types.h"
#include "utils/str_match.h"

#include <functional>
#include <tuple>
#include <vector>

namespace tgbot {

    template<typename __TypeUpdate>
    using __T_UpdateCallback =
    std::function<void(const __TypeUpdate, const methods::Api &)>;

    class RegisterCallback {
    public:
        using MessageCallback = __T_UpdateCallback<types::Message>;
        using InlineQueryCallback = __T_UpdateCallback<types::InlineQuery>;
        using ChosenInlineResultCallback =
        __T_UpdateCallback<types::ChosenInlineResult>;
        using CallbackQueryCallback = __T_UpdateCallback<types::CallbackQuery>;
        using ShippingQueryCallback = __T_UpdateCallback<types::ShippingQuery>;
        using PreCheckoutQueryCallback = __T_UpdateCallback<types::PreCheckoutQuery>;

    protected:
        using __Command_Tuple =
        std::tuple<const char *,
                std::function<bool(const std::string &, const char *)>,
                const char,
                std::function<void(const types::Message, const methods::Api &,
                                   const std::vector<std::string>)> >;

        RegisterCallback() = default;

        MessageCallback messageCallback;
        InlineQueryCallback inlineQueryCallback;
        ChosenInlineResultCallback chosenInlineResultCallback;
        CallbackQueryCallback callbackQueryCallback;
        ShippingQueryCallback shippingQueryCallback;
        PreCheckoutQueryCallback preCheckoutQueryCallback;
        MessageCallback editedMessageCallback;
        MessageCallback editedChannelPostCallback;
        MessageCallback channelPostCallback;
        std::vector<__Command_Tuple> commandCallback;

    public:
        inline void callback(bool (&matcherCallback)(const std::string &,
                                                     const char *),
                             void (&callback)(const types::Message,
                                              const methods::Api &,
                                              const std::vector<std::string>),
                             const char *matchWord, const char sep = ' ') {
            commandCallback.emplace_back(matchWord, matcherCallback, sep, callback);
        }

        inline void callback(bool (&matcherCallback)(const std::string &, const char *),
                             std::function<void(const types::Message, const methods::Api &,
                                                const std::vector<std::string>)>
                             callback,
                             const char *matchWord, const char sep = ' ') {
            commandCallback.emplace_back(matchWord, matcherCallback, sep, callback);
        }

        inline void callback(std::function<bool(const std::string &,
                                                const char *)> matcherCallback,
                             void (&callback)(const types::Message,
                                              const methods::Api &,
                                              const std::vector<std::string>),
                             const char *matchWord, const char sep = ' ') {

            commandCallback.emplace_back(matchWord, matcherCallback, sep, callback);
        }

        inline void callback(std::function<bool(const std::string &,
                                                const char *)> matcherCallback,
                             std::function<void(const types::Message, const methods::Api &,
                                                const std::vector<std::string>)> callback,
                             const char *matchWord, const char sep = ' ') {

            commandCallback.emplace_back(matchWord, matcherCallback, sep, callback);
        }

        inline void callback(void (&callback)(const types::Message,
                                              const methods::Api &)) {
            messageCallback = callback;
        }

        inline void callback(MessageCallback callback) { messageCallback = callback; }

        inline void callback(void (&callback)(const types::InlineQuery,
                                              const methods::Api &)) {
            inlineQueryCallback = callback;
        }

        inline void callback(InlineQueryCallback callback) {
            inlineQueryCallback = callback;
        }

        inline void callback(void (&callback)(const types::ChosenInlineResult,
                                              const methods::Api &)) {
            chosenInlineResultCallback = callback;
        }

        inline void callback(ChosenInlineResultCallback callback) {
            chosenInlineResultCallback = callback;
        }

        inline void callback(void (&callback)(const types::CallbackQuery,
                                              const methods::Api &)) {
            callbackQueryCallback = callback;
        }

        inline void callback(CallbackQueryCallback callback) {
            callbackQueryCallback = callback;
        }

        inline void callback(void (&callback)(const types::ShippingQuery,
                                              const methods::Api &)) {
            shippingQueryCallback = callback;
        }

        inline void callback(ShippingQueryCallback callback) {
            shippingQueryCallback = callback;
        }

        inline void callback(void (&callback)(const types::PreCheckoutQuery,
                                              const methods::Api &)) {
            preCheckoutQueryCallback = callback;
        }

        inline void callback(PreCheckoutQueryCallback callback) {
            preCheckoutQueryCallback = callback;
        }

        inline void callback(void (&callback)(const types::Message,
                                              const methods::Api &),
                             const types::UpdateType &which) {
            if (which == types::UpdateType::EDITED_MESSAGE)
                editedMessageCallback = callback;
            else if (which == types::UpdateType::EDITED_CHANNEL_POST)
                editedChannelPostCallback = callback;
            else if (which == types::UpdateType::CHANNEL_POST)
                channelPostCallback = callback;
        }

        inline void callback(MessageCallback callback,
                             const types::UpdateType updateType) {
            switch (updateType) {
                case types::UpdateType::EDITED_MESSAGE:
                    editedMessageCallback = callback;
                    break;
                case types::UpdateType::EDITED_CHANNEL_POST:
                    editedChannelPostCallback = callback;
                    break;
                case types::UpdateType::CHANNEL_POST:
                    channelPostCallback = callback;
                    break;
                default:
                    break;
            }
        }
    };

}  // namespace tgbot

#endif