Base.hpp

Go to the documentation of this file.

/*
    MIT License
 
    DiscordCoreAPI, A bot library for Discord, written in C++, and featuring explicit multithreading through the usage of custom, asynchronous C++ CoRoutines.
 
    Copyright 2022, 2023 Chris M. (RealTimeChris)
 
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
*/
/// Base.hpp - Header for the some of the base definitions and includes.
/// Nov 8, 2021
/// https://discordcoreapi.com
/// \file Base.hpp
#pragma once
 
#if !defined(__GNUC__)
    #pragma warning(disable : 4710)
    #pragma warning(disable : 4711)
    #pragma warning(disable : 4251)
    #pragma warning(disable : 4371)
    #pragma warning(disable : 4514)
    #pragma warning(disable : 4623)
    #pragma warning(disable : 4625)
    #pragma warning(disable : 4626)
    #pragma warning(disable : 4820)
    #pragma warning(disable : 5267)
    #pragma warning(disable : 5026)
    #pragma warning(disable : 5027)
    #pragma warning(disable : 5045)
    #pragma warning(disable : 5246)
#endif
 
#if defined _WIN32
    #if !defined DiscordCoreAPI_EXPORTS_NOPE
        #if defined DiscordCoreAPI_EXPORTS
            #if !defined DiscordCoreAPI_Dll
                #define DiscordCoreAPI_Dll __declspec(dllexport)
            #endif
        #else
            #if !defined DiscordCoreAPI_Dll
                #define DiscordCoreAPI_Dll __declspec(dllimport)
            #endif
        #endif
    #else
        #define DiscordCoreAPI_Dll
    #endif
    #if !defined WIN32_LEAN_AND_MEAN
        #define WIN32_LEAN_AND_MEAN
    #endif
    #if !defined WINRT_LEAN_AND_MEAN
        #define WINRT_LEAN_AND_MEAN
    #endif
    #if !defined(NOMINMAX)
        #define NOMINMAX
    #endif
    #include <chrono>
inline std::tm getCurrentTimeVal(time_t& result) {
    std::tm resultTwo{};
    localtime_s(&resultTwo, &result);
    return resultTwo;
}
    #include <WinSock2.h>
#else
    #if !defined DiscordCoreAPI_Dll
        #define DiscordCoreAPI_Dll
    #endif
    #include <arpa/inet.h>
    #include <sys/time.h>
    #include <pthread.h>
    #include <cstdint>
    #include <cstring>
    #include <time.h>
    #include <ctime>
inline std::tm getCurrentTimeVal(time_t& result) {
    std::tm resultTwo{ *localtime(&result) };
    return resultTwo;
}
#endif
 
#include <jsonifier/Index.hpp>
 
#include <source_location>
#include <shared_mutex>
#include <immintrin.h>
#include <functional>
#include <semaphore>
#include <concepts>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <vector>
#include <atomic>
#include <random>
#include <string>
#include <thread>
#include <mutex>
#include <queue>
#include <array>
 
using namespace std::literals;
 
/**
 * \defgroup main_endpoints Main Endpoints
/// @brief For all of the discord api's endpoints.
 */
 
/**
 * \defgroup voice_connection Voice Connection
/// @brief For all of the voice connection related stuff.
 */
 
/**
 * \defgroup discord_events Discord Events
/// @brief For all of the events that could be sent by the discord api.
 */
 
/**
 * \defgroup utilities Utilities
/// @brief For utility classes/functions.
 */
 
/**
 * \defgroup foundation_entities Foundation Entities
/// @brief For all of the building blocks of the main endpoints.
 */
 
/**
 * \defgroup discord_events Discord Events
/// @brief For all of events that could be sent by discord's websockets.
 */
 
/**
 * \defgroup discord_core_internal DiscordCoreInternal
/// @brief For all of the internal api stuff.
 */
 
/**
 * @brief The main namespace for the forward-facing interfaces.
 *
 * \ingroup discord_core_api
 */
 
namespace discord_core_api {
 
    extern thread_local jsonifier::jsonifier_core parser;
 
    template<typename value_type> using stop_watch = jsonifier_internal::stop_watch<value_type>;
    using sys_clock                                = std::chrono::system_clock;
    using hrclock                                  = std::chrono::high_resolution_clock;
    using milliseconds                             = std::chrono::duration<int64_t, std::milli>;
    using microseconds                             = std::chrono::duration<int64_t, std::micro>;
    using nanoseconds                              = std::chrono::duration<int64_t, std::nano>;
    using seconds                                  = std::chrono::duration<int64_t, std::ratio<1, 1>>;
 
