#ifndef UTILS_LOG_H
#define UTILS_LOG_H

#include <cassert>
#include <chrono>
#include <cstdio>
#include <type_traits>

// -- LOGGER MACROS ------------------------------------------------------------

#define FAIL(log, fmt, ...) LOG(log, kFail, fmt, ##__VA_ARGS__)
#define WARN(log, fmt, ...) LOG(log, kWarn, fmt, ##__VA_ARGS__)
#define INFO(log, fmt, ...) LOG(log, kInfo, fmt, ##__VA_ARGS__)
#define DBG0(log, fmt, ...) LOG(log, kDbg0, fmt, ##__VA_ARGS__)

// -- LOGGER MACROS DETAILS ----------------------------------------------------

#define LOG(log_, lvl, fmt, ...)                                             \
  do {                                                                       \
    struct fmt_str_must_be_str_literal {                                     \
      constexpr fmt_str_must_be_str_literal(const char* ptr) : ptr{ptr} {}   \
      const char* ptr;                                                       \
    };                                                                       \
    /* Check if FMT is a string literal, construction fails otherwise. */    \
    constexpr fmt_str_must_be_str_literal _{fmt};                            \
    (void)_;                                                                 \
                                                                             \
    int lint_fmt_string(const char*, ...)                                    \
        __attribute__((format(printf, 1, 2)));                               \
    /* Check fmt args against fmt string and warn if -Wformat is enabled. */ \
    (void)sizeof(lint_fmt_string(fmt, ##__VA_ARGS__));                       \
                                                                             \
    if (logging::log_level::lvl <= (log_)->get_level())                      \
      (log_)->template log<logging::log_level::lvl>(fmt, ##__VA_ARGS__);     \
  } while (0)

namespace logging {

// -- LOGGING LEVELS -----------------------------------------------------------

#define LOG_LEVELS(M) \
  M(kFail, "FAIL")    \
  M(kWarn, "WARN")    \
  M(kInfo, "INFO")    \
  M(kDbg0, "DBG0")

#define M(val, ignore) val,
enum log_level { LOG_LEVELS(M) };
#undef M

#define M(ignore, val) val,
constexpr const char* kLogPrefix[] = {LOG_LEVELS(M)};
#undef M

namespace detail {

// -- SANITIZE FMT ARG HELPER (META FN) ----------------------------------------

template <typename T>
constexpr inline bool is_one_of() {
  return false;
}

template <typename T, typename U, typename... Args>
constexpr inline bool is_one_of() {
  return std::is_same<T, U>::value || is_one_of<T, Args...>();
}

template <typename Arg>
constexpr inline Arg sanitize_fmt_args(Arg arg) {
  static_assert(
      is_one_of<Arg, char, unsigned char, int, unsigned, float, double>() ||
          std::is_pointer<Arg>::value,
      "Invalid FMT arg type!");
  return arg;
}

// -- FORMATTER HELPER ---------------------------------------------------------

template <std::size_t N>
struct formatter {
  template <typename... Args>
  std::size_t operator()(char* str,
                         std::size_t size,
                         const char* fmt,
                         Args... args) {
    static_assert(sizeof...(Args) == N, "");
    return std::snprintf(str, size, fmt, args...);
  }
};

template <>
struct formatter<0> {
  std::size_t operator()(char* str, std::size_t size, const char* fmt) {
    return std::snprintf(str, size, "%s", fmt);
  }
};

// -- TIME STAMP HELPER --------------------------------------------------------

template <int UtcOffset = 0>
struct time_stamp {
  using clock = std::chrono::system_clock;
  using repr = clock::rep;
  using time_point = clock::time_point;

  repr us() const {
    return to_duration<std::chrono::microseconds>() % 1000;
  }
  repr ms() const {
    return to_duration<std::chrono::milliseconds>() % 1000;
  }
  repr s() const {
    return to_duration<std::chrono::seconds>() % 60;
  }
  repr m() const {
    return to_duration<std::chrono::minutes>() % 60;
  }
  repr h() const {
    return to_duration<std::chrono::hours>() % 24 + UtcOffset;
  }

 private:
  template <typename ToDuration>
  repr to_duration() const {
    return std::chrono::duration_cast<ToDuration>(m_time.time_since_epoch())
        .count();
  }

  time_point m_time{clock::now()};
};
}  // namespace detail

// -- LOGGER -------------------------------------------------------------------

template <bool WithTimestamp = true, std::size_t BufSize = 128>
struct logger {
  constexpr logger() = default;
  constexpr logger(log_level lvl) : m_lvl{lvl} {}

  log_level get_level() const {
    return m_lvl;
  }
  void set_level(log_level lvl) {
    m_lvl = lvl;
  }

  template <log_level L, typename... Args>
  constexpr void log(const char* fmt, Args... args);

 private:
  log_level m_lvl{kInfo};
  char m_buf[BufSize];
};

// -- LOGGER IMPLEMENTATION ----------------------------------------------------

template <bool WithTimestamp, std::size_t BufSize>
template <log_level L, typename... Args>
constexpr void logger<WithTimestamp, BufSize>::log(const char* fmt,
                                                   Args... args) {
  std::size_t pos{0};

  // Add timestamp if enabled.
  if (WithTimestamp) {
    detail::time_stamp<2> ts;
    pos += std::snprintf(m_buf + pos, BufSize - pos,
                         "[%02ld:%02ld:%02ld:%03ld%03ld] ", ts.h(), ts.m(),
                         ts.s(), ts.ms(), ts.us());
    assert(pos > 0);
  }

  // Add log level prefix.
  pos += std::snprintf(m_buf + pos, BufSize - pos, "%s: ", kLogPrefix[L]);
  assert(pos < BufSize);

  // Add log message using user specified fmt string.
  //
  // SAFETY: User of this function is responsible to provide a "safe" fmt
  // string. When using the provided macros we check that the user specifies a
  // string literal as fmt string and hence the user controls the fmt string.
  // Additionally, we sanitize the arguments to only allow explicitly specified
  // argument types.
  detail::formatter<sizeof...(Args)> formatter;
  pos += formatter(m_buf + pos, BufSize - pos, fmt,
                   detail::sanitize_fmt_args(args)...);
  assert(pos < BufSize);

  // Ensure terminated with new line and null terminator.
  assert(pos < BufSize);
  m_buf[pos++] = '\n';

  // Write out log message.
  std::fwrite(m_buf, pos < BufSize ? pos : BufSize, 1 /* nmemb */, stderr);
}

}  // namespace logging

#endif