logger.h

/*
 * Copyright 2025 Dominik Czekai
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
#include <functional>
#include <memory>
#include <unordered_map>
#include <vector>
 
#include "handler.h"
#include "log_streambuffer.h"
 
namespace cli::logging
{
 
class AbstractLogger
{
public:
    virtual ~AbstractLogger() = default;
 
    virtual void setLevel(LogLevel lvl) = 0;
 
    virtual void addHandler(std::unique_ptr<AbstractHandler> handlerPtr) = 0;
 
    virtual void removeAllHandlers() = 0;
 
    virtual void log(LogLevel lvl, const std::string &message) const = 0;
 
    virtual std::ostream &getStream(LogLevel lvl) = 0;
 
    template <typename... Args> void log(LogLevel lvl, const std::string &fmt, Args &&...args) const
    {
        std::string formatted = std::vformat(fmt, std::make_format_args(args...));
        log(lvl, formatted);
    }
 
#pragma region LogLevelShortcuts
 
    template <typename... Args> void trace(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::TRACE, fmt, std::forward<Args>(args)...);
    }
 
    template <typename... Args> void verbose(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::VERBOSE, fmt, std::forward<Args>(args)...);
    }
 
    template <typename... Args> void debug(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::DEBUG, fmt, std::forward<Args>(args)...);
    }
 
    template <typename... Args> void success(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::SUCCESS, fmt, std::forward<Args>(args)...);
    }
 
    template <typename... Args> void info(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::INFO, fmt, std::forward<Args>(args)...);
    }
 
    template <typename... Args> void warning(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::WARNING, fmt, std::forward<Args>(args)...);
    }
 
    template <typename... Args> void error(const std::string &fmt, Args &&...args)
    {
        log(LogLevel::ERROR, fmt, std::forward<Args>(args)...);
    }
 
#pragma endregion LogLevelShortcuts
 
#pragma region LogStreamShortcuts
 
    std::ostream &trace() { return getStream(LogLevel::TRACE); }
 
    std::ostream &verbose() { return getStream(LogLevel::VERBOSE); }
 
    std::ostream &debug() { return getStream(LogLevel::DEBUG); }
 
    std::ostream &success() { return getStream(LogLevel::SUCCESS); }
 
    std::ostream &info() { return getStream(LogLevel::INFO); }
 
    std::ostream &warning() { return getStream(LogLevel::WARNING); }
 
    std::ostream &error() { return getStream(LogLevel::ERROR); }
 
#pragma endregion LogStreamShortcuts
};
 
class Logger : public AbstractLogger
{
public:
    ~Logger() override = default;
    // Non-copyable
    Logger(const Logger &) = delete;
    Logger &operator=(const Logger &) = delete;
 
    Logger(Logger &&) = default;
    Logger &operator=(Logger &&) = default;
 
    explicit Logger(LogLevel lvl = LogLevel::TRACE);
 
    void setLevel(LogLevel lvl) override;
 
    void addHandler(std::unique_ptr<AbstractHandler> handlerPtr) override;
 
    void removeAllHandlers() override { handlers.clear(); }
 
    void log(LogLevel lvl, const std::string& msg) const override;
 
    std::ostream& getStream(LogLevel lvl) override;
 
private:
    LogLevel minLevel;
    std::vector<std::unique_ptr<AbstractHandler>> handlers;
 
    // Per-level stream buffers & streams
    std::unordered_map<LogLevel, std::unique_ptr<LogStreamBuf>> buffers;
    std::unordered_map<LogLevel, std::unique_ptr<std::ostream>> streams;
};
} // namespace cli::logging