    enum class print_message_type {
        general   = 0,
        https     = 1,
        websocket = 2,
    };
 
    inline constexpr jsonifier::string_view shiftToBrightGreen() {
        return "\033[1;40;92m";
    }
 
    inline constexpr jsonifier::string_view shiftToBrightBlue() {
        return "\033[1;40;96m";
    }
 
    inline constexpr jsonifier::string_view shiftToBrightRed() {
        return "\033[1;40;91m";
    }
 
    inline constexpr jsonifier::string_view reset() {
        return "\033[0m";
    }
 
    /**
     * \addtogroup utilities
     * @{
     */
 
    /// @brief Class for printing different types of messages to output and error streams.
    class message_printer {
      public:
        inline message_printer() = default;
 
        /// @brief Initialize the message_printer with configuration settings and output/error streams.
        /// @tparam value_type the type containing configuration settings.
        /// @param other an instance of value_type with configuration settings.
        template<typename value_type> inline static void initialize(const value_type& other) {
            doWePrintGeneralErrors.store(other.doWePrintGeneralErrorMessages(), std::memory_order_release);
            doWePrintGeneralSuccesses.store(other.doWePrintGeneralSuccessMessages(), std::memory_order_release);
            doWePrintHttpsErrors.store(other.doWePrintHttpsErrorMessages(), std::memory_order_release);
            doWePrintHttpsSuccesses.store(other.doWePrintHttpsSuccessMessages(), std::memory_order_release);
            doWePrintWebSocketErrors.store(other.doWePrintWebSocketErrorMessages(), std::memory_order_release);
            doWePrintWebSocketSuccesses.store(other.doWePrintWebSocketSuccessMessages(), std::memory_order_release);
            outputStream = other.getOutputStream();
            errorStream  = other.getErrorStream();
        }
 
        /// @brief Print an error message of the specified type.
        /// @tparam messageType the type of message to print.
        /// @param what the error message.
        /// @param where the source location where the error occurred (default: current source location).
        template<print_message_type messageType, typename string_type>
        inline static void printError(const string_type& what, std::source_location where = std::source_location::current()) {
            switch (messageType) {
                case print_message_type::general: {
                    if (doWePrintGeneralErrors.load(std::memory_order_acquire)) {
                        std::unique_lock lock{ accessMutex };
                        *errorStream << shiftToBrightRed() << "General error, caught at: " << where.file_name() << ", " << where.line() << ":" << where.column()
                                     << ", in: " << where.function_name() << ", it is: " << what << std::endl
                                     << reset() << std::endl;
                    }
                    break;
                }
                case print_message_type::websocket: {
                    if (doWePrintWebSocketErrors.load(std::memory_order_acquire)) {
                        std::unique_lock lock{ accessMutex };
                        *errorStream << shiftToBrightRed() << "WebSocket error, caught at: " << where.file_name() << ", " << where.line() << ":" << where.column()
                                     << ", in: " << where.function_name() << ", it is: " << what << std::endl
                                     << reset() << std::endl;
                    }
                    break;
                }
                case print_message_type::https: {
                    if (doWePrintHttpsErrors.load(std::memory_order_acquire)) {
                        std::unique_lock lock{ accessMutex };
                        *errorStream << shiftToBrightRed() << "Https error, caught at: " << where.file_name() << ", " << where.line() << ":" << where.column()
                                     << ", in: " << where.function_name() << ", it is: " << what << std::endl
                                     << reset() << std::endl;
                    }
                    break;
                }
            }
        }
 
