message.hpp

//
// message.hpp
// ***********
//
// Copyright (c) 2019 Sharon W (sharon at aegis dot gg)
//
// Distributed under the MIT License. (See accompanying file LICENSE)
//

#pragma once

#include "aegis/config.hpp"
#include "aegis/snowflake.hpp"
#include "aegis/shards/shard.hpp"
#include "aegis/rest/rest_reply.hpp"
#include "aegis/gateway/objects/attachment.hpp"
#include "aegis/gateway/objects/embed.hpp"
#include "aegis/gateway/objects/reaction.hpp"
#include "aegis/gateway/objects/user.hpp"
#include <nlohmann/json.hpp>
#include "aegis/futures.hpp"

namespace aegis
{

struct edit_message_t;

namespace gateway
{

namespace objects
{

class message;

AEGIS_DECL void from_json(const nlohmann::json& j, objects::message& m);

AEGIS_DECL void to_json(nlohmann::json& j, const objects::message& m);

enum message_type
{
    Default = 0,
    RecipientAdd = 1,
    RecipientRemove = 2,
    Call = 3,
    ChannelNameChange = 4,
    ChannelIconChange = 5,
    ChannelPinnedMessage = 6,
    GuildMemberJoin = 7
};

class message
{
public:

    explicit message(const std::string & content, aegis::channel * _channel, aegis::guild * _guild) noexcept
        : _content(content)
        , _channel(_channel)
        , _guild(_guild)
    {
    }


    message(const std::string & _json, aegis::core * _core) noexcept
        : _core(_core)
    {
        from_json(nlohmann::json::parse(_json), *this);
        populate_self();
    }


    message(const nlohmann::json & _json, aegis::core * _core) noexcept
        : _core(_core)
    {
        from_json(_json, *this);
        populate_self();
    }


    message(aegis::core * _core) noexcept
        : _core(_core)
    {
        populate_self();
    }


    AEGIS_DECL void set_channel(aegis::channel * _channel)
    {
        this->_channel = _channel;
    }


    AEGIS_DECL void set_guild(aegis::guild * _guild)
    {
        this->_guild = _guild;
    }

    message() = default;
    message & operator=(const message &) = default;
    message(const message&) = default;
    message(message && msg) = default;

    inline bool operator==(const std::string& rhs)
    {
        return _content == rhs;
    }

    inline bool operator!=(const std::string& rhs)
    {
        return !(*this == rhs);
    }

    inline bool operator==(const char * rhs)
    {
        return _content == rhs;
    }

    inline bool operator!=(const char * rhs)
    {
        return !(*this == rhs);
    }

    std::string timestamp; 
    std::string edited_timestamp; 
    bool tts = false; 
    bool mention_everyone = false; 
    std::vector<snowflake> mentions; 
    std::vector<snowflake> mention_roles; 
    std::vector<objects::attachment> attachments; 
    std::vector<objects::embed> embeds; 
    bool pinned = false; 
    std::vector<objects::reaction> reactions; 
    snowflake nonce; 
    std::string webhook_id; 
    objects::message_type type = Default; 
    user author; 

    bool is_dm() const noexcept
    {
        return !_guild_id;
    }


    bool is_bot() const noexcept
    {
        return author.is_bot();
    }


    bool is_webhook() const noexcept
    {
        return !webhook_id.empty();
    }


    const std::string & get_content() const noexcept
    {
        return _content;
    }


    void set_content(const std::string & content) noexcept
    {
        _content = content;
    }


    snowflake get_id() const noexcept
    {
        return _message_id;
    }


    snowflake get_channel_id() const noexcept
    {
        return _channel_id;
    }


    snowflake get_guild_id() const noexcept
    {
        return _guild_id;
    }


    snowflake get_author_id() const noexcept
    {
        return _author_id;
    }


    bool has_guild() const noexcept
    {
        return _guild != nullptr || _guild_id != 0;
    }


    bool has_channel() const noexcept
    {
        return _channel != nullptr || _channel_id != 0;
    }

#if !defined(AEGIS_DISABLE_ALL_CACHE)

    bool has_member() const noexcept
    {
        return _user != nullptr || _author_id != 0;
    }
#endif


    AEGIS_DECL aegis::guild & get_guild();


    AEGIS_DECL aegis::channel & get_channel();

#if !defined(AEGIS_DISABLE_ALL_CACHE)

    AEGIS_DECL aegis::user & get_user();
#endif


    AEGIS_DECL aegis::future<rest::rest_reply> delete_message();


    AEGIS_DECL aegis::future<message> edit(const std::string & content);


    AEGIS_DECL aegis::future<message> edit(edit_message_t & obj);


    AEGIS_DECL aegis::future<rest::rest_reply> create_reaction(const std::string & content);


    AEGIS_DECL aegis::future<rest::rest_reply> delete_own_reaction(const std::string & content);


    AEGIS_DECL aegis::future<rest::rest_reply> delete_user_reaction(const std::string & content, const snowflake member_id);


    AEGIS_DECL aegis::future<rest::rest_reply> delete_all_reactions();


    std::tuple<snowflake, snowflake, snowflake, snowflake> get_related_ids() const noexcept
    {
        return std::tuple<snowflake, snowflake, snowflake, snowflake>{ _channel_id, _guild_id, _message_id, _author_id };
    };

private:
    friend AEGIS_DECL void from_json(const nlohmann::json& j, objects::message& m);
    friend AEGIS_DECL void to_json(nlohmann::json& j, const objects::message& m);
    friend class aegis::core;

    AEGIS_DECL void populate_self();

    std::string _content;
    aegis::channel * _channel = nullptr;
    aegis::guild * _guild = nullptr;
#if !defined(AEGIS_DISABLE_ALL_CACHE)
    aegis::user * _user = nullptr;
#endif
    aegis::core * _core = nullptr;
    snowflake _message_id = 0; 
    snowflake _channel_id = 0; 
    snowflake _guild_id = 0; 
    snowflake _author_id = 0; 
};

}

}

}

#if defined(AEGIS_HEADER_ONLY)
#include "aegis/gateway/objects/impl/message.cpp"
#endif