user.hpp

//
// user.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"
#if !defined(AEGIS_DISABLE_ALL_CACHE)
#include "aegis/snowflake.hpp"
#include "aegis/gateway/objects/presence.hpp"
#include "aegis/fwd.hpp"
#include <nlohmann/json.hpp>
#include <string>
#include <queue>
#include <memory>
#include <set>
#include <shared_mutex>

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;

class user
{
public:
    using presence = aegis::gateway::objects::presence;
  
    explicit user(snowflake id) : _member_id(id) {}

    struct guild_info
    {
        guild_info(snowflake _id) : id(_id) {};
        snowflake id;
        std::vector<snowflake> roles;
        lib::optional<std::string> nickname;
        uint64_t joined_at = 0;
        bool deaf = false;
        bool mute = false;
    };


    AEGIS_DECL std::string get_name(snowflake guild_id) noexcept;


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


    uint16_t get_discriminator() const noexcept
    {
        return _discriminator;
    }


    std::string get_avatar() const noexcept
    {
        std::shared_lock<shared_mutex> l(_m);
        std::string t_avatar = _avatar;
        return std::move(t_avatar);
    }


    bool is_bot() const noexcept
    {
        return _is_bot;
    }


    bool is_mfa_enabled() const noexcept
    {
        return _mfa_enabled;
    }


    AEGIS_DECL std::string get_mention() const noexcept;

    AEGIS_DECL guild_info & get_guild_info(snowflake guild_id) noexcept;

    AEGIS_DECL guild_info & get_guild_info_nolock(snowflake guild_id) noexcept;

    AEGIS_DECL guild_info * get_guild_info_nocreate(snowflake guild_id) const noexcept;


    AEGIS_DECL std::string get_full_name() const noexcept;


    snowflake get_id() const noexcept
    {
        return _member_id;
    }


    bool has_dm() const noexcept
    {
        return !!get_dm_id();
    }


    snowflake get_dm_id() const noexcept
    {
        return _dm_id;
    }


    void set_dm_id(snowflake _id) noexcept
    {
        _dm_id = _id;
    }


    shared_mutex & mtx() noexcept
    {
        return _m;
    }

private:
    friend class core;
    friend class guild;
    friend class gateway::objects::message;

    AEGIS_DECL void _load_data(gateway::objects::user mbr);

    snowflake _member_id = 0;
    snowflake _dm_id = 0;
    presence::user_status _status = presence::user_status::Offline; 
    std::string _name; 
    uint16_t _discriminator = 0; 
    std::string _avatar; 
    bool _is_bot = false; 
    bool _mfa_enabled = false; 
    std::vector<std::unique_ptr<guild_info>> guilds; 
    mutable shared_mutex _m;

    AEGIS_DECL void _load(guild * _guild, const json & obj, shards::shard * _shard, bool self_add = true);

    AEGIS_DECL void _load_nolock(guild * _guild, const json & obj, shards::shard * _shard, bool self_add = true, bool guild_lock = true);

    AEGIS_DECL guild_info & _join(snowflake guild_id);

    AEGIS_DECL guild_info & _join_nolock(snowflake guild_id);

    void leave(snowflake guild_id)
    {
        std::unique_lock<shared_mutex> l(mtx());
        guilds.erase(std::find_if(std::begin(guilds), std::end(guilds), [&guild_id](const std::unique_ptr<guild_info> & gi)
        {
            if (gi->id == guild_id)
                return true;
            return false;
        }));
    }
};

}

#else

namespace aegis
{

class user
{
public:
    enum member_status
    {
        Offline,
        Online,
        Idle,
        DoNotDisturb
    };
};

}
#endif