guild.hpp

//
// guild.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/utility.hpp"
#include "aegis/gateway/objects/role.hpp"
#include "aegis/snowflake.hpp"
#include "aegis/rest/rest_reply.hpp"
#include "aegis/ratelimit/ratelimit.hpp"
#include "aegis/gateway/objects/permission_overwrite.hpp"
#include "aegis/gateway/objects/member.hpp"
#include <future>
#include <asio.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;

#pragma region rest params
struct modify_guild_t
{
    modify_guild_t & name(const std::string & param) { _name = param; return *this; }
    modify_guild_t & voice_region(const std::string & param) { _voice_region = param; return *this; }
    modify_guild_t & verification_level(int param) { _verification_level = param; return *this; }
    modify_guild_t & default_message_notifications(int param) { _default_message_notifications = param; return *this; }
    modify_guild_t & explicit_content_filter(int param) { _explicit_content_filter = param; return *this; }
    modify_guild_t & afk_channel_id(snowflake param) { _afk_channel_id = param; return *this; }
    modify_guild_t & afk_timeout(int param) { _afk_timeout = param; return *this; }
    modify_guild_t & icon(const std::string & param) { _icon = param; return *this; }
    modify_guild_t & owner_id(snowflake param) { _owner_id = param; return *this; }
    modify_guild_t & splash(const std::string & param) { _splash = param; return *this; }

    lib::optional<std::string> _name;
    lib::optional<std::string> _voice_region;
    lib::optional<int> _verification_level;
    lib::optional<int> _default_message_notifications;
    lib::optional<int> _explicit_content_filter;
    lib::optional<snowflake> _afk_channel_id;
    lib::optional<int> _afk_timeout;
    lib::optional<std::string> _icon;
    lib::optional<snowflake> _owner_id;
    lib::optional<std::string> _splash;
};

struct create_text_channel_t
{
    create_text_channel_t & name(const std::string & param) { _name = param; return *this; }
    create_text_channel_t & parent_id(int64_t param) { _parent_id = param; return *this; }
    create_text_channel_t & nsfw(bool param) { _nsfw = param; return *this; }
    create_text_channel_t & permission_overwrites(const std::vector<gateway::objects::permission_overwrite> & param)
    { _permission_overwrites = param; return *this; }
    std::string _name;
    int64_t _parent_id = 0;
    bool _nsfw = false;
    std::vector<gateway::objects::permission_overwrite> _permission_overwrites;
};

struct create_voice_channel_t
{
    create_voice_channel_t & name(const std::string param) { _name = param; return *this; }
    create_voice_channel_t & bitrate(int32_t param) { _bitrate = param; return *this; }
    create_voice_channel_t & user_limit(int32_t param) { _user_limit = param; return *this; }
    create_voice_channel_t & parent_id(int64_t param) { _parent_id = param; return *this; }
    create_voice_channel_t & permission_overwrites(const std::vector<gateway::objects::permission_overwrite> & param)
    { _permission_overwrites = param; return *this; }
    std::string _name;
    int32_t _bitrate = 0;
    int32_t _user_limit = 0;
    int64_t _parent_id = 0;
    std::vector<gateway::objects::permission_overwrite> _permission_overwrites;
};

struct create_category_channel_t
{
    create_category_channel_t & name(const std::string & param) { _name = param; return *this; }
    create_category_channel_t & parent_id(int64_t param) { _parent_id = param; return *this; }
    create_category_channel_t & permission_overwrites(const std::vector<gateway::objects::permission_overwrite> & param)
    { _permission_overwrites = param; return *this; }
    std::string _name;
    int64_t _parent_id = 0;
    std::vector<gateway::objects::permission_overwrite> _permission_overwrites;
};

struct modify_guild_member_t
{
    modify_guild_member_t & user_id(snowflake param) { _user_id = param; return *this; }
    modify_guild_member_t & nick(const std::string & param) { _nick = param; return *this; }
    modify_guild_member_t & mute(bool param) { _mute = param; return *this; }
    modify_guild_member_t & deaf(bool param) { _deaf = param; return *this; }
    modify_guild_member_t & roles(const std::vector<snowflake> & param) { _roles = param; return *this; }
    modify_guild_member_t & channel_id(snowflake param) { _channel_id = param; return *this; }
    snowflake _user_id;
    lib::optional<std::string> _nick;
    lib::optional<bool> _mute;
    lib::optional<bool> _deaf;
    lib::optional<std::vector<snowflake>> _roles;
    lib::optional<snowflake> _channel_id;
};

