basic_bot.hpp

#ifndef CPPGRAM_BASIC_BOT_HPP
#define CPPGRAM_BASIC_BOT_HPP

#include <string>

#include <cpr/cpr.h>
#include <spdlog/spdlog.h>

#include "command_handler.hpp"
#include "exception.hpp"
#include "keyboard.hpp"
#include "types/update.hpp"

namespace cppgram
{
template <class T> class BasicBot
{
    template <typename V> friend class Polling;
    template <class Z> friend class commands::Command;

    public:
    BasicBot( const std::string &token, std::string name = "Bot", T *obj_ptr = nullptr );

    BasicBot( const BasicBot &b, T *base_ptr );

    virtual ~BasicBot() {}

    BasicBot operator=( const BasicBot &b );

    inline void setChatId( uint_fast32_t chat_id ) { this->chat_id = chat_id; }

    inline void setChatId( int_fast64_t chat_id ) { this->chat_id = chat_id; }

    inline CommandHandler<T> &commands() { return command_handler; }

    inline Keyboard &keyboard() { return keyboard_obj; }

    inline std::shared_ptr<spdlog::logger> logger() { return logger_ptr; }

    std::shared_ptr<spdlog::logger> setLogger( spdlog::sink_ptr sink );

    inline std::shared_ptr<spdlog::logger> setLogger( std::vector<spdlog::sink_ptr> &sinks );

    void setLogger( std::shared_ptr<spdlog::logger> new_logger );

    virtual void init();

    const cpr::Response executeRequest( const std::string &method, const cpr::Parameters &params );

    bool checkMethodError( const cpr::Response &response, Json::Value &val );

    bool getUpdates( std::vector<types::Update> &updates,
                     const uint_fast32_t         offset  = 0,
                     const uint_fast32_t         limit   = 100,
                     const uint_fast32_t         timeout = 60 );

    std::experimental::optional<const class types::Message>
    sendMessage( const int_fast64_t chat_id,
                 const std::string &text,
                 const std::string &reply_markup             = "",
                 const EParseMode   parse_mode               = EParseMode::HTML,
                 const bool         disable_web_page_preview = true,
                 const bool         disable_notification     = false,
                 const int_fast32_t reply_to_message_id      = 0 );

    std::experimental::optional<const class types::Message>
    sendMessage( const std::string &chat_id,
                 const std::string &text,
                 const std::string &reply_markup             = "",
                 const EParseMode   parse_mode               = EParseMode::HTML,
                 const bool         disable_web_page_preview = true,
                 const bool         disable_notification     = false,
                 const int_fast32_t reply_to_message_id      = 0 );

    std::experimental::optional<const class types::Message>
    sendMessage( const std::string &text,
                 const std::string &reply_markup             = "",
                 const EParseMode   parse_mode               = EParseMode::HTML,
                 const bool         disable_web_page_preview = true,
                 const bool         disable_notification     = false,
                 const int_fast32_t reply_to_message_id      = 0 );

    bool answerCallbackQuery( const std::string &text,
                              bool               show_alert = false,
                              uint32_t           cache_time = 0,
                              const std::string &url        = "" );

    std::experimental::optional<const class types::Message>
    editMessageText( const int_fast64_t  chat_id,
                     const uint_fast32_t message_id,
                     const std::string & text,
                     const std::string & reply_markup             = "",
                     const EParseMode    parse_mode               = static_cast<EParseMode>( 1 ),
                     const bool          disable_web_page_preview = true );

    std::experimental::optional<const class types::Message>
    editMessageText( const std::string & chat_id,
                     const uint_fast32_t message_id,
                     const std::string & text,
                     const std::string & reply_markup             = "",
                     const EParseMode    parse_mode               = static_cast<EParseMode>( 1 ),
                     const bool          disable_web_page_preview = true );

    std::experimental::optional<const class types::Message>
    editMessageText( const uint_fast32_t message_id,
                     const std::string & text,
                     const std::string & reply_markup             = "",
                     const EParseMode    parse_mode               = static_cast<EParseMode>( 1 ),
                     const bool          disable_web_page_preview = true );
    bool editMessageText( const std::string &inline_message_id,
                          const std::string &text,
                          const std::string &reply_markup = "",
                          const EParseMode   parse_mode   = static_cast<EParseMode>( 1 ),
                          const bool         disable_web_page_preview = true );

    std::experimental::optional<const class types::Message>
    editMessageCaption( const int_fast64_t  chat_id,
                        const uint_fast32_t message_id,
                        const std::string & caption      = "",
                        const std::string & reply_markup = "" );

    std::experimental::optional<const class types::Message>
    editMessageCaption( const std::string & chat_id,
                        const uint_fast32_t message_id,
                        const std::string & caption      = "",
                        const std::string & reply_markup = "" );

    std::experimental::optional<const class types::Message>
    editMessageCaption( const uint_fast32_t message_id,
                        const std::string & caption      = "",
                        const std::string & reply_markup = "" );

    bool editMessageCaption( const std::string &inline_message_id,
                             const std::string &caption,
                             const std::string &reply_markup = "" );

    std::experimental::optional<const class types::Message>
    editMessageReplyMarkup( const int_fast64_t  chat_id,
                            const uint_fast32_t message_id,
                            const std::string & reply_markup = "" );

    std::experimental::optional<const class types::Message>
    editMessageReplyMarkup( const std::string & chat_id,
                            const uint_fast32_t message_id,
                            const std::string & reply_markup = "" );

    std::experimental::optional<const class types::Message>
    editMessageReplyMarkup( const uint_fast32_t message_id, const std::string &reply_markup = "" );

    bool editMessageReplyMarkup( const std::string &inline_message_id,
                                 const std::string &reply_markup = "" );

    bool answerInlineQuery( const Json::Value & results,
                            const uint_fast16_t cache_time         = 300,
                            const bool          is_personal        = false,
                            const std::string & next_offset        = "",
                            const std::string & switch_pm_text     = "",
                            const std::string & switch_pm_paramter = "" );

    std::function<void( T &, const types::Message & )> processMessage = nullptr;

    void ( *processEditedMessage )( T &, const types::Message & ) = nullptr;

    void ( *processChannelPost )( T &, const types::Message & ) = nullptr;

    void ( *processEditedChannelPost )( T &, const types::Message & ) = nullptr;

    void ( *processInlineQuery )( T &, const types::InlineQuery & ) = nullptr;

    void ( *processChosenInlineResult )( T &, const types::ChosenInlineResult & ) = nullptr;

    void ( *processCallbackQuery )( T &, const types::CallbackQuery & ) = nullptr;

    private:
    void processUpdate( const types::Update &update );

    int_fast64_t chat_id;

    std::string callback_query_id;

    std::string inline_query_id;

    Json::Reader reader;

    cpr::Session connection;

    std::shared_ptr<spdlog::logger> logger_ptr;

    std::string api_url,

            bot_name;

    CommandHandler<T> command_handler;

    Keyboard keyboard_obj;
};
}

#include "basic_bot_impl.hpp"

#endif