logger.h

#ifndef OE_IO_LOGGER_H
#define OE_IO_LOGGER_H
 
#include "../util/non_copyable.h"
 
#include <sstream>
#include <string>
#include <mutex>
#include <memory>
#include <format>
 
namespace oe::io
{
    class Logger;
    class LogHandler;

    enum class LogLevel
    {
        LEVEL_TRACE, 
        LEVEL_DEBUG, 
        LEVEL_INFO, 
        LEVEL_WARNING, 
        LEVEL_ERROR, 
        LEVEL_CRITICAL 
    };

    constexpr LogLevel default_log_level = LogLevel::LEVEL_INFO;

    typedef uint64_t LogVerbosity;

    constexpr uint64_t default_log_verbosity = 0xFFFFFFFF;

    class LoggerStream : public util::NonCopyable
    {
        public:
            LoggerStream(LoggerStream&& other) noexcept;

            ~LoggerStream();

            LoggerStream& operator=(LoggerStream&& other) noexcept;

            template<typename T>
            LoggerStream& operator<<(T const& data)
            {
                _stream << data;
                return *this;
            }
 
        private:
            LoggerStream(Logger* logger, LogLevel level, const LogVerbosity verbosity);
 
            std::ostringstream _stream;
 
            LogLevel _level = default_log_level;
            LogVerbosity _verbosity = default_log_verbosity;
            Logger* _logger = nullptr;
 
            friend class Logger;
    };

    class Logger
    {
        public:
            Logger();

            std::string name;

            LogLevel minimum_level = LogLevel::LEVEL_TRACE;

            LogVerbosity verbosity = default_log_verbosity;

            static Logger& getGlobalInstance()
            {
                static Logger instance;
                return instance;
            }

            LoggerStream trace(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_TRACE, verbosity);
            }

            LoggerStream debug(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_DEBUG, verbosity);
            }

            LoggerStream info(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_INFO, verbosity);
            }

            LoggerStream warn(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_WARNING, verbosity);
            }

            LoggerStream error(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_ERROR, verbosity);
            }

            LoggerStream critical(const LogVerbosity verbosity = default_log_verbosity)
            {
                return as(LogLevel::LEVEL_CRITICAL, verbosity);
            }

            LoggerStream as(LogLevel level, const LogVerbosity verbosity = default_log_verbosity)
            {
                return LoggerStream(this, level, verbosity);
            }

            Logger& setDefaultLevel(const LogLevel default_level)
            {
                _default_level = default_level;
                return *this;
            }

            Logger& setDefaultVerbosity(const LogVerbosity verbosity)
            {
                _default_verbosity = verbosity;
                return *this;
            }

            template <typename... Args>
            void operator()(std::string_view format, Args&&... args)
            {
                _write(std::vformat(format, std::make_format_args(args...)), _default_level, _default_verbosity);
            }

            template<typename T>
            LoggerStream operator<<(T const& data)
            {
                LoggerStream stream(this, _default_level, _default_verbosity);
 
                stream << data;
 
                return stream;
            }

            void setHandler(std::shared_ptr<LogHandler> handler);

            LogHandler* getHandler()
            {
                return _handler.get();
            }

            void log(const std::ostringstream& stream, const LogLevel level = default_log_level, const LogVerbosity verbosity = default_log_verbosity);
 
        private:
            void _write(const std::string& message, const LogLevel level, const LogVerbosity verbosity);
 
            LogLevel _default_level = default_log_level;
            LogVerbosity _default_verbosity = default_log_verbosity;
 
            std::shared_ptr<LogHandler> _handler;
 
            std::mutex _mutex;
    };

    class LogHandler
    {
        public:
            virtual void write(const std::string& message, const LogLevel level) = 0;

            virtual bool canWrite(const LogLevel level, const LogVerbosity verbosity)
            {
                return (verbosity & _logger->verbosity) && level >= _logger->minimum_level;
            }
 
            virtual ~LogHandler() = default;

            bool write_stdout = true;

            bool write_file = false;
 
        protected:
            Logger* _logger = nullptr;
 
        friend class Logger;
    };

    class DefaultLogHandler : public LogHandler
    {
        public:
            virtual void write(const std::string& message, const LogLevel level) override;
    };
}
 
namespace oe
{
    extern io::Logger& log;
}
 
#endif