#pragma once

#include <string_view>

#include "uart_handler.hpp"

enum class LogLevel {
  ERROR = 0,
  INFO,
  DEBUG,
  TRACE,
};

inline std::string_view get_loglevel_string(LogLevel level) {
  switch (level) {
    case (LogLevel::ERROR): {
      return "[Error]";
    }
    case (LogLevel::INFO): {
      return "[Info] ";
    }
    case (LogLevel::DEBUG): {
      return "[Debug]";
    }
    case (LogLevel::TRACE): {
      return "[Trace]";
    }
  }

  return "[Unknown]";
}

class logging_adapter {
 public:
  virtual bool init(){}
  virtual void log(std::string_view message) const = 0;
};

class uart_logger : public logging_adapter {
 public:
  bool init() { return uart_interface::init(); }

  virtual void log(std::string_view message) const override {
    uart_interface::write(message);
  }
};

class log {
 public:
  template <typename LoggerType>
  static bool init() {
    if (logger) {
      return true;
    }

    static LoggerType logger_impl;
    logger = &logger_impl;

    return logger_impl.init();
  }

  static void error(std::string_view message) {
    log_impl(LogLevel::ERROR, message);
  }

  static void debug(std::string_view message) {
    log_impl(LogLevel::DEBUG, message);
  }

  static void info(std::string_view message) {
    log_impl(LogLevel::INFO, message);
  }

  static void set_loglevel(LogLevel level) { log_level = level; }

 private:
  static void log_impl(LogLevel level, std::string_view message) {
    if (log_level < level) {
      return;
    }

    //std::stringstream msg;
    //msg << get_loglevel_string(level) << ": " << message;
    logger->log(get_loglevel_string(level));
    logger->log(": ");
    logger->log(message);

    constexpr std::string_view carriage_return{"\r\n"};
    logger->log(carriage_return);
  }

  static logging_adapter* logger;
  static LogLevel log_level;
};