export module routemon:log;

import std;

namespace routemon::log {

export enum class level : std::uint8_t {
  debug,
  info,
  warn,
  error,
};

export class sink
{
  std::atomic<enum level> lvl_;
  std::ostream& os_ = std::cout;

  explicit sink(level lvl);

  friend auto make_sink(level lvl) -> std::shared_ptr<sink>;

public:
  struct tmp_message
  {
    level lvl;
    std::string_view component;
    std::string_view txt;
    std::map<std::string, std::string> const& attrs;
  };

  [[nodiscard]] auto level() const -> enum level;
  auto set_level(enum level lvl) -> void;

  auto write(tmp_message msg) -> void;
};

export auto make_sink(level lvl) -> std::shared_ptr<sink>;

export class logger
{
  std::shared_ptr<sink> sink_;
  std::string component_;
  std::map<std::string, std::string> attrs_;

  auto log_at(log::level lvl, std::string_view fmt, std::format_args args)
      -> logger&;

public:
  explicit logger(std::shared_ptr<sink> const& sink);

  [[nodiscard]] auto sub(std::string_view component) const -> logger;
  [[nodiscard]] auto with(std::string const& k, std::string&& v) const
      -> logger;
  [[nodiscard]] auto with(std::string const& k, std::string_view v) const
      -> logger;

  template <class... Args>
  auto debug(std::format_string<Args...> fmt, Args&&... args) -> logger&
  {
    return log_at(level::debug, fmt.get(), std::make_format_args(args...));
  }

  template <class... Args>
  auto info(std::format_string<Args...> fmt, Args&&... args) -> logger&
  {
    return log_at(level::info, fmt.get(), std::make_format_args(args...));
  }

  template <class... Args>
  auto warn(std::format_string<Args...> fmt, Args&&... args) -> logger&
  {
    return log_at(level::warn, fmt.get(), std::make_format_args(args...));
  }

  template <class... Args>
  auto error(std::format_string<Args...> fmt, Args&&... args) -> logger&
  {
    return log_at(level::error, fmt.get(), std::make_format_args(args...));
  }
};

} // namespace routemon::log