        /// @brief Print a success message of the specified type.
        /// @tparam messageType the type of message to print.
        /// @param what the success message.
        /// @param where the source location where the success occurred (default: current source location).
        template<print_message_type messageType, typename string_type>
        inline static void printSuccess(const string_type& what, std::source_location where = std::source_location::current()) {
            switch (messageType) {
                case print_message_type::general: {
                    if (doWePrintGeneralSuccesses.load(std::memory_order_acquire)) {
                        std::unique_lock lock{ accessMutex };
                        *outputStream << shiftToBrightBlue() << "General success, caught at: " << where.file_name() << ", " << where.line() << ":" << where.column()
                                      << ", in: " << where.function_name() << ", it is: " << what << std::endl
                                      << reset() << std::endl;
                    }
                    break;
                }
                case print_message_type::websocket: {
                    if (doWePrintWebSocketSuccesses.load(std::memory_order_acquire)) {
                        std::unique_lock lock{ accessMutex };
                        *outputStream << shiftToBrightGreen() << "WebSocket success, caught at: " << where.file_name() << ", " << where.line() << ":" << where.column()
                                      << ", in: " << where.function_name() << ", it is: " << what << std::endl
                                      << reset() << std::endl;
                    }
                    break;
                }
                case print_message_type::https: {
                    if (doWePrintHttpsSuccesses.load(std::memory_order_acquire)) {
                        std::unique_lock lock{ accessMutex };
                        *outputStream << shiftToBrightGreen() << "Https success, caught at: " << where.file_name() << ", " << where.line() << ":" << where.column()
                                      << ", in: " << where.function_name() << ", it is: " << what << std::endl
                                      << reset() << std::endl;
                    }
                    break;
                }
            }
        }
 
      protected:
        inline static std::atomic_bool doWePrintHttpsSuccesses{};///< Flag to control printing of https success messages.
        inline static std::atomic_bool doWePrintHttpsErrors{};///< Flag to control printing of https error messages.
        inline static std::atomic_bool doWePrintWebSocketSuccesses{};///< Flag to control printing of websocket success messages.
        inline static std::atomic_bool doWePrintWebSocketErrors{};///< Flag to control printing of websocket error messages.
        inline static std::atomic_bool doWePrintGeneralSuccesses{};///< Flag to control printing of general success messages.
        inline static std::atomic_bool doWePrintGeneralErrors{};///< Flag to control printing of general error messages.
        inline static std::ostream* outputStream{};///< Pointer to the output stream for message printing.
        inline static std::ostream* errorStream{};///< Pointer to the error stream for message printing.
        inline static std::mutex accessMutex{};///< Mutex for thread-safe access to shared resources.
    };
 
    /// @brief Time formatting methods.
    enum class time_format : char {
        long_date       = 'D',///< "20 April 2021" - Long Date
        long_date_time  = 'F',///< "Tuesday, 20 April 2021 16:20" - Long Date/Time
        long_time       = 'T',///< "16:20:30" - Long Time
        short_date      = 'd',///< "20/04/2021" - Short Date
        short_date_time = 'f',///< "20 April 2021 16:20" - Short Date/Time
        short_time      = 't',///< "16:20" - Short Time
    };
 
    class time_stamp;
 
