#include <iostream>
#include <sstream>

#include <NBCore/Logger.hpp>
#include <NBCore/StringUtils.hpp>

namespace nb {

static bool RUN_LOGGER(nb::DefaultDebugLogger& logger_) {
    logger_.run();
    return logger_.isRunning();
}

#ifdef _NB_AUTOLOG
DefaultDebugLogger logger({std::static_pointer_cast<LogEventHandler>(
    std::make_shared<DefaultTerminalLogEventPrinter>(0x0)
)});
const bool LOGGER_RUNNING = RUN_LOGGER(logger);
#else
const bool LOGGER_RUNNING = false;
#endif // _NB_AUTOLOG

// class LogEventHandler

LogEventHandler::LogEventHandler(uint8_t logging_level) {
    _logLevel.store(logging_level, std::memory_order_release);
}

bool LogEventHandler::stop() noexcept {
    _running.store(false, std::memory_order_release);
    return isRunning();
}

bool LogEventHandler::run() {
    _running.store(true, std::memory_order_release);
    return isRunning();
}

uint8_t LogEventHandler::logLevel(uint8_t val) {
    _logLevel.store(val, std::memory_order_release);
    return logLevel();
} 
uint8_t LogEventHandler::logLevel() const {
    return _logLevel.load();
}

// class DefaultTerminalLogEventPrinter

bool DefaultTerminalLogEventPrinter::in(const LogEvent& msg) {
    if (!isRunning()) {
        return false;
    }
    if (msg.lvl < logLevel()) {
        return false;
    }
    constexpr size_t level_field_width = 5;
    constexpr size_t msg_prompt_length = level_field_width+7;
    std::stringstream formatted_stream;
    formatted_stream << "[";
    formatted_stream.width(level_field_width);
    formatted_stream << std::to_string(msg.lvl) << "] :: ";
    std::string fileloc="";
    if (!msg.file.empty()) {
        fileloc += "(" + msg.file + ":" + std::to_string(msg.line) + ") - ";
    }
    formatted_stream << indent_strblock(
        fileloc + msg.msg,
        std::string(20 - msg_prompt_length, ' '),
        ""
    ) << nb::NEWLINE;
    std::string formatted_string = formatted_stream.str();
    std::cout << formatted_string << std::flush;
    return true;
}

// class DefaultDebugLogger

bool DefaultDebugLogger::process(const LogEvent& msg) {
    return _logsink->in(msg);
}

} // namespace nb