struct create_guild_ban_t
{
    create_guild_ban_t & user_id(snowflake param) { _user_id = param; return *this; }
    create_guild_ban_t & delete_message_days(int8_t param) { _delete_message_days = param; return *this; }
    create_guild_ban_t & reason(const std::string & param) { _reason = param; return *this; }
    snowflake _user_id;
    int8_t _delete_message_days;
    std::string _reason;
};

struct create_guild_role_t
{
    create_guild_role_t & name(const std::string & param) { _name = param; return *this; }
    create_guild_role_t & perms(permission param) { _perms = param; return *this; }
    create_guild_role_t & color(int32_t param) { _color = param; return *this; }
    create_guild_role_t & hoist(bool param) { _hoist = param; return *this; }
    create_guild_role_t & mentionable(bool param) { _mentionable = param; return *this; }
    std::string _name;
    permission _perms;
    int32_t _color = 0;
    bool _hoist = false;
    bool _mentionable = false;
};

struct modify_guild_role_t
{
    modify_guild_role_t & role_id(snowflake param) { _role_id = param; return *this; }
    modify_guild_role_t & name(const std::string & param) { _name = param; return *this; }
    modify_guild_role_t & perms(permission param) { _perms = param; return *this; }
    modify_guild_role_t & color(int32_t param) { _color = param; return *this; }
    modify_guild_role_t & hoist(bool param) { _hoist = param; return *this; }
    modify_guild_role_t & mentionable(bool param) { _mentionable = param; return *this; }
    snowflake _role_id;
    std::string _name;
    permission _perms;
    int32_t _color = 0;
    bool _hoist = false;
    bool _mentionable = false;
};
#pragma endregion

class guild
{
public:

    AEGIS_DECL explicit guild(const int32_t _shard_id, const snowflake _id, core * _bot, asio::io_context & _io);

    AEGIS_DECL ~guild();

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

    int32_t shard_id; /*< shard that receives this guild's messages */
    snowflake guild_id; /*< snowflake of this guild */

#if !defined(AEGIS_DISABLE_ALL_CACHE)

    permission perms()
    {
        return permission(base_permissions(self()));
    }


    AEGIS_DECL user * self() const;


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


    std::string get_icon() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::string _icon = icon;
        return std::move(_icon);
    }


    std::string get_splash() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::string _splash = splash;
        return std::move(_splash);
    }


    std::string get_region() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::string _region = region;
        return std::move(_region);
    }


    AEGIS_DECL bool member_has_role(snowflake member_id, snowflake role_id) const noexcept;


    AEGIS_DECL int32_t get_member_count() const noexcept;


    AEGIS_DECL permission get_permissions(snowflake member_id, snowflake channel_id) const;


    AEGIS_DECL permission get_permissions(const user * _member, const channel * _channel) const;


    int64_t base_permissions() const
    {
        std::shared_lock<shared_mutex> l(_m);
        return base_permissions(self());
    }


    int64_t base_permissions(const user * _member) const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        return base_permissions(*_member);
    }


    AEGIS_DECL int64_t base_permissions(const user & _member) const noexcept;


    AEGIS_DECL int64_t compute_overwrites(const int64_t _base_permissions, const user & _member, const channel & _channel) const noexcept;


    AEGIS_DECL const gateway::objects::role get_role(const int64_t r) const;


    AEGIS_DECL const snowflake get_owner() const noexcept;
