#pragma once

#include <chrono>
#include <cstdint>

// hard dependency
#include <fmt/format.h>

// log impl is heavily influenced & based on the yuzu logger

namespace utl {
enum class logLevel : uint8_t {
  Trace,    //< very detailed and extensive debugging information
  Debug,    //< less detailed debug information
  Info,     //< status information
  Warning,  //< minor or potential problems
  Error,    //< major problems that block further execution of a task
  Critical, //< major problems that block continued execution of the entire
            //application
  Count     //< total number of log levels
};

struct logEntry {
  std::chrono::microseconds timestamp;
  logLevel log_level;
  unsigned int line_num;
  std::string function;
  std::string message;
  bool final_entry = false;

  logEntry() = default;
  logEntry(logEntry &&o) = default;

  logEntry &operator=(logEntry &&o) = default;
  logEntry &operator=(const logEntry &o) = default;
};

class logBase {
public:
  virtual ~logBase() = default;

  virtual const char *getName() { return "Unknown"; }

  virtual void write(const logEntry &) = 0;
};

std::string formatLogEntry(const logEntry &entry);
logBase *addLogSink(std::unique_ptr<logBase> sink);
logBase *getLogSink(std::string_view name);
void formatLogMsg(logLevel lvl, uint32_t line, const char *func,
                  const char *fmt, const fmt::format_args &args);

void createLogger(bool withConsole = false);

template <typename... Args>
inline void fmtLogMsg(logLevel lvl, uint32_t line, const char *func,
                      const char *fmt, const Args &... args) {
  formatLogMsg(lvl, line, func, fmt, fmt::make_format_args(args...));
}

template <typename... Args>
inline void fmtLogMsg(logLevel lvl, uint32_t line, const char *func,
                      const std::string &text) {
  formatLogMsg(lvl, line, func, text.c_str(), {});
}
}

#ifdef _DEBUG
#define LOG_TRACE(...)                                                         \
  ::utl::fmtLogMsg(::utl::logLevel::Trace, __LINE__, __func__, __VA_ARGS__)
#else
#define LOG_TRACE(fmt, ...) (void(0))
#endif

#define LOG_DEBUG(...)                                                         \
  ::utl::fmtLogMsg(::utl::logLevel::Debug, __LINE__, __func__, __VA_ARGS__)
#define LOG_INFO(...)                                                          \
  ::utl::fmtLogMsg(::utl::logLevel::Info, __LINE__, __func__, __VA_ARGS__)
#define LOG_WARNING(...)                                                       \
  ::utl::fmtLogMsg(::utl::logLevel::Warning, __LINE__, __func__, __VA_ARGS__)
#define LOG_ERROR(...)                                                         \
  ::utl::fmtLogMsg(::utl::logLevel::Error, __LINE__, __func__, __VA_ARGS__)
#define LOG_CRITICAL(...)                                                      \
  ::utl::fmtLogMsg(::utl::logLevel::Critical, __LINE__, __func__, __VA_ARGS__)
#define LOG_ASSERT(expression)                                                 \
  do {                                                                         \
    if (!(expression)) {                                                       \
      ::utl::fmtLogMsg(::utl::logLevel::Error, __LINE__, __func__,             \
                       "assertion failed at " #expression);                    \
      __debugbreak();                                                          \
    }                                                                          \
  \
} while (0)

#define LOG_UNIMPLEMENTED                                                      \
  ::utl::fmtLogMsg(::utl::logLevel::Error, __LINE__, __func__,                 \
                   "Unimplemented function")