#include "Logger.h"

void Logger::Initialize(const std::string &logFile, LogLevel consoleLevel, LogLevel fileLevel) {
    logFileName = logFile;
    consoleLogLevel = consoleLevel;
    fileLogLevel = fileLevel;
    if (!logFile.empty()) {
        logFileStream.open(logFile, std::ios::out | std::ios::app);
    }
}

Logger::~Logger() {
    if (logFileStream.is_open()) {
        logFileStream.close();
    }
}

void Logger::Log(LogLevel level, const std::string& message, const std::string& scope) {
    std::lock_guard<std::mutex> lock(logMutex);

    std::string formattedMessage = FormatMessage(level, message, scope);

    memoryLogs.push_back(formattedMessage);
    if (memoryLogs.size() > memoryLogSize) {
        memoryLogs.pop_front();
    }

    if (ShouldLogToConsole(level)) {
        std::cout << formattedMessage << std::endl;
    }

    if (ShouldLogToFile(level)) {
        if (logFileStream.is_open()) {
            logFileStream << formattedMessage << std::endl;
        }
    }
}

void Logger::LogInfo(const std::string& message, const std::string& scope) {
    Log(LogLevel::INFOL, message, scope);
}

void Logger::LogDebug(const std::string& message, const std::string& scope) {
    Log(LogLevel::DEBUGL, message, scope);
}

void Logger::LogWarning(const std::string& message, const std::string& scope) {
    Log(LogLevel::WARNINGL, message, scope);
}

void Logger::LogError(const std::string& message, const std::string& scope) {
    Log(LogLevel::ERRORL, message, scope);
}

void Logger::LogCritical(const std::string& message, const std::string& scope) {
    Log(LogLevel::CRITICALL, message, scope);
}

void Logger::DumpLogs(const std::string& dumpFileName) {
    std::lock_guard<std::mutex> lock(logMutex);

    std::ofstream dumpFile(dumpFileName, std::ios::out | std::ios::app);
    if (!dumpFile.is_open()) {
        std::cerr << "Failed to open dump file: " << dumpFileName << std::endl;
        return;
    }

    dumpFile << "---- Log Dump ----" << std::endl;
    dumpFile << "Timestamp: " << GetTimestamp() << std::endl;
    dumpFile << "------------------" << std::endl;

    for (const std::string& log : memoryLogs) {
        dumpFile << log << std::endl;
    }

    dumpFile.close();
}

std::string Logger::FormatMessage(LogLevel level, const std::string& message, const std::string& scope) {
    std::string levelStr = LogLevelToString(level);
    std::string timestamp = GetTimestamp();
    return timestamp + " [" + levelStr + "] [" + scope + "] " + message;
}

std::string Logger::GetTimestamp() {
    std::time_t now = std::time(nullptr);
    char buf[20];
    std::strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", std::localtime(&now));
    return std::string(buf);
}

std::string Logger::LogLevelToString(LogLevel level) {
    switch (level) {
        case LogLevel::DEBUGL:    return "DEBUG";
        case LogLevel::INFOL:     return "INFO";
        case LogLevel::WARNINGL:  return "WARNING";
        case LogLevel::ERRORL:    return "ERROR";
        case LogLevel::CRITICALL: return "CRITICAL";
        default:                 return "UNKNOWN";
    }
}

bool Logger::ShouldLogToConsole(LogLevel level) {
    return level >= consoleLogLevel;
}

bool Logger::ShouldLogToFile(LogLevel level) {
    return level >= fileLogLevel && !logFileName.empty();
}