Logger.h

#pragma once
 
#include <fmt/color.h>
#include <fmt/format.h>
#include <fmt/ranges.h>
 
#include <functional>
#include <unordered_map>
 
namespace iguana {

  class Logger
  {
 
      friend class Object;
 
    public:

      enum Level {
        trace,
        debug,
        info,
        quiet,
        warn,
        error,
        silent
      };

      static Level const DEFAULT_LEVEL = info;

      Logger(std::string_view name = "log", Level const lev = DEFAULT_LEVEL, bool const enable_style = true);
      ~Logger() {}

      void SetLevel(std::string_view lev);

      void SetLevel(Level const lev);

      Level GetLevel();

      void EnableStyle();

      void DisableStyle();

      static std::string Header(std::string_view message, int const width = 50);

      template <typename... VALUES>
      void Trace(std::string_view message, const VALUES... vals) const { Print(trace, message, vals...); }
      template <typename... VALUES>
      void Debug(std::string_view message, const VALUES... vals) const { Print(debug, message, vals...); }
      template <typename... VALUES>
      void Info(std::string_view message, const VALUES... vals) const { Print(info, message, vals...); }
      template <typename... VALUES>
      void Warn(std::string_view message, const VALUES... vals) const { Print(warn, message, vals...); }
      template <typename... VALUES>
      void Error(std::string_view message, const VALUES... vals) const { Print(error, message, vals...); }

      template <typename... VALUES>
      void Print(Level const lev, std::string_view message, const VALUES... vals) const
      {
        if(lev >= m_level) {
          if(auto it{m_level_names.find(lev)}; it != m_level_names.end()) {
            std::function<std::string(std::string)> style = [](std::string s)
            { return fmt::format("[{}]", s); };
            if(m_enable_style) {
              switch(lev) {
              case warn:
                style = [](std::string s)
                { return fmt::format("[{}]", fmt::styled(s, fmt::emphasis::bold | fmt::fg(fmt::terminal_color::magenta))); };
                break;
              case error:
                style = [](std::string s)
                { return fmt::format("[{}]", fmt::styled(s, fmt::emphasis::bold | fmt::fg(fmt::terminal_color::red))); };
                break;
              default:
                style = [](std::string s)
                { return fmt::format("[{}]", fmt::styled(s, fmt::emphasis::bold)); };
              }
            }
            fmt::print(
                lev >= warn ? stderr : stdout,
                fmt::runtime(fmt::format("{} {} {}\n", style(it->second), style(m_name), message)),
                vals...);
          }
          else {
            Warn("Logger::Print called with unknown log level '{}'; printing as error instead", static_cast<int>(lev)); // FIXME: static_cast -> fmt::underlying, but needs new version of fmt
            Error(message, vals...);
          }
        }
      }
 
    private:

      std::string m_name;

      Level m_level;

      std::unordered_map<Level, std::string> m_level_names;

      bool m_enable_style;
  };
}