#endif


    snowflake get_id() const noexcept
    {
        return guild_id;
    }


    AEGIS_DECL channel * get_channel(snowflake id) const noexcept;


    AEGIS_DECL aegis::future<gateway::objects::guild> get_guild();


    AEGIS_DECL aegis::future<gateway::objects::guild> modify_guild(
        lib::optional<std::string> name = {},
        lib::optional<std::string> voice_region = {}, lib::optional<int> verification_level = {},
        lib::optional<int> default_message_notifications = {}, lib::optional<int> explicit_content_filter = {},
        lib::optional<snowflake> afk_channel_id = {}, lib::optional<int> afk_timeout = {},
        lib::optional<std::string> icon = {}, lib::optional<snowflake> owner_id = {},
        lib::optional<std::string> splash = {}
    );


    AEGIS_DECL aegis::future<gateway::objects::guild> modify_guild(modify_guild_t obj)
    {
        return modify_guild(obj._name, obj._voice_region, obj._verification_level, obj._default_message_notifications,
                            obj._explicit_content_filter, obj._afk_channel_id, obj._afk_timeout, obj._icon,
                            obj._owner_id, obj._splash);
    }


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


    AEGIS_DECL aegis::future<gateway::objects::channel> create_text_channel(const std::string & name, int64_t parent_id = 0, bool nsfw = false,
                                            const std::vector<gateway::objects::permission_overwrite> & permission_overwrites = {});
    

    AEGIS_DECL aegis::future<gateway::objects::channel> create_text_channel(create_text_channel_t obj)
    {
        return create_text_channel(obj._name, obj._parent_id, obj._nsfw, obj._permission_overwrites);
    }


    AEGIS_DECL aegis::future<gateway::objects::channel> create_voice_channel(const std::string & name, int32_t bitrate = 0, int32_t user_limit = 0, int64_t parent_id = 0,
                                             const std::vector<gateway::objects::permission_overwrite> & permission_overwrites = {});


    AEGIS_DECL aegis::future<gateway::objects::channel> create_voice_channel(create_voice_channel_t obj)
    {
        return create_voice_channel(obj._name, obj._bitrate, obj._user_limit, obj._parent_id, obj._permission_overwrites);
    }


    AEGIS_DECL aegis::future<gateway::objects::channel> create_category_channel(const std::string & name, int64_t parent_id,
                                                const std::vector<gateway::objects::permission_overwrite> & permission_overwrites);


    AEGIS_DECL aegis::future<gateway::objects::channel> create_category_channel(create_category_channel_t obj)
    {
        return create_category_channel(obj._name, obj._parent_id, obj._permission_overwrites);
    }


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


    AEGIS_DECL aegis::future<gateway::objects::member> modify_guild_member(snowflake user_id, lib::optional<std::string> nick, lib::optional<bool> mute,
                                            lib::optional<bool> deaf, lib::optional<std::vector<snowflake>> roles,
                                            lib::optional<snowflake> channel_id);


    AEGIS_DECL aegis::future<gateway::objects::member> modify_guild_member(modify_guild_member_t obj)
    {
        return modify_guild_member(obj._user_id, obj._nick, obj._mute, obj._deaf, obj._roles, obj._channel_id);
    }


    AEGIS_DECL aegis::future<rest::rest_reply> modify_my_nick(const std::string & newname);


    AEGIS_DECL aegis::future<gateway::objects::role> add_guild_member_role(snowflake user_id, snowflake role_id);


    AEGIS_DECL aegis::future<rest::rest_reply> remove_guild_member_role(snowflake user_id, snowflake role_id);


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


    AEGIS_DECL aegis::future<rest::rest_reply> create_guild_ban(snowflake user_id, int8_t delete_message_days = 0, const std::string & reason = "");


    AEGIS_DECL aegis::future<rest::rest_reply> create_guild_ban(create_guild_ban_t obj)
    {
        return create_guild_ban(obj._user_id, obj._delete_message_days, obj._reason);
    }


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


    AEGIS_DECL aegis::future<gateway::objects::role> create_guild_role(const std::string & name, permission _perms, int32_t color, bool hoist, bool mentionable);


    AEGIS_DECL aegis::future<gateway::objects::role> create_guild_role(create_guild_role_t obj)
    {
        return create_guild_role(obj._name, obj._perms, obj._color, obj._hoist, obj._mentionable);
    }


    AEGIS_DECL aegis::future<rest::rest_reply> modify_guild_role_positions(snowflake role_id, int16_t position);


    AEGIS_DECL aegis::future<gateway::objects::role> modify_guild_role(snowflake role_id, const std::string & name, permission _perms, int32_t color,
                                          bool hoist, bool mentionable);


    AEGIS_DECL aegis::future<gateway::objects::role> modify_guild_role(modify_guild_role_t obj)
    {
        return modify_guild_role(obj._role_id, obj._name, obj._perms, obj._color, obj._hoist, obj._mentionable);
    }


    AEGIS_DECL aegis::future<rest::rest_reply> delete_guild_role(snowflake role_id);


    AEGIS_DECL aegis::future<rest::rest_reply> get_guild_prune_count(int16_t days);


    AEGIS_DECL aegis::future<rest::rest_reply> begin_guild_prune(int16_t days);


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


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


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


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


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


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


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


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


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


    AEGIS_DECL core & get_bot() const noexcept;


    AEGIS_DECL user * find_member(snowflake member_id) const noexcept;


    AEGIS_DECL channel * find_channel(snowflake channel_id) const noexcept;


    AEGIS_DECL channel * find_channel(std::string channel_name) const noexcept;


    AEGIS_DECL lib::optional<gateway::objects::role> find_role(snowflake role_id) const noexcept;


    AEGIS_DECL lib::optional<gateway::objects::role> find_role(std::string role_name) const noexcept;


    std::unordered_map<snowflake, channel*> get_channels() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::unordered_map<snowflake, channel*> _list = channels;
        return std::move(_list);
    }