    /// @brief A base class for handling time stamps and conversions.
    /// @tparam value_type the value type to be used with the time stamp.
    template<typename value_type> class time_stamp_base {
      public:
        /// @brief Checks if the time stamp is equal to a string representation.
        /// @param other the string to compare with.
        /// @return true if equal, false otherwise.
        inline bool operator==(jsonifier::string_view other) const {
            return static_cast<jsonifier::string>(*static_cast<const value_type*>(this)) == other;
        }
 
        /// @brief Converts given time values into a future iso8601 time stamp.
        /// @param minutesToAdd number of minutes to add.
        /// @param hoursToAdd number of hours to add.
        /// @param daysToAdd number of days to add.
        /// @param monthsToAdd number of months to add.
        /// @param yearsToAdd number of years to add.
        /// @param timeFormat format for the resulting time stamp.
        /// @return iso8601 time stamp string.
        inline static jsonifier::string convertToFutureISO8601TimeStamp(uint64_t minutesToAdd, uint64_t hoursToAdd, uint64_t daysToAdd, uint64_t monthsToAdd, uint64_t yearsToAdd,
            time_format timeFormat) {
            std::time_t result = std::time(nullptr);
            static constexpr uint64_t secondsPerMinute{ 60ULL };
            static constexpr uint64_t minutesPerHour{ 60ULL };
            static constexpr uint64_t secondsPerHour{ minutesPerHour * secondsPerMinute };
            static constexpr uint64_t hoursPerDay{ 24ULL };
            static constexpr uint64_t secondsPerDay{ secondsPerHour * hoursPerDay };
            static constexpr uint64_t daysPerMonth{ 30ULL };
            static constexpr uint64_t secondsPerMonth{ secondsPerDay * daysPerMonth };
            static constexpr uint64_t daysPerYear{ 365ULL };
            static constexpr uint64_t secondsPerYear{ secondsPerDay * daysPerYear };
            uint64_t secondsToAdd = (yearsToAdd * secondsPerYear) + (monthsToAdd * secondsPerMonth) + (daysToAdd * secondsPerDay) + ((hoursToAdd + 8) * secondsPerHour) +
                (minutesToAdd * secondsPerMinute);
            result += secondsToAdd;
            std::tm resultTwo{ getCurrentTimeVal(result) };
            jsonifier::string returnString{};
            if (resultTwo.tm_isdst) {
                if (resultTwo.tm_hour + 4ULL >= 24) {
                    resultTwo.tm_hour = resultTwo.tm_hour - 24;
                    ++resultTwo.tm_mday;
                }
                auto newValue =
                    getTimeSinceEpoch(static_cast<uint64_t>(resultTwo.tm_year) + 1900ULL, static_cast<uint64_t>(resultTwo.tm_mon) + 1ULL, static_cast<uint64_t>(resultTwo.tm_mday),
                        static_cast<uint64_t>(resultTwo.tm_hour) + 4ULL, static_cast<uint64_t>(resultTwo.tm_min), static_cast<uint64_t>(resultTwo.tm_sec));
                returnString = getISO8601TimeStamp(timeFormat, newValue);
            } else {
                if (resultTwo.tm_hour + 5ULL >= 24) {
                    resultTwo.tm_hour = resultTwo.tm_hour - 24;
                    ++resultTwo.tm_mday;
                }
                auto newValue =
                    getTimeSinceEpoch(static_cast<uint64_t>(resultTwo.tm_year) + 1900ULL, static_cast<uint64_t>(resultTwo.tm_mon) + 1ULL, static_cast<uint64_t>(resultTwo.tm_mday),
                        static_cast<uint64_t>(resultTwo.tm_hour) + 5ULL, static_cast<uint64_t>(resultTwo.tm_min), static_cast<uint64_t>(resultTwo.tm_sec));
                returnString = getISO8601TimeStamp(timeFormat, newValue);
            }
            return returnString;
        }
 
        /// @brief Converts the current time into an iso8601 time stamp.
        /// @param timeFormat format for the resulting time stamp.
        /// @return iso8601 time stamp string.
        inline static jsonifier::string convertToCurrentISO8601TimeStamp(time_format timeFormat) {
            std::time_t result = std::time(nullptr);
            std::tm resultTwo{ getCurrentTimeVal(result) };
            jsonifier::string returnString{};
            if (resultTwo.tm_isdst) {
                if (resultTwo.tm_hour + 4ULL >= 24) {
                    resultTwo.tm_hour = resultTwo.tm_hour - 24;
                    ++resultTwo.tm_mday;
                }
                auto newValue =
                    getTimeSinceEpoch(static_cast<uint64_t>(resultTwo.tm_year) + 1900ULL, static_cast<uint64_t>(resultTwo.tm_mon) + 1ULL, static_cast<uint64_t>(resultTwo.tm_mday),
                        static_cast<uint64_t>(resultTwo.tm_hour) + 4ULL, static_cast<uint64_t>(resultTwo.tm_min), static_cast<uint64_t>(resultTwo.tm_sec));
                returnString = getISO8601TimeStamp(timeFormat, newValue);
            } else {
                if (resultTwo.tm_hour + 5ULL >= 24) {
                    resultTwo.tm_hour = resultTwo.tm_hour - 24;
                    ++resultTwo.tm_mday;
                }
                auto newValue =
                    getTimeSinceEpoch(static_cast<uint64_t>(resultTwo.tm_year) + 1900ULL, static_cast<uint64_t>(resultTwo.tm_mon) + 1ULL, static_cast<uint64_t>(resultTwo.tm_mday),
                        static_cast<uint64_t>(resultTwo.tm_hour) + 5ULL, static_cast<uint64_t>(resultTwo.tm_min), static_cast<uint64_t>(resultTwo.tm_sec));
                returnString = getISO8601TimeStamp(timeFormat, newValue);
            }
            return returnString;
        }
 
        /// @brief Checks if a certain time duration has elapsed.
        /// @param days number of days for elapsed time.
        /// @param hours number of hours for elapsed time.
        /// @param minutes number of minutes for elapsed time.
        /// @return true if the specified time has elapsed, otherwise false.
        inline bool hasTimeElapsed(int64_t days, int64_t hours, int64_t minutes) const {
            int64_t startTimeRaw{ static_cast<int64_t>(convertTimeStampToTimeUnits(static_cast<jsonifier::string>(*static_cast<const value_type*>(this)))) };
            startTimeRaw =
                std::chrono::current_zone()->to_sys(std::chrono::local_time<std::chrono::milliseconds>(std::chrono::milliseconds{ startTimeRaw })).time_since_epoch().count();
            auto currentTime                          = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
            static constexpr int64_t secondsPerMinute = 60ULL;
            static constexpr int64_t secondsPerHour   = secondsPerMinute * 60ULL;
            static constexpr int64_t secondsPerDay    = secondsPerHour * 24ULL;
            auto targetElapsedTime =
                ((static_cast<int64_t>(days) * secondsPerDay) + ((static_cast<int64_t>(hours)) * secondsPerHour) + (static_cast<int64_t>(minutes) * secondsPerMinute)) * 1000LL;
            auto actualElapsedTime = currentTime - startTimeRaw;
            if (actualElapsedTime <= 0) {
                return false;
            }
            if (actualElapsedTime >= targetElapsedTime) {
                return true;
            } else {
                return false;
            }
        }
 
        /// @brief Converts milliseconds into a human-readable duration string.
        /// @param durationInMs duration in milliseconds to convert.
        /// @return human-readable duration string.
        inline static jsonifier::string convertMsToDurationString(uint64_t durationInMs) {
            jsonifier::string newString{};
            static constexpr uint64_t msPerSecond{ 1000ULL };
            static constexpr uint64_t secondsPerMinute{ 60ULL };
            static constexpr uint64_t minutesPerHour{ 60ULL };
            static constexpr uint64_t msPerMinute{ msPerSecond * secondsPerMinute };
            static constexpr uint64_t msPerHour{ msPerMinute * minutesPerHour };
            uint64_t hoursLeft   = static_cast<uint64_t>(trunc(durationInMs / msPerHour));
            uint64_t minutesLeft = static_cast<uint64_t>(trunc((durationInMs % msPerHour) / msPerMinute));
            uint64_t secondsLeft = static_cast<uint64_t>(trunc(((durationInMs % msPerHour) % msPerMinute) / msPerSecond));
            if (hoursLeft >= 1) {
                newString += jsonifier::toString(hoursLeft) + " hours, ";
                newString += jsonifier::toString(minutesLeft) + " minutes, ";
                newString += jsonifier::toString(secondsLeft) + " seconds.";
            } else if (minutesLeft >= 1) {
                newString += jsonifier::toString(minutesLeft) + " minutes, ";
                newString += jsonifier::toString(secondsLeft) + " seconds.";
            } else {
                newString += jsonifier::toString(secondsLeft) + " seconds.";
            }
            return newString;
        }
 
        /// @brief Gets an iso8601 time stamp string based on the provided time format.
        /// @param timeFormat format for the resulting time stamp.
        /// @param inputTime input time value.
        /// @return iso8601 time stamp string.
        inline static jsonifier::string getISO8601TimeStamp(time_format timeFormat, uint64_t inputTime) {
            uint64_t timeValue = static_cast<uint64_t>(inputTime) / 1000ULL;
            time_t rawTime(static_cast<time_t>(timeValue));
            std::tm resultTwo{ getCurrentTimeVal(rawTime) };
            jsonifier::string timeStamp{};
            timeStamp.resize(48);
            switch (timeFormat) {
                case time_format::long_date: {
                    uint64_t sizeResponse = strftime(timeStamp.data(), 48, "%d %B %G", &resultTwo);
                    timeStamp.resize(sizeResponse);
                    break;
                }
                case time_format::long_date_time: {
                    uint64_t sizeResponse = strftime(timeStamp.data(), 48, "%FT%T", &resultTwo);
                    timeStamp.resize(sizeResponse);
                    break;
                }
                case time_format::long_time: {
                    uint64_t sizeResponse = strftime(timeStamp.data(), 48, "%T", &resultTwo);
                    timeStamp.resize(sizeResponse);
                    break;
                }
                case time_format::short_date: {
                    uint64_t sizeResponse = strftime(timeStamp.data(), 48, "%d/%m/%g", &resultTwo);
                    timeStamp.resize(sizeResponse);
                    break;
                }
                case time_format::short_date_time: {
                    uint64_t sizeResponse = strftime(timeStamp.data(), 48, "%d %B %G %R", &resultTwo);
                    timeStamp.resize(sizeResponse);
                    break;
                }
                case time_format::short_time: {
                    uint64_t sizeResponse = strftime(timeStamp.data(), 48, "%R", &resultTwo);
                    timeStamp.resize(sizeResponse);
                    break;
                }
                default: {
                    break;
                }
            }
            return timeStamp;
        }
 
        /// @brief Gets the time since the unix epoch for the specified date and time.
        /// @param year year.
        /// @param month month.
        /// @param day day.
        /// @param hour hour.
        /// @param minute minute.
        /// @param second second.
        /// @return time since unix epoch in milliseconds.
        inline static uint64_t getTimeSinceEpoch(uint64_t year, uint64_t month, uint64_t day, uint64_t hour, uint64_t minute, uint64_t second) {
            static constexpr uint64_t secondsInJan{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInFeb{ 28 * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInMar{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInApr{ 30ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInMay{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInJun{ 30ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInJul{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInAug{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInSep{ 30ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInOct{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInNov{ 30ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsInDec{ 31ULL * 24ULL * 60ULL * 60ULL };
            static constexpr uint64_t secondsPerMinute{ 60ULL };
            static constexpr uint64_t secondsPerHour{ 60ULL * 60ULL };
            static constexpr uint64_t secondsPerDay{ 60ULL * 60ULL * 24ULL };
            seconds value{};
            for (uint64_t x = 1970ULL; x < year; ++x) {
                value += seconds{ secondsInJan };
                value += seconds{ secondsInFeb };
                value += seconds{ secondsInMar };
                value += seconds{ secondsInApr };
                value += seconds{ secondsInMay };
                value += seconds{ secondsInJun };
                value += seconds{ secondsInJul };
                value += seconds{ secondsInAug };
                value += seconds{ secondsInSep };
                value += seconds{ secondsInOct };
                value += seconds{ secondsInNov };
                value += seconds{ secondsInDec };
                if (x % 4ULL == 0ULL) {
                    value += seconds{ secondsPerDay };
                }
            }
            if (month > 0) {
                value += seconds{ static_cast<uint64_t>((day - 1ULL) * secondsPerDay) };
                value += seconds{ static_cast<uint64_t>(hour * secondsPerHour) };
                value += seconds{ static_cast<uint64_t>(minute * secondsPerMinute) };
                value += seconds{ second };
            }
            if (month > 1ULL) {
                value += seconds{ secondsInJan };
            }
            if (month > 2ULL) {
                value += seconds{ secondsInFeb };
            }
            if (month > 3ULL) {
                value += seconds{ secondsInMar };
            }
            if (month > 4ULL) {
                value += seconds{ secondsInApr };
            }
            if (month > 5ULL) {
                value += seconds{ secondsInMay };
            }
            if (month > 6ULL) {
                value += seconds{ secondsInJun };
            }
            if (month > 7ULL) {
                value += seconds{ secondsInJul };
            }
            if (month > 8ULL) {
                value += seconds{ secondsInAug };
            }
            if (month > 9ULL) {
                value += seconds{ secondsInSep };
            }
            if (month > 10ULL) {
                value += seconds{ secondsInOct };
            }
            if (month > 11ULL) {
                value += seconds{ secondsInNov };
            }
            return static_cast<uint64_t>(std::chrono::duration_cast<milliseconds>(value).count());
        }
 
      protected:
        /// @brief Converts a string time stamp into a uint64_t time value.
        /// @param originalTimeStamp original time stamp string.
        /// @return converted time value in milliseconds.
        inline static uint64_t convertTimeStampToTimeUnits(jsonifier::string_view originalTimeStamp) {
            if (originalTimeStamp != "" && originalTimeStamp.size() >= 19) {
                auto newValue =
                    getTimeSinceEpoch(jsonifier::strToUint64(originalTimeStamp.substr(0ULL, 4ULL).data()), jsonifier::strToUint64(originalTimeStamp.substr(5ULL, 6ULL).data()),
                        jsonifier::strToUint64(originalTimeStamp.substr(8ULL, 9ULL).data()), jsonifier::strToUint64(originalTimeStamp.substr(11ULL, 12ULL).data()),
                        jsonifier::strToUint64(originalTimeStamp.substr(14ULL, 15ULL).data()), jsonifier::strToUint64(originalTimeStamp.substr(17ULL, 18ULL).data()));
                return newValue;
            } else {
                return static_cast<uint64_t>(std::chrono::duration_cast<milliseconds>(sys_clock::now().time_since_epoch()).count());
            }
        }
 
        /// @brief Converts a string time stamp into a uint64_t time value.
        /// @param stringTimeStamp string time stamp to convert.
        /// @return converted time value in milliseconds.
        inline uint64_t convertStringToUintTimeStamp(jsonifier::string_view stringTimeStamp) const {
            return convertTimeStampToTimeUnits(stringTimeStamp);
        }
 
        /// @brief Converts a uint64_t time value into a string time stamp.
        /// @param uintTimeStamp time value to convert.
        /// @return string time stamp.
        inline jsonifier::string convertUintToStringTimeStamp(uint64_t uintTimeStamp) const {
            return getISO8601TimeStamp(time_format::long_date_time, uintTimeStamp);
        }
    };
 
    /// @brief A class that extends time_stamp_base to provide additional functionality.
    class time_stamp : public time_stamp_base<time_stamp> {
      public:
        template<typename value_type> friend class time_stamp_base;
 
        /// @brief Default constructor for time_stamp.
        inline time_stamp() = default;
 
        /// @brief Move assignment operator to move a string value into time_stamp.
        /// @param valueNew the string value to move.
        /// @return reference to the modified time_stamp instance.
        inline time_stamp& operator=(jsonifier::string_view valueNew) {
            value = convertStringToUintTimeStamp(valueNew);
            return *this;
        }
 
        /// @brief Move constructor to create a time_stamp instance by moving a string value.
        /// @param valueNew the string value to move.
        inline time_stamp(jsonifier::string_view valueNew) {
            *this = valueNew;
        }
 
        /// @brief Assignment operator to assign a uint64_t value to time_stamp.
        /// @param valueNew the new uint64_t value to assign.
        /// @return reference to the modified time_stamp instance.
        inline time_stamp& operator=(uint64_t valueNew) {
            value = valueNew;
            return *this;
        }
 
        /// @brief Constructor to create a time_stamp instance from a uint64_t value.
        /// @param valueNew the uint64_t value to create the instance from.
        inline time_stamp(uint64_t valueNew) {
            *this = valueNew;
        }
 
        /// @brief Conversion operator to convert time_stamp to int64_t.
        /// @return the int64_t value represented by the time_stamp instance.
        inline operator uint64_t() const {
            return value;
        }
 
        /// @brief Conversion operator to convert time_stamp to jsonifier::string.
        /// @return the jsonifier::string value represented by the time_stamp instance.
        inline operator jsonifier::string() const {
            return convertUintToStringTimeStamp(value);
        }
 
      protected:
        uint64_t value{};///< The value stored in the time_stamp instance.
    };
 
    class snowflake;
 
    /// @brief A class for converting snowflake id's into the data structures they represent.
    /// @tparam value_type The type of value being acquired.
    template<typename value_type = void> class to_entity {
        inline static value_type toEntity(snowflake initialId, snowflake additionalId);
 
        inline static value_type toEntity(snowflake initialId);
    };
 
    /// @brief A class representing a snowflake identifier with various operations.
    class snowflake {
      public:
        /// @brief Default constructor for snowflake.
        inline snowflake() = default;
 
        /// @brief A class for converting snowflake id's into the data structures they represent.
        /// @tparam value_type The type of value being acquired.
        /// @return value_type If successful, the intended data structure.
        template<typename value_type> inline value_type toEntity() {
            return to_entity<value_type>{}.toEntity(*this);
        }
 
        /// @brief A class for converting snowflake id's into the data structures they represent.
        /// @param additionalId For certain classes, a second Id for collecting the data structure.
        /// @tparam value_type The type of value being acquired.
        /// @return value_type If successful, the intended data structure.
        template<typename value_type> inline value_type toEntity(snowflake additionalId) {
            return to_entity<value_type>{}.toEntity(*this, additionalId);
        }
 
        /// @brief Assignment operator to assign a string value to snowflake.
        /// @param other the string value to assign.
        /// @return reference to the modified snowflake instance.
        inline snowflake& operator=(const jsonifier::string& other) {
            if (other.size() > 0) {
                for (auto& value: other) {
                    if (!std::isdigit(static_cast<uint8_t>(value))) {
                        return *this;
                    }
                }
                id = jsonifier::strToUint64(other.data());
            }
            return *this;
        }
 
        /// @brief Constructor to create a snowflake instance from a string value.
        /// @param other the string value to create the instance from.
        inline snowflake(const jsonifier::string& other) {
            *this = other;
        }
 
        /// @brief Assignment operator to assign a uint64_t value to snowflake.
        /// @param other the uint64_t value to assign.
        /// @return reference to the modified snowflake instance.
        inline snowflake& operator=(uint64_t other) {
            id = other;
            return *this;
        }
 
        /// @brief Constructor to create a snowflake instance from a uint64_t value.
        /// @param other the uint64_t value to create the instance from.
        inline snowflake(uint64_t other) {
            *this = other;
        }
 
        /// @brief Conversion operator to convert snowflake to jsonifier::string.
        /// @return the jsonifier::string value represented by the snowflake instance.
        inline explicit operator jsonifier::string() const {
            return jsonifier::toString(id);
        }
 
        /// @brief Explicit conversion operator to convert snowflake to uint64_t.
        /// @return the uint64_t value represented by the snowflake instance.
        inline explicit operator const uint64_t&() const {
            return id;
        }
 
        inline bool operator==(const snowflake& other) const {
            return id == other.id;
        }
 
        inline bool operator==(jsonifier::string_view other) const {
            return operator jsonifier::string() == other;
        }
 
        inline bool operator==(uint64_t other) const {
            return id == other;
        }
 
        /// @brief Concatenation operator to concatenate snowflake and a string value.
        /// @tparam value_type the type of the string value.
        /// @param rhs the string value to concatenate.
        /// @return the concatenated string.
        template<jsonifier::concepts::string_t value_type> inline jsonifier::string operator+(jsonifier::string_view rhs) const {
            jsonifier::string newString{ operator jsonifier::string() };
            newString += rhs;
            return newString;
        }
 
        /// @brief Friend function to concatenate snowflake and a string value.
        /// @param lhs the snowflake instance.
        /// @param other the string value to concatenate.
        /// @return the concatenated string.
        inline friend jsonifier::string operator+(const snowflake& lhs, jsonifier::string_view other) {
            jsonifier::string lhsNew{ static_cast<jsonifier::string>(lhs) };
            lhsNew += other;
            return lhsNew;
        }
 
        /// @brief Friend function to concatenate two values.
        /// @tparam value_type01 the type of the first value.
        /// @tparam value_type02 the type of the second value.
        /// @param lhs the first value.
        /// @param rhs the second value.
        /// @return the concatenated string.
        template<jsonifier::concepts::string_t value_type01, typename value_type02> friend inline jsonifier::string operator+(const value_type01& lhs, const value_type02& rhs) {
            jsonifier::string newString{ lhs };
            newString += rhs.operator jsonifier::string();
            return newString;
        }
 
        /// @brief Friend function to concatenate two values.
        /// @tparam value_type01 the type of the first value.
        /// @tparam value_type02 the type of the second value.
        /// @param lhs the first value.
        /// @param rhs the second value.
        /// @return the concatenated string.
        template<uint64_t size> friend inline jsonifier::string operator+(const char (&lhs)[size], const snowflake& rhs) {
            jsonifier::string newString{ lhs };
            newString += rhs.operator jsonifier::string();
            return newString;
        }
 
        /// @brief Converts the snowflake id into a time and date stamp.
        /// @return a jsonifier::string containing the timestamp.
        inline jsonifier::string getCreatedAtTimeStamp() {
            uint64_t timeStamp{ static_cast<uint64_t>((id >> 22) + 1420070400000) };
            return time_stamp::getISO8601TimeStamp(time_format::long_date_time, timeStamp);
        }
 
      protected:
        uint64_t id{};///< The snowflake id.
    };
 
    inline std::ostream& operator<<(std::ostream& os, snowflake sf) {
        os << sf.operator jsonifier::string();
        return os;
    }
 
    /// @brief An exception class derived from std::runtime_error for dca-related exceptions.
    struct dca_exception : public std::runtime_error {
        /// @brief Constructor to create a dca_exception with an error message and optional source location.
        /// @param error the error message.
        /// @param location the source location of the exception (default: current location).
        inline dca_exception(jsonifier::string_view error, std::source_location location = std::source_location::current())
            : std::runtime_error(std::string{ "thrown from: " + jsonifier::string{ location.file_name() } + jsonifier::string{ " (" } + jsonifier::toString(location.line()) + ":" +
                  jsonifier::toString(location.column()) + ")\n" + error }){};
    };
 
    /**@}*/
 
    /**
     * \addtogroup voice_connection
     * @{
     */
 
    /// @brief For selecting the type of streamer that the given bot is, one must be one server and one of client per connection.
    enum class stream_type { none = 0, client = 1, server = 2 };
 
    /**@}*/
}