bot.h

#ifndef TGBOT_BOT_H
#define TGBOT_BOT_H

#include <exception>
#include <utility>

#include "register_callback.h"
#include "utils/https.h"

namespace tgbot {

    class TelegramException : public std::exception {
    public:
        explicit TelegramException(const std::string &_what) : __what(_what) {}

        const char *what() const noexcept override { return __what.c_str(); }

    private:
        const std::string __what;
    };

    class Bot : public methods::Api, public RegisterCallback {
    public:
        Bot(const Bot&) = default;
        Bot(Bot&&) = default;

        Bot& operator=(const Bot&) = default;
        Bot& operator=(Bot&&) = default;

        virtual ~Bot() = default;

        virtual void start() {}

        void notifyEachUpdate(bool t);

    protected:
        template<typename... TyArgs>
        explicit Bot(TyArgs &&... many) : Api(std::forward<TyArgs>(many)...) {
            utils::http::__internal_Curl_GlobalInit();
        }

        void makeCallback(const std::vector<types::Update> &updates) const;

    private:
        bool __notifyEachUpdate{false};
    };

    class LongPollBot : public Bot {
    public:
        explicit LongPollBot(const std::string &token,
                    const std::vector<types::UpdateType> &filterUpdates = {},
                    const int &limit = 100, const int &timeout = 60);

        LongPollBot(const LongPollBot &) = delete;

        LongPollBot(LongPollBot &&) = default;

        LongPollBot &operator=(const LongPollBot &) = delete;

        LongPollBot &operator=(LongPollBot &&) = default;

        void start() override;
    };

    class WebhookBot : public Bot {
    public:
        WebhookBot() = delete;

        WebhookBot(const std::string &token) = delete;

        WebhookBot(const std::string &token, const std::string &url,
                   const int &maxConnections = 40,
                   const std::vector<types::UpdateType> &filterUpdates = {}) = delete;

        WebhookBot(const std::string &token, const std::string &url,
                   const std::string &certificate, const int &maxConnections = 40,
                   const std::vector<types::UpdateType> &filterUpdates = {}) = delete;

        WebhookBot(const WebhookBot &) = delete;

        WebhookBot(WebhookBot &&) = delete;

        WebhookBot &operator=(const WebhookBot &) = delete;

        WebhookBot &operator=(WebhookBot &&) = delete;

        // start()
    };

}  // namespace tgbot

#endif