LogParser.cpp

#include "LogParser.h"
#include "Utils.h"
#include <fstream>
#include <sstream>
#include <iostream>
#include <regex>

std::vector<LogEntry> LogParser::parseFile(const std::string& filepath) {
    std::vector<LogEntry> entries;
    std::ifstream file(filepath);

    if (!file.is_open()) {
        std::cerr << Utils::RED << "Error: Cannot open file: " << filepath << Utils::RESET << "\n";
        return entries;
    }

    std::string line;
    int lineNum = 0;

    while (std::getline(file, line)) {
        lineNum++;
        totalLines++;
        line = Utils::trim(line);

        if (line.empty() || line[0] == '#') {
            skippedLines++;
            continue;
        }

        LogEntry entry = parseLine(line, lineNum);
        if (entry.level != LogLevel::UNKNOWN) {
            entries.push_back(entry);
        } else {
            skippedLines++;
        }
    }

    return entries;
}

LogEntry LogParser::parseLine(const std::string& line, int lineNumber) {
    LogEntry entry;
    entry.lineNumber = lineNumber;
    entry.level = LogLevel::UNKNOWN;

    if (parseStandardFormat(line, entry)) return entry;
    if (parseSimpleFormat(line, entry))   return entry;

    return entry;
}

bool LogParser::parseStandardFormat(const std::string& line, LogEntry& entry) {
    // Format: [2024-01-15 10:30:45] [ERROR] [source] message
    // or:      2024-01-15 10:30:45 ERROR source: message
    static const std::regex standardRegex(
        R"(\[?(\d{4}-\d{2}-\d{2}[\sT]\d{2}:\d{2}:\d{2}(?:\.\d+)?)\]?\s+\[?(\w+)\]?\s+(?:\[([^\]]+)\]\s+)?(.+))"
    );

    std::smatch match;
    if (std::regex_match(line, match, standardRegex)) {
        entry.timestamp = Utils::trim(match[1].str());
        entry.level     = LogEntry::levelFromString(match[2].str());
        entry.source    = match[3].str().empty() ? "app" : Utils::trim(match[3].str());
        entry.message   = Utils::trim(match[4].str());

        if (entry.level != LogLevel::UNKNOWN) return true;
    }
    return false;
}

bool LogParser::parseSimpleFormat(const std::string& line, LogEntry& entry) {
    // Format: ERROR: message  or  [ERROR] message
    static const std::regex simpleRegex(
        R"(\[?(\w+)\]?:\s+(.+))"
    );

    std::smatch match;
    if (std::regex_match(line, match, simpleRegex)) {
        LogLevel lvl = LogEntry::levelFromString(match[1].str());
        if (lvl != LogLevel::UNKNOWN) {
            entry.level     = lvl;
            entry.timestamp = "N/A";
            entry.source    = "app";
            entry.message   = Utils::trim(match[2].str());
            return true;
        }
    }
    return false;
}