#if !defined(AEGIS_DISABLE_ALL_CACHE)

    std::unordered_map<snowflake, user*> get_members() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::unordered_map<snowflake, user*> _list = members;
        return std::move(_list);
    }


    std::unordered_map<snowflake, gateway::objects::role> get_roles() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::unordered_map<snowflake, gateway::objects::role> _list = roles;
        return std::move(_list);
    }


    std::unordered_map<snowflake, gateway::objects::voice_state> get_voicestates() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::unordered_map<snowflake, gateway::objects::voice_state> _list = voice_states;
        return std::move(_list);
    }


    const std::unordered_map<snowflake, user*> & get_members_nocopy() const noexcept
    {
        return members;
    }


    const std::unordered_map<snowflake, gateway::objects::role> & get_roles_nocopy() const noexcept
    {
        return roles;
    }
#endif


    const std::unordered_map<snowflake, channel*> & get_channels_nocopy() const noexcept
    {
        return channels;
    }

    shared_mutex & mtx()
    {
        return _m;
    }

private:
    friend class core;
    friend class user;

    std::unordered_map<snowflake, channel*> channels; 
#if !defined(AEGIS_DISABLE_ALL_CACHE)
    std::unordered_map<snowflake, user*> members; 
    std::unordered_map<snowflake, gateway::objects::role> roles; 
    std::unordered_map<snowflake, gateway::objects::emoji> emojis; 
    std::unordered_map<snowflake, gateway::objects::voice_state> voice_states; 
#endif

#if !defined(AEGIS_DISABLE_ALL_CACHE)
    AEGIS_DECL void _add_member(user * _member) noexcept;

    AEGIS_DECL void _add_member_nolock(user * _member) noexcept;

    AEGIS_DECL void _remove_member(snowflake member_id) noexcept;

    AEGIS_DECL void _load_presence(const json & obj) noexcept;

    AEGIS_DECL void _load_emoji(const json & obj) noexcept;

    AEGIS_DECL void _load_role(const json & obj) noexcept;

    AEGIS_DECL void _remove_role(snowflake role_id) noexcept;

    AEGIS_DECL void _load_voicestate(const json & obj) noexcept;
#endif

    AEGIS_DECL void _load(const json & obj, shards::shard * _shard) noexcept;

    AEGIS_DECL user * _find_member(snowflake member_id) const noexcept;
    
    AEGIS_DECL channel * _find_channel(snowflake channel_id) const noexcept;

    AEGIS_DECL void _remove_channel(snowflake channel_id) noexcept;

#if !defined(AEGIS_DISABLE_ALL_CACHE)
    std::string name;
    std::string icon;
    std::string splash;
    snowflake owner_id = 0;
    std::string region;
    snowflake afk_channel_id = 0;
    uint32_t afk_timeout = 0;//in seconds
    bool embed_enabled = false;
    snowflake embed_channel_id = 0;
    uint32_t verification_level = 0;
    uint32_t default_message_notifications = 0;
    uint32_t mfa_level = 0;
    std::string joined_at;
    bool large = false;
    bool unavailable = false;
    uint32_t member_count = 0;
    //std::string m_voice_states;//this is really an array
    bool is_init = true;
#endif
    core * _bot;
    asio::io_context & _io_context;
    mutable shared_mutex _m;
};

}