Logger.h

/****************************************************************************
* Platform Abstraction Layer
* Daryl Borth 2026
* Logger.h
*
* Multi-backend debug logging. Platform-agnostic - this header never
* includes a platform SDK header. Each platform's Platform::init() wires
* up whichever LoggingDriver implementations it supports and hands them
* to a single Logger instance.
*
* Zero-overhead when disabled: build with -DLOGGING_ENABLED=0 (or define
* it before this header is first included) and every LOG_*() call site
* compiles to nothing - no string literal in .rodata, no branch, no call.
***************************************************************************/
#pragma once
 
#include <stdarg.h>
#include <stddef.h>
#include <stdint.h>

#ifndef LOGGING_ENABLED
#define LOGGING_ENABLED 0
#endif

#define LOG_LEVEL_DEBUG   0
#define LOG_LEVEL_INFO    1
#define LOG_LEVEL_WARNING 2
#define LOG_LEVEL_ERROR   3
 
#ifdef __cplusplus
 
#include "Mutex.h"

enum class LogLevel : uint8_t
{
    Debug,
    Info,
    Warning,
    Error,
    None
};
 
static_assert(static_cast<uint8_t>(LogLevel::Debug)   == LOG_LEVEL_DEBUG,   "LOG_LEVEL_DEBUG out of sync with LogLevel");
static_assert(static_cast<uint8_t>(LogLevel::Info)    == LOG_LEVEL_INFO,    "LOG_LEVEL_INFO out of sync with LogLevel");
static_assert(static_cast<uint8_t>(LogLevel::Warning) == LOG_LEVEL_WARNING, "LOG_LEVEL_WARNING out of sync with LogLevel");
static_assert(static_cast<uint8_t>(LogLevel::Error)   == LOG_LEVEL_ERROR,   "LOG_LEVEL_ERROR out of sync with LogLevel");

enum class LogMode : uint8_t
{
    OSReport, 
    UDP,
    SerialGecko,
    File,
    Multi 
};

enum LogBackendId : uint32_t
{
    LOGGER_NONE     = 0,
    LOGGER_OSREPORT = 1u << 0,
    LOGGER_UDP      = 1u << 1,
    LOGGER_SERIAL   = 1u << 2,
    LOGGER_FILE     = 1u << 3,
};

enum class LogFlushPolicy : uint8_t
{
    Immediate,    
    EveryNWrites, 
    Never         
};

struct LogConfig
{
    LogMode mode = LogMode::File; 
    LogLevel level = LogLevel::Info; 

    uint32_t multiBackendMask = LOGGER_OSREPORT;

    bool mirrorToOSReport = true;
 
    // ---- UDP ----
    const char * targetIp = "192.168.1.100";
    uint16_t targetPort = 4405;
    bool nonBlocking = true; 
 
    // ---- Serial / USB Gecko ----
    int geckoChannel = 1;

    uint32_t serialBaudRate = 115200;
 
    // ---- SD / file ----
    char filePath[1024] = "sd:/debug.log";
    LogFlushPolicy flushPolicy = LogFlushPolicy::Immediate;
    uint32_t flushEveryNWrites = 16;
 
    // ---- Formatting ----
    bool includeLevelTag = true;         
    bool includeSequenceNumber = false;  
    bool includeTimestamp = true;        
};

class LoggingDriver
{
public:
    virtual ~LoggingDriver() = default;

    virtual bool init(const LogConfig & config) = 0;

    virtual void shutdown() = 0;

    virtual void write(LogLevel level, const char * line, size_t len) = 0;

    virtual const char * name() const = 0;
};

class Logger
{
public:
    Logger();
    ~Logger();
 
    Logger(const Logger &) = delete;
    Logger & operator=(const Logger &) = delete;

    void init(const LogConfig & config);

    void activateDeferred(LogBackendId id);

    void shutdown();

    bool registerBackend(LogBackendId id, LoggingDriver * backend);

    void setLevel(LogLevel level);
    LogLevel getLevel() const { return logConfig.level; }

    void log(LogLevel level, const char * fmt, va_list args);

    static const int MAX_BACKENDS = 8;
 
private:
    struct Slot
    {
        LogBackendId id = LOGGER_NONE;
        LoggingDriver * backend = nullptr;
        bool active = false; 
    };

    uint32_t resolveActiveMask() const;
 
    Slot slots[MAX_BACKENDS];
    int slotCount = 0;
    LogConfig logConfig;
    Mutex lock;
    uint32_t sequence = 0;
    bool initialized = false;
};
 
#endif // __cplusplus
 
/****************************************************************************
* C bridge
*
* LogPrintf() (below) is a C++ function taking a `LogLevel` argument, so
* its mangled name and argument type aren't callable from C.
***************************************************************************/
#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
void LogPrintf(LogLevel level, const char * fmt, ...);
#endif

void Log_Printf(int level, const char * fmt, ...);
 
#ifdef __cplusplus
} // extern "C"
#endif
 
#if LOGGING_ENABLED
  #ifdef __cplusplus
    #define LOG_DEBUG(fmt, ...) LogPrintf(LogLevel::Debug,   fmt, ##__VA_ARGS__)
    #define LOG_INFO(fmt, ...)  LogPrintf(LogLevel::Info,    fmt, ##__VA_ARGS__)
    #define LOG_WARN(fmt, ...)  LogPrintf(LogLevel::Warning, fmt, ##__VA_ARGS__)
    #define LOG_ERROR(fmt, ...) LogPrintf(LogLevel::Error,   fmt, ##__VA_ARGS__)
  #else
    #define LOG_DEBUG(fmt, ...) Log_Printf(LOG_LEVEL_DEBUG,   fmt, ##__VA_ARGS__)
    #define LOG_INFO(fmt, ...)  Log_Printf(LOG_LEVEL_INFO,    fmt, ##__VA_ARGS__)
    #define LOG_WARN(fmt, ...)  Log_Printf(LOG_LEVEL_WARNING, fmt, ##__VA_ARGS__)
    #define LOG_ERROR(fmt, ...) Log_Printf(LOG_LEVEL_ERROR,   fmt, ##__VA_ARGS__)
  #endif
#else
#define LOG_DEBUG(fmt, ...) ((void)0)
#define LOG_INFO(fmt, ...)  ((void)0)
#define LOG_WARN(fmt, ...)  ((void)0)
#define LOG_ERROR(fmt, ...) ((void)0)
#endif

#define LOG(fmt, ...) LOG_INFO(fmt, ##__VA_ARGS__)