channel.hpp

//
// channel.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/fwd.hpp"
#include "aegis/utility.hpp"
#include "aegis/ratelimit/ratelimit.hpp"
#include "aegis/permission.hpp"
#include "aegis/snowflake.hpp"
#include "aegis/gateway/objects/permission_overwrite.hpp"
#include "aegis/gateway/objects/channel.hpp"
#include <shared_mutex>
#include "aegis/futures.hpp"

namespace aegis
{

#if (AEGIS_HAS_STD_SHARED_MUTEX == 1)
using shared_mutex = std::shared_mutex;
#else
using shared_mutex = std::shared_timed_mutex;
#endif

using json = nlohmann::json;

using channel_type = gateway::objects::channel::channel_type;

#pragma region rest params
struct create_message_t
{
    create_message_t & user_id(snowflake param) { _user_id = param; return *this; }

    create_message_t & content(const std::string & param) { _content = param; return *this; }
    create_message_t & embed(const json & param) { _embed = param; return *this; }
    create_message_t & nonce(int64_t param) { _nonce = param; return *this; }
    create_message_t & file(rest::aegis_file file)
    {
        this->_file.emplace(std::move(file));
        return *this;
    }
    snowflake _user_id;
    std::string _content;
    json _embed;
    int64_t _nonce = 0;
    lib::optional<rest::aegis_file> _file;
};

struct edit_message_t
{
    edit_message_t & message_id(snowflake param) { _message_id = param; return *this; }
    edit_message_t & content(const std::string & param) { _content = param; return *this; }
    edit_message_t & embed(const json & param) { _embed = param; return *this; }
    snowflake _message_id;
    std::string _content;
    json _embed;
};

struct get_messages_t
{
    enum class get_messages_type {
        AROUND,
        BEFORE,
        AFTER,
        LAST
    };
    get_messages_t & message_id(snowflake param) { _message_id = param; return *this; }
    get_messages_t & around() { _type = get_messages_type::AROUND; return *this; }
    get_messages_t & before() { _type = get_messages_type::BEFORE; return *this; }
    get_messages_t & after() { _type = get_messages_type::AFTER; return *this; }
    get_messages_t & limit(int16_t param) { _limit = param; return *this; }
    get_messages_type _type = get_messages_type::LAST;
    snowflake _message_id;
    int16_t _limit;
};

struct modify_channel_t
{
    modify_channel_t & name(const std::string & param) { _name = param; return *this; }
    modify_channel_t & position(int param) { _position = param; return *this; }
    modify_channel_t & topic(const std::string & param) { _topic = param; return *this; }
    modify_channel_t & nsfw(bool param) { _nsfw = param; return *this; }
    modify_channel_t & bitrate(int param) { _bitrate = param; return *this; }
    modify_channel_t & user_limit(int param) { _user_limit = param; return *this; }
    modify_channel_t & permission_overwrites(const std::vector<gateway::objects::permission_overwrite> & param)
    {
        _permission_overwrites = param; return *this;
    }
    modify_channel_t & parent_id(snowflake param) { _parent_id = param; return *this; }
    modify_channel_t & rate_limit_per_user(int param) { _rate_limit_per_user = param; return *this; }
    lib::optional<std::string> _name = {};
    lib::optional<int> _position = {};
    lib::optional<std::string> _topic = {};
    lib::optional<bool> _nsfw = {};
    lib::optional<int> _bitrate = {};
    lib::optional<int> _user_limit = {};
    lib::optional<std::vector<gateway::objects::permission_overwrite>> _permission_overwrites = {};
    lib::optional<snowflake> _parent_id = {};
    lib::optional<int> _rate_limit_per_user = {};
};

struct create_reaction_t
{
    create_reaction_t & message_id(snowflake param) { _message_id = param; return *this; }
    create_reaction_t & emoji_text(const std::string & param) { _emoji_text = param; return *this; }
    snowflake _message_id;
    std::string _emoji_text;
};

struct delete_own_reaction_t
{
    delete_own_reaction_t & message_id(int64_t param) { _message_id = param; return *this; }
    delete_own_reaction_t & emoji_text(const std::string & param) { _emoji_text = param; return *this; }
    snowflake _message_id;
    std::string _emoji_text;
};

struct delete_user_reaction_t
{
    delete_user_reaction_t & message_id(snowflake param) { _message_id = param; return *this; }
    delete_user_reaction_t & emoji_text(const std::string & param) { _emoji_text = param; return *this; }
    delete_user_reaction_t & member_id(snowflake param) { _member_id = param; return *this; }
    snowflake _message_id;
    std::string _emoji_text;
    snowflake _member_id;
};

struct get_reactions_t
{
    get_reactions_t & message_id(snowflake param) { _message_id = param; return *this; }
    get_reactions_t & emoji_text(const std::string & param) { _emoji_text = param; return *this; }
    snowflake _message_id;
    std::string _emoji_text;
};

struct edit_channel_permissions_t
{
    edit_channel_permissions_t & overwrite_id(snowflake param) { _overwrite_id = param; return *this; }
    edit_channel_permissions_t & allow(int64_t param) { _allow = param; return *this; }
    edit_channel_permissions_t & deny(int64_t param) { _deny = param; return *this; }
    edit_channel_permissions_t & type(const std::string & param) { _type = param; return *this; }
    snowflake _overwrite_id;
    int64_t _allow;
    int64_t _deny;
    std::string _type;
};

struct create_channel_invite_t
{
    create_channel_invite_t & max_age(int param) { _max_age = param; return *this; }
    create_channel_invite_t & max_uses(int param) { _max_uses = param; return *this; }
    create_channel_invite_t & temporary(bool param) { _temporary = param; return *this; }
    create_channel_invite_t & unique(bool param) { _unique = param; return *this; }
    lib::optional<int> _max_age;
    lib::optional<int> _max_uses;
    lib::optional<bool> _temporary;
    lib::optional<bool> _unique;
};
#pragma endregion

class channel
{
public:

