#include "Logger.h"
#include "FatalHandler.h"

Logger& Logger::GetCoreLogger() {
    static Logger coreLogger;
    return coreLogger;
}

Logger& Logger::GetAppLogger() {
    static Logger appLogger;
    return appLogger;
}

Logger::Logger() {}

void Logger::AddOutputStream(std::ostream* stream) {
    outputStreams.push_back(stream);
}

void Logger::SetLogLevel(LogLevel level) {
    logLevel = level;
}

void Logger::Log(LogLevel level, const std::string& message) {
    if (level >= logLevel) {
        LogInternal(level, message);
    }
}

void Logger::LogInternal(LogLevel level, const std::string& message) {
    std::string time = GetCurrentTime();
    std::string levelStr = LevelToString(level);

    for (auto* stream : outputStreams) {
        *stream << time << " [" << levelStr << "]: " << message << std::endl;
    }
}

std::string Logger::GetCurrentTime() {
    auto now = std::chrono::system_clock::now();
    auto in_time_t = std::chrono::system_clock::to_time_t(now);

    std::stringstream ss;
    ss << std::put_time(std::localtime(&in_time_t), "%Y/%m/%d %H:%M:%S");
    return ss.str();
}

std::string Logger::LevelToString(LogLevel level) {
    switch (level) {
        case LogLevel::TRACE_l: return "TRACE";
        case LogLevel::DEBUG_l: return "DEBUG";
        case LogLevel::INFO_l:  return "INFO";
        case LogLevel::WARN_l:  return "WARN";
        case LogLevel::ERROR_l: return "ERROR";
        case LogLevel::FATAL_l: return "FATAL";
        default:              return "UNKNOWN";
    }
}

template<typename... Args>
void Logger::FatalHandler(const std::string& format, Args... args) {
    IsoEngine::FatalHandler(format, args...);
}