Log.h

#ifndef HYDROBRICKS_LOG_H
#define HYDROBRICKS_LOG_H
 
#include <format>
#include <memory>
#include <string>
 
enum class LogLevel {
    Error,
    Warning,
    Message,
    Debug
};
 
class LogFile {
  public:
    LogFile();
    ~LogFile();
    LogFile(const LogFile&) = delete;
    LogFile& operator=(const LogFile&) = delete;
 
    void Open(const std::string& path);
 
    void Close();
 
    [[nodiscard]] bool IsOpen();
 
    void Write(const std::string& line);
 
  private:
    // The stream and its mutex live in the implementation: this header is part of the
    // core's common includes, which must not pull in <fstream> and <mutex>.
    struct Impl;
    std::unique_ptr<Impl> _impl;
};
 
class LogScope {
  public:
    explicit LogScope(LogFile* file);
    ~LogScope();
    LogScope(const LogScope&) = delete;
    LogScope& operator=(const LogScope&) = delete;
 
  private:
    LogFile* _previous;
};
 
void LogSetLevel(LogLevel level);
 
void LogSetFile(const std::string& path);
 
void LogFlush();
 
// Core logging functions (non-template)
void LogError(const std::string& msg);
void LogWarning(const std::string& msg);
void LogMessage(const std::string& msg);
void LogDebug(const std::string& msg);
 
// Template overloads for formatted messages (std::format style)
template <typename... Args>
void LogError(std::format_string<Args...> fmt, Args&&... args) {
    LogError(std::format(fmt, std::forward<Args>(args)...));
}
 
template <typename... Args>
void LogWarning(std::format_string<Args...> fmt, Args&&... args) {
    LogWarning(std::format(fmt, std::forward<Args>(args)...));
}
 
template <typename... Args>
void LogMessage(std::format_string<Args...> fmt, Args&&... args) {
    LogMessage(std::format(fmt, std::forward<Args>(args)...));
}
 
template <typename... Args>
void LogDebug(std::format_string<Args...> fmt, Args&&... args) {
    LogDebug(std::format(fmt, std::forward<Args>(args)...));
}
 
#endif  // HYDROBRICKS_LOG_H