    AEGIS_DECL channel(const snowflake channel_id, const snowflake guild_id, core * _bot, asio::io_context & _io, ratelimit::ratelimit_mgr & _ratelimit);


    AEGIS_DECL guild & get_guild() const;


    AEGIS_DECL guild & get_guild(std::error_code & ec) const noexcept;

#if !defined(AEGIS_DISABLE_ALL_CACHE)

    std::string get_name() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::string _name = name;
        return std::move(_name);
    }


    gateway::objects::channel::channel_type get_type() const noexcept
    {
        return type;
    }


    AEGIS_DECL permission perms() const noexcept;
#endif


    AEGIS_DECL aegis::future<gateway::objects::message> create_message(const std::string & content, int64_t nonce = 0);


    AEGIS_DECL aegis::future<gateway::objects::message> create_message(create_message_t obj);


    AEGIS_DECL aegis::future<gateway::objects::message> create_message_embed(const std::string & content, const json & embed, int64_t nonce = 0);


    AEGIS_DECL aegis::future<gateway::objects::message> create_message_embed(create_message_t obj);


    AEGIS_DECL aegis::future<gateway::objects::message> get_message(snowflake message_id);


    AEGIS_DECL aegis::future<gateway::objects::messages> get_messages(get_messages_t obj);



    AEGIS_DECL aegis::future<gateway::objects::message> edit_message(snowflake message_id, const std::string & content);


    AEGIS_DECL aegis::future<gateway::objects::message> edit_message(edit_message_t obj);


    AEGIS_DECL aegis::future<gateway::objects::message> edit_message_embed(snowflake message_id, const std::string & content, const json & embed);


    AEGIS_DECL aegis::future<gateway::objects::message> edit_message_embed(edit_message_t obj);


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


    AEGIS_DECL aegis::future<rest::rest_reply> bulk_delete_message(const std::vector<int64_t> & messages);


    AEGIS_DECL aegis::future<rest::rest_reply> bulk_delete_message(const std::vector<snowflake> & messages);


    AEGIS_DECL aegis::future<gateway::objects::channel> modify_channel(lib::optional<std::string> _name = {},
        lib::optional<int> _position = {}, lib::optional<std::string> _topic = {},
        lib::optional<bool> _nsfw = {}, lib::optional<int> _bitrate = {},
        lib::optional<int> _user_limit = {},
        lib::optional<std::vector<gateway::objects::permission_overwrite>> _permission_overwrites = {},
        lib::optional<snowflake> _parent_id = {}, lib::optional<int> _rate_limit_per_user = {});


    AEGIS_DECL aegis::future<gateway::objects::channel> modify_channel(modify_channel_t obj)
    {
        return modify_channel(obj._name, obj._position, obj._topic, obj._nsfw,
            obj._bitrate, obj._user_limit, obj._permission_overwrites,
            obj._parent_id, obj._rate_limit_per_user);
    }


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


    AEGIS_DECL aegis::future<rest::rest_reply> create_reaction(snowflake message_id, const std::string & emoji_text);


    AEGIS_DECL aegis::future<rest::rest_reply> create_reaction(create_reaction_t obj)
    {
        return create_reaction(obj._message_id, obj._emoji_text);
    }


    AEGIS_DECL aegis::future<rest::rest_reply> delete_own_reaction(snowflake message_id, const std::string & emoji_text);


    AEGIS_DECL aegis::future<rest::rest_reply> delete_own_reaction(delete_own_reaction_t obj)
    {
        return delete_own_reaction(obj._message_id, obj._emoji_text);
    }


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


    AEGIS_DECL aegis::future<rest::rest_reply> delete_user_reaction(delete_user_reaction_t obj)
    {
        return delete_user_reaction(obj._message_id, obj._emoji_text, obj._member_id);
    }


    AEGIS_DECL aegis::future<rest::rest_reply> get_reactions(snowflake message_id, const std::string & emoji_text);


    AEGIS_DECL aegis::future<rest::rest_reply> get_reactions(get_reactions_t obj)
    {
        return get_reactions(obj._message_id, obj._emoji_text);
    }


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


    AEGIS_DECL aegis::future<rest::rest_reply> edit_channel_permissions(snowflake _overwrite_id, int64_t _allow, int64_t _deny, const std::string & _type);


    AEGIS_DECL aegis::future<rest::rest_reply> edit_channel_permissions(edit_channel_permissions_t obj)
    {
        return edit_channel_permissions(obj._overwrite_id, obj._allow, obj._deny, obj._type);
    }


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


    AEGIS_DECL aegis::future<rest::rest_reply> create_channel_invite(const lib::optional<int> max_age,
        const lib::optional<int> max_uses,
        const lib::optional<bool> temporary,
        const lib::optional<bool> unique);


    AEGIS_DECL aegis::future<rest::rest_reply> create_channel_invite(create_channel_invite_t obj)
    {
        return create_channel_invite(obj._max_age, obj._max_uses, obj._temporary, obj._unique);
    }


    AEGIS_DECL aegis::future<rest::rest_reply> delete_channel_permission(snowflake overwrite_id);


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


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


    AEGIS_DECL aegis::future<rest::rest_reply> add_pinned_channel_message(snowflake message_id);


    AEGIS_DECL aegis::future<rest::rest_reply> delete_pinned_channel_message(snowflake message_id);


    AEGIS_DECL aegis::future<rest::rest_reply> group_dm_add_recipient(snowflake user_id);


    AEGIS_DECL aegis::future<rest::rest_reply> group_dm_remove_recipient(snowflake user_id);


    aegis::channel * get_parent() const
    {
        return _bot->find_channel(parent_id);
    }


    aegis::snowflake get_parent_id() const noexcept
    {
        return parent_id;
    }


    snowflake get_id() const noexcept
    {
        return channel_id;
    }


    snowflake get_guild_id() const noexcept
    {
        return guild_id;
    }


    bool is_dm() const noexcept
    {
        return _guild == nullptr;
    }


    shared_mutex & mtx() const noexcept
    {
        return _m;
    }

#if !defined(AEGIS_DISABLE_ALL_CACHE)

    bool nsfw() const noexcept
    {
        return _nsfw;
    }
#endif

private:
    friend class guild;
    friend class core;

    AEGIS_DECL void _load_with_guild(guild & _guild, const json & obj, shards::shard * _shard);

    AEGIS_DECL void _load_with_guild_nolock(guild & _guild, const json & obj, shards::shard * _shard);

    snowflake channel_id; 
    snowflake guild_id; 
    guild * _guild; 
    snowflake parent_id; 
#if !defined(AEGIS_DISABLE_ALL_CACHE)
    snowflake last_message_id = 0; 
    std::string name; 
    std::string topic; 
    bool _nsfw = false;
    uint32_t position = 0; 
    gateway::objects::channel::channel_type type = gateway::objects::channel::channel_type::Text; 
    uint16_t bitrate = 0; 
    uint16_t user_limit = 0; 
    std::unordered_map<int64_t, gateway::objects::permission_overwrite> overrides; 
    uint16_t rate_limit_per_user = 0; 
#endif
    asio::io_context & _io_context;
    mutable shared_mutex _m;
    core * _bot = nullptr;
    ratelimit::ratelimit_mgr & _ratelimit;
};

}