logmod.h

#ifndef LOGMOD_H
#define LOGMOD_H

#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

/**
 * @brief Define symbol visibility for LogMod API
 *
 * Define LOGMOD_STATIC to make all symbols static (for single-file inclusion)
 */
#ifdef LOGMOD_STATIC
#define LOGMOD_API static
#else
#define LOGMOD_API extern
#endif /* LOGMOD_STATIC */

#include <stdio.h>
#include <stdarg.h>
#include <time.h>

/**
 * @brief Format string checking attribute for printf-like functions
 *
 * This macro adds format string checking when supported by the compiler,
 * helping catch format string errors at compile time.
 *
 * @param a Format string parameter position
 * @param b First variadic argument position
 */
#if defined(__MINGW32__)                                                      \
    || (defined(__GNUC__) && __GNUC__ > 4 ? true : __GNUC_PATCHLEVEL__ >= 4)  \
    || defined(__USE_MINGW_ANSI_STDIO)
#define LOGMOD_PRINTF_LIKE(a, b) __attribute__((format(gnu_printf, a, b)))
#else
#define LOGMOD_PRINTF_LIKE(a, b)
#endif

/**
 * @brief Default application ID for the fallback logger
 *
 * Can be overridden by defining this macro before including logmod.h
 */
#ifndef LOGMOD_FALLBACK_APPLICATION_ID
#define LOGMOD_FALLBACK_APPLICATION_ID "APPLICATION"
#endif /* LOGMOD_FALLBACK_APPLICATION_ID */

/**
 * @brief Default context ID for the fallback logger
 *
 * Can be overridden by defining this macro before including logmod.h
 */
#ifndef LOGMOD_FALLBACK_CONTEXT_ID
#define LOGMOD_FALLBACK_CONTEXT_ID "GLOBAL"
#endif /* LOGMOD_FALLBACK_CONTEXT_ID */

/**
 * @brief Log levels supported by LogMod
 *
 * Built-in log levels ordered by severity (lowest to highest)
 * Custom log levels should start at LOGMOD_LEVEL_CUSTOM
 */
enum logmod_levels {
    LOGMOD_LEVEL_TRACE = 0, /**< Most detailed logging for tracing execution */
    LOGMOD_LEVEL_DEBUG, /**< Debug information */
    LOGMOD_LEVEL_INFO, /**< Informational messages */
    LOGMOD_LEVEL_WARN, /**< Warning messages */
    LOGMOD_LEVEL_ERROR, /**< Error messages */
    LOGMOD_LEVEL_FATAL, /**< Fatal errors that cause termination */
    __LOGMOD_LEVEL_MAX, /**< Internal marker for built-in level count */
    /** user defined log level must start with this value */
    LOGMOD_LEVEL_CUSTOM = __LOGMOD_LEVEL_MAX
};

/**
 * @brief Error codes returned by LogMod functions
 */
typedef enum {
    LOGMOD_ERRNO = -2, /**< System error, check errno */
    LOGMOD_BAD_PARAMETER = -1, /**< Invalid parameter passed to function */
    LOGMOD_OK = 0, /**< Success */
    LOGMOD_OK_CONTINUE, /**< Success, continue with default behavior */
    LOGMOD_OK_SKIPPED /**< Success, logger has been skipped from logging due to
                         being disabled by user */
} logmod_err;

/**
 * @brief Configuration options for a logger
 */
struct logmod_options {
    FILE *logfile; /**< File to write logs to, or NULL for no file output */
    int quiet; /**< If 1, suppress console output */
    int color; /**< If 1, enable ANSI colors on console output */
    int hide_context_id; /**< If 1, suppress context ID in log messages */
    int show_application_id; /**< If 1, show application ID in log messages */
    unsigned level; /**< Minimum level to log (suppress messages below this) */
    int suppress_time; /**< If 1, suppress time in log messages */
    int hide_counter; /**< If 1, hide message counter in log messages */
};

/**
 * @brief Label properties for a log level
 *
 * @see @ref LOGMOD_LABEL_COLOR
 */
struct logmod_label {
    const char *const name; /**< Display name of the log level */
    const char *const style; /**< ANSI style code for this label */
    const char *const visibility; /**< ANSI visibility code for this label */
    const char *const color; /**< ANSI color code for this label */
    const int output; /**< Output stream: 0 = stdout, 1 = stderr */
};

/**
 * @brief Helper macro to define label color, style, and visibility at once
 *
 * @param _style Style name (e.g., BOLD, REGULAR)
 * @param _visibility Visibility name (e.g., FOREGROUND, BACKGROUND)
 * @param _color Color name (e.g., RED, GREEN)
 */
#define LOGMOD_LABEL_COLOR(_style, _visibility, _color)                       \
    LOGMOD_STYLE_##_style, LOGMOD_VISIBILITY_##_visibility,                   \
        LOGMOD_COLOR_##_color

/**
 * @brief Information about a log entry
 */
struct logmod_info {
    const unsigned line; /**< Source line number */
    const char *const filename; /**< Source filename */
    const unsigned level; /**< Log level */
    const struct logmod_label *const label; /**< Label for this log level */
    const struct tm time; /**< Time for when entry has been triggered */
};

/* forward declaration */
struct logmod_logger;
struct tm;
/**/

/**
 * @brief Lock function type for thread safety
 *
 * @param logger The logger instance
 * @param should_lock 1 to acquire lock, 0 to release
 */
typedef void (*logmod_lock)(const struct logmod_logger *logger,
                            int should_lock);

/**
 * @brief Callback function type for custom log handling
 *
 * @param logger The logger instance
 * @param info Information about the log entry
 * @param fmt Format string
 * @param args Variable arguments list
 * @return LOGMOD_OK to skip default handling, LOGMOD_OK_CONTINUE to also
 * perform default handling
 */
typedef logmod_err (*logmod_callback)(const struct logmod_logger *logger,
                                      const struct logmod_info *info,
                                      const char *fmt,
                                      va_list args);

/**
 * @brief ANSI text style values
 */
#define LOGMOD_STYLE_REGULAR       "0" /**< Regular text style */
#define LOGMOD_STYLE_BOLD          "1" /**< Bold text style */
#define LOGMOD_STYLE_UNDERLINE     "4" /**< Underlined text style */
#define LOGMOD_STYLE_STRIKETHROUGH "9" /**< Strikethrough text style */

/**
 * @brief ANSI text visibility mode values
 */
#define LOGMOD_VISIBILITY_FOREGROUND "3" /**< Foreground color */
#define LOGMOD_VISIBILITY_BACKGROUND "4" /**< Background color */
#define LOGMOD_VISIBILITY_INTENSITY  "9" /**< Intensity (bright) foreground */
#define LOGMOD_VISIBILITY_BACKGROUND_INTENSITY                                \
    "10" /**< Intensity (bright) background */

/**
 * @brief ANSI color values
 */
#define LOGMOD_COLOR_BLACK   "0" /**< Black color */
#define LOGMOD_COLOR_RED     "1" /**< Red color */
#define LOGMOD_COLOR_GREEN   "2" /**< Green color */
#define LOGMOD_COLOR_YELLOW  "3" /**< Yellow color */
#define LOGMOD_COLOR_BLUE    "4" /**< Blue color */
#define LOGMOD_COLOR_MAGENTA "5" /**< Magenta color */
#define LOGMOD_COLOR_CYAN    "6" /**< Cyan color */
#define LOGMOD_COLOR_WHITE   "7" /**< White color */

/**
 * @brief Internal macro for defining logger attributes
 *
 * Used to define both const and non-const versions of the logger structure
 * with the same fields.
 *
 * @param _qualifier Qualifier to apply to mutable fields (const or empty)
 */
#define __LOGMOD_LOGGER_ATTRS(_qualifier)                                     \
    const char *context_id;                                                   \
    _qualifier struct logmod_options options;                                 \
    const long *counter;                                                      \
    _qualifier logmod_callback callback;                                      \
    void *user_data;                                                          \
    const struct logmod_label *_qualifier custom_labels;                      \
    _qualifier size_t num_custom_labels;                                      \
    _qualifier int disabled

#define __BLANK
/**
 * @brief Mutable version of the logger structure
 *
 * This version allows modification of the logger properties
 */
struct logmod_mut_logger {
    __LOGMOD_LOGGER_ATTRS(__BLANK);
};
#undef __BLANK

/**
 * @brief Immutable logger structure
 *
 * This is the public-facing version of the logger with const-qualified fields
 */
struct logmod_logger {
    __LOGMOD_LOGGER_ATTRS(const);
};

#undef __LOGMOD_LOGGER_ATTRS

/**
 * @brief Main logging context structure
 *
 * Contains the global state for a logging context
 */
struct logmod {
    const char *application_id; /**< Application identifier */
    const struct logmod_logger *loggers; /**< Array of loggers */
    const size_t length; /**< Current number of loggers */
    const size_t real_length; /**< Maximum capacity of loggers array */
    long counter; /**< Global log message counter */
    const struct logmod_options
        default_options; /**< Default options for new loggers */
    logmod_lock lock; /**< Lock function for thread safety */
};

/**
 * @brief Initialize the logging context
 *
 * @param logmod Pointer to the logging context structure
 * @param application_id Application identifier string
 * @param table Array to store loggers (must be pre-allocated)
 * @param length Capacity of the table array
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_init(struct logmod *logmod,
                                  const char *const application_id,
                                  struct logmod_logger table[],
                                  unsigned length);

/**
 * @brief Clean up the logging context
 *
 * @param logmod Pointer to the logging context structure
 * @return LOGMOD_OK on success
 */
LOGMOD_API logmod_err logmod_cleanup(struct logmod *logmod);

/**
 * @brief Set the lock function for thread safety
 *
 * @param logmod Pointer to the logging context structure
 * @param lock Lock function to use
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_set_lock(struct logmod *logmod, logmod_lock lock);

/**
 * @brief Set default options for all new loggers
 *
 * @param logmod Pointer to the logging context structure
 * @param options Default options to use for new loggers
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_set_options(struct logmod *logmod,
                                         struct logmod_options options);

/**
 * @brief Toggle a specific logger from logging (default is true)
 *
 * @param logmod Pointer to the logging context structure
 * @param context_id The context id of the logger to be enabled or disabled
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_toggle_logger(struct logmod *logmod,
                                           const char *const context_id);

/**
 * @brief Set user data for a logger
 *
 * @param logger Pointer to the logger
 * @param user_data Pointer to user-defined data
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_data(struct logmod_logger *logger,
                                             void *user_data);

/**
 * @brief Set callback function and custom labels for a logger
 *
 * @param logger Pointer to the logger
 * @param custom_labels Array of custom log level labels or NULL
 * @param num_custom_labels Number of custom labels in the array
 * @param callback Callback function for log processing
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err
logmod_logger_set_callback(struct logmod_logger *logger,
                           const struct logmod_label *const custom_labels,
                           const size_t num_custom_labels,
                           logmod_callback callback);

/**
 * @brief Set all options for a logger at once
 *
 * @param logger Pointer to the logger
 * @param options Options structure
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_options(struct logmod_logger *logger,
                                                struct logmod_options options);

/**
 * @brief Set visibility of application ID and context ID in log messages
 *
 * @param logger Pointer to the logger
 * @param show_app_id 1 to show application ID, 0 to hide
 * @param show_context_id 1 to show context ID, 0 to hide
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_id_visibility(
    struct logmod_logger *logger, int show_app_id, int show_context_id);

/**
 * @brief Set quiet mode for a logger
 *
 * @param logger Pointer to the logger
 * @param quiet 1 to enable quiet mode (suppress console output), 0 to disable
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_quiet(struct logmod_logger *logger,
                                              int quiet);

/**
 * @brief Set color mode for a logger
 *
 * @param logger Pointer to the logger
 * @param color 1 to enable colored output, 0 to disable
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_color(struct logmod_logger *logger,
                                              int color);

/**
 * @brief Set minimum log level for a logger
 *
 * @param logger Pointer to the logger
 * @param level Minimum level to log (messages below this will be suppressed)
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_level(struct logmod_logger *logger,
                                              unsigned level);

/**
 * @brief Set logfile for a logger
 *
 * @param logger Pointer to the logger
 * @param logfile File pointer to write logs to, or NULL to disable
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_logfile(struct logmod_logger *logger,
                                                FILE *logfile);

/**
 * @brief Set time display for a logger
 *
 * @param logger Pointer to the logger
 * @param show_time 0 to suppress time in log messages, 1 to show it
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_time(struct logmod_logger *logger,
                                             int show_time);

/**
 * @brief Set counter display for a logger
 *
 * @param logger Pointer to the logger
 * @param show_counter 0 to hide counter in log messages, 1 to show it
 * @return LOGMOD_OK on success, error code on failure
 */
LOGMOD_API logmod_err logmod_logger_set_counter(struct logmod_logger *logger,
                                                int show_counter);

/**
 * @brief Get or create a logger by context ID
 *
 * @param logmod Pointer to the logging context
 * @param context_id Context identifier string
 * @return Pointer to the logger, or NULL if the table is full
 */
LOGMOD_API struct logmod_logger *logmod_get_logger(
    struct logmod *logmod, const char *const context_id);

/**
 * @brief Get the label for a specific log level
 *
 * @param logger Pointer to the logger
 * @param level Log level to get the label for
 * @return Pointer to the label structure, or NULL if invalid
 */
LOGMOD_API const struct logmod_label *logmod_logger_get_label(
    const struct logmod_logger *logger, const unsigned level);

/**
 * @brief Get the level value for a label name
 *
 * @param logger Pointer to the logger
 * @param label Label name to look up
 * @return Level value, or LOGMOD_BAD_PARAMETER if invalid
 */
LOGMOD_API long logmod_logger_get_level(const struct logmod_logger *logger,
                                        const char *const label);

/**
 * @brief Get the global message counter for a logger
 *
 * @param logger Pointer to the logger
 * @return Current counter value, or -1 if logger is NULL
 */
LOGMOD_API long logmod_logger_get_counter(const struct logmod_logger *logger);

/**
 * @brief Log a message (C89 compatible version)
 *
 * @param _level Log level (without LOGMOD_LEVEL_ prefix)
 * @param _logger Logger to use, or NULL for default
 * @param _parenthesized_params Format and arguments in parentheses
 * @param num_params Number of arguments in the format string
 */
#define logmod_nlog(_level, _logger, _parenthesized_params, num_params)       \
    _logmod_log(_logger, __LINE__, __FILE__, LOGMOD_LEVEL_##_level,           \
                LOGMOD_SPREAD_TUPLE_##num_params _parenthesized_params)

#if __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
/**
 * @brief Internal helper macro for C99 variable arguments processing
 *
 * @param _level The log level
 * @param _logger The logger instance
 * @param _line Source line number
 * @param _file Source file path
 * @param _fmt Format string
 * @param ... Additional format arguments
 */
#define _logmod_log_permissive(_level, _logger, _line, _file, _fmt, ...)      \
    _logmod_log(_logger, _line, _file, _level, _fmt "%s", __VA_ARGS__)

/**
 * @brief Log a message with specified level (C99 version with variadic macro
 * support)
 *
 * @param _level Log level (e.g., INFO, DEBUG, ERROR)
 * @param _logger The logger instance or NULL for default logger
 * @param ... Format string followed by format arguments
 */
#define logmod_log(_level, _logger, ...)                                      \
    _logmod_log_permissive(LOGMOD_LEVEL_##_level, _logger, __LINE__,          \
                           __FILE__, __VA_ARGS__, "")
#else
/**
 * @brief Alias to logmod_nlog for C89 compatibility
 */
#define logmod_log logmod_nlog
#endif /* __STDC_VERSION__ */

/**
 * @brief Internal logging implementation function
 *
 * @param logger The logger instance
 * @param line Source line number
 * @param filename Source file path
 * @param level Log level
 * @param fmt Format string
 * @param ... Format arguments
 * @return logmod_err LOGMOD_OK on success, or error code on failure
 */
LOGMOD_API logmod_err _logmod_log(const struct logmod_logger *logger,
                                  const unsigned line,
                                  const char *const filename,
                                  const unsigned level,
                                  const char *fmt,
                                  ...) LOGMOD_PRINTF_LIKE(5, 6);

/**
 * @brief Encodes text with ANSI colors and styles
 *
 * @param _style Style code (LOGMOD_STYLE_* macros)
 * @param _visibility Visibility code (LOGMOD_VISIBILITY_* macros)
 * @param _color Color code (LOGMOD_COLOR_* macros)
 * @param buf Text buffer to encode
 */
#define LOGMOD_ENCODE(_style, _visibility, _color, buf)                       \
    "\x1b[" _style ";" _visibility _color "m" buf "\x1b[0m"

/**
 * @brief Static encoding of text with ANSI colors (compile-time)
 *
 * @param _style Style name (e.g., BOLD, REGULAR)
 * @param _visibility Visibility name (e.g., FOREGROUND, BACKGROUND)
 * @param _color Color name (e.g., RED, GREEN)
 * @param buf The text to encode
 */
#define LOGMOD_ENCODE_STATIC(_style, _visibility, _color, buf)                \
    LOGMOD_ENCODE(LOGMOD_STYLE_##_style, LOGMOD_VISIBILITY_##_visibility,     \
                  LOGMOD_COLOR_##_color, buf)

/**
 * @brief Dynamic encoding of text with ANSI colors (respects toggle)
 *
 * @param _toggle Toggle to enable or disable color encoding
 * @param _style Style name (e.g., BOLD, REGULAR)
 * @param _visibility Visibility name (e.g., FOREGROUND, BACKGROUND)
 * @param _color Color name (e.g., RED, GREEN)
 * @param buf The text to encode
 * @return Colored text if toggle is enabled, or original text otherwise
 */
#define LOGMOD_ENCODE_TOGGLE(_toggle, _style, _visibility, _color, buf)       \
    ((_toggle) ? LOGMOD_ENCODE_STATIC(_style, _visibility, _color, buf) : buf)

/**
 * @brief Dynamic encoding of text with ANSI colors (respects logger color
 * setting)
 *
 * @param _logger The logger instance to check for color enabled setting
 * @param _style Style name (e.g., BOLD, REGULAR)
 * @param _visibility Visibility name (e.g., FOREGROUND, BACKGROUND)
 * @param _color Color name (e.g., RED, GREEN)
 * @param buf The text to encode
 * @return Colored text if colors enabled, or original text otherwise
 */
#define LOGMOD_ENCODE_LOGGER(_logger, _style, _visibility, _color, buf)       \
    LOGMOD_ENCODE_TOGGLE((_logger)->options.color, _style, _visibility,       \
                         _color, buf)

/** @brief Shorthand for LOGMOD_ENCODE_STATIC */
#define LMS LOGMOD_ENCODE_STATIC
/** @brief Shorthand for LOGMOD_ENCODE_TOGGLE */
#define LMT LOGMOD_ENCODE_TOGGLE
/** @brief Shorthand for LOGMOD_ENCODE_LOGGER */
#define LML LOGMOD_ENCODE_LOGGER
/** @brief Shorthand for LOGMOD_ENCODE */
#define LME LOGMOD_ENCODE

#define LOGMOD_SPREAD_TUPLE_0(_fmt)                 _fmt
#define LOGMOD_SPREAD_TUPLE_1(_fmt, _1)             _fmt, _1
#define LOGMOD_SPREAD_TUPLE_2(_fmt, _1, _2)         _fmt, _1, _2
#define LOGMOD_SPREAD_TUPLE_3(_fmt, _1, _2, _3)     _fmt, _1, _2, _3
#define LOGMOD_SPREAD_TUPLE_4(_fmt, _1, _2, _3, _4) _fmt, _2, _3, _4
#define LOGMOD_SPREAD_TUPLE_5(_fmt, _1, _2, _3, _4, _5)                       \
    _fmt, _1, _2, _3, _4, _5
#define LOGMOD_SPREAD_TUPLE_6(_fmt, _1, _2, _3, _4, _5, _6)                   \
    _fmt, _1, _2, _3, _4, _6
#define LOGMOD_SPREAD_TUPLE_7(_fmt, _1, _2, _3, _4, _5, _6, _7)               \
    _fmt, _1, _2, _3, _4, _5, _6, _7
#define LOGMOD_SPREAD_TUPLE_8(_fmt, _1, _2, _3, _4, _5, _6, _7, _8)           \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8
#define LOGMOD_SPREAD_TUPLE_9(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9)       \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9
#define LOGMOD_SPREAD_TUPLE_10(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10
#define LOGMOD_SPREAD_TUPLE_11(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11)                                           \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11
#define LOGMOD_SPREAD_TUPLE_12(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12)                                      \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12
#define LOGMOD_SPREAD_TUPLE_13(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13)                                 \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13
#define LOGMOD_SPREAD_TUPLE_14(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13, _14)                            \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14
#define LOGMOD_SPREAD_TUPLE_15(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13, _14, _15)                       \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15
#define LOGMOD_SPREAD_TUPLE_16(_fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, \
                               _11, _12, _13, _14, _15, _16)                  \
    _fmt, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16

#ifndef LOGMOD_HEADER

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <stddef.h>
#include <string.h>
#include <time.h>

#include "logmod.h"

static const struct logmod_label default_labels[__LOGMOD_LEVEL_MAX] = {
    /*[LOGMOD_LEVEL_TRACE]:*/
    { "TRACE", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND_INTENSITY, BLUE), 0 },
    /*[LOGMOD_LEVEL_DEBUG]:*/
    { "DEBUG", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, CYAN), 0 },
    /*[LOGMOD_LEVEL_INFO]: */
    { "INFO", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, GREEN), 0 },
    /*[LOGMOD_LEVEL_WARN]: */
    { "WARN", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, YELLOW), 1 },
    /*[LOGMOD_LEVEL_ERROR]:*/
    { "ERROR", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, RED), 1 },
    /*[LOGMOD_LEVEL_FATAL]:*/
    { "FATAL", LOGMOD_LABEL_COLOR(REGULAR, BACKGROUND, MAGENTA), 1 },
};

/** @brief Get @ref logmod from any @ref logmod_logger */
#define LOGMOD_FROM_LOGGER(_ctx)                                              \
    ((struct logmod *)((char *)(_ctx)->counter                                \
                       - offsetof(struct logmod, counter)))

#define _LOGMOD_EXPECT(_cond, _error, _return)                                \
    do {                                                                      \
        if (!(_cond)) {                                                       \
            switch ((_error)) {                                               \
            case LOGMOD_BAD_PARAMETER:                                        \
                logmod_nlog(ERROR, NULL, ("Bad parameter: %s", #_cond), 1);   \
                break;                                                        \
            case LOGMOD_ERRNO:                                                \
                logmod_nlog(ERROR, NULL,                                      \
                            ("System error (check errno): %s", #_cond), 1);   \
                break;                                                        \
            default:                                                          \
                logmod_nlog(ERROR, NULL, ("Unknown error: %s", #_cond), 1);   \
                break;                                                        \
            }                                                                 \
            return (_return);                                                 \
        }                                                                     \
    } while (0)

/**
 * @brief Check if a condition is met and log an error message if not
 *
 * @param _cond Condition to check
 * @param _error Error code to return if the condition is false
 */
#define LOGMOD_EXPECT(_cond, _error) _LOGMOD_EXPECT(_cond, _error, _error)

static void
_logmod_lock_noop(const struct logmod_logger *_, int __)
{
    (void)_;
    (void)__;
}

LOGMOD_API logmod_err
logmod_init(struct logmod *logmod,
            const char *const application_id,
            struct logmod_logger table[],
            unsigned length)
{
    size_t *mut_real_length = (size_t *)&logmod->real_length;
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(application_id && *application_id, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(table != NULL, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(length > 0, LOGMOD_BAD_PARAMETER);
    memset(logmod, 0, sizeof *logmod);
    memset(table, 0, length * sizeof *table);
    logmod->application_id = application_id;
    logmod->loggers = table;
    *mut_real_length = length;
    logmod->lock = _logmod_lock_noop;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_cleanup(struct logmod *logmod)
{
    memset((void *)logmod->loggers, 0,
           logmod->real_length * sizeof *logmod->loggers);
    memset(logmod, 0, sizeof *logmod);
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_set_lock(struct logmod *logmod, logmod_lock lock)
{
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    logmod->lock = lock;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_set_options(struct logmod *logmod, struct logmod_options options)
{
    struct logmod_options *mut_default_options =
        (struct logmod_options *)&logmod->default_options;
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    *mut_default_options = options;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_toggle_logger(struct logmod *logmod, const char *const context_id)
{
    struct logmod_mut_logger *mut_logger =
        (struct logmod_mut_logger *)logmod_get_logger(logmod, context_id);
    LOGMOD_EXPECT(mut_logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->disabled = !mut_logger->disabled;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_id_visibility(struct logmod_logger *logger,
                                int show_app_id,
                                int show_context_id)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.show_application_id = show_app_id;
    mut_logger->options.hide_context_id = !show_context_id;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_data(struct logmod_logger *logger, void *user_data)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->user_data = user_data;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_callback(struct logmod_logger *logger,
                           const struct logmod_label *const custom_labels,
                           const size_t num_custom_labels,
                           logmod_callback callback)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->callback = callback;
    if (custom_labels != NULL) {
        LOGMOD_EXPECT(num_custom_labels > 0, LOGMOD_BAD_PARAMETER);
        mut_logger->custom_labels = custom_labels;
        mut_logger->num_custom_labels = num_custom_labels;
    }
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_options(struct logmod_logger *logger,
                          struct logmod_options options)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options = options;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_quiet(struct logmod_logger *logger, int quiet)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.quiet = quiet;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_color(struct logmod_logger *logger, int color)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.color = color;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_level(struct logmod_logger *logger, unsigned level)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.level = level;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_logfile(struct logmod_logger *logger, FILE *logfile)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.logfile = logfile;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_time(struct logmod_logger *logger, int show_time)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.suppress_time = !show_time;
    return LOGMOD_OK;
}

LOGMOD_API logmod_err
logmod_logger_set_counter(struct logmod_logger *logger, int show_counter)
{
    struct logmod_mut_logger *mut_logger = (struct logmod_mut_logger *)logger;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    mut_logger->options.hide_counter = !show_counter;
    return LOGMOD_OK;
}

LOGMOD_API const struct logmod_label *
logmod_logger_get_label(const struct logmod_logger *logger,
                        const unsigned level)
{
    static const struct logmod_label unknown_label = {
        "#UNKNOWN LABEL!!",
        LOGMOD_LABEL_COLOR(STRIKETHROUGH, BACKGROUND_INTENSITY, YELLOW), 1
    };
    if (level < LOGMOD_LEVEL_CUSTOM) {
        return &default_labels[level];
    }
    if (logger && level >= LOGMOD_LEVEL_CUSTOM
        && level < (LOGMOD_LEVEL_CUSTOM + logger->num_custom_labels))
    {
        return &logger->custom_labels[level - LOGMOD_LEVEL_CUSTOM];
    }
    logmod_nlog(ERROR, NULL,
                ("Invalid log level %u for logger %s", level,
                 logger ? logger->context_id : "NULL"),
                2);
    return &unknown_label;
}

LOGMOD_API long
logmod_logger_get_level(const struct logmod_logger *logger,
                        const char *const label)
{
    size_t i;
    LOGMOD_EXPECT(logger != NULL, LOGMOD_BAD_PARAMETER);
    LOGMOD_EXPECT(label != NULL, LOGMOD_BAD_PARAMETER);
    for (i = 0; i < __LOGMOD_LEVEL_MAX; ++i) {
        if (strcmp(label, default_labels[i].name) == 0) {
            return (long)i;
        }
    }
    for (i = 0; i < logger->num_custom_labels; ++i) {
        if (strcmp(label, logger->custom_labels[i].name) == 0) {
            return (long)(i + LOGMOD_LEVEL_CUSTOM);
        }
    }
    return LOGMOD_BAD_PARAMETER;
}

LOGMOD_API long
logmod_logger_get_counter(const struct logmod_logger *logger)
{
    struct logmod *logmod = LOGMOD_FROM_LOGGER(logger);
    long counter;
    LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER);
    logmod->lock(logger, 1);
    counter = logmod->counter;
    logmod->lock(logger, 0);
    return counter;
}

LOGMOD_API struct logmod_logger *
logmod_get_logger(struct logmod *logmod, const char *const context_id)
{
    size_t i;
    _LOGMOD_EXPECT(logmod != NULL, LOGMOD_BAD_PARAMETER, NULL);
    _LOGMOD_EXPECT(logmod->loggers != NULL, LOGMOD_BAD_PARAMETER, NULL);
    _LOGMOD_EXPECT(context_id != NULL, LOGMOD_BAD_PARAMETER, NULL);
    logmod->lock(NULL, 1);
    for (i = 0; i < logmod->length; ++i) {
        if (0 == strcmp(logmod->loggers[i].context_id, context_id)) {
            struct logmod_logger *logger =
                (struct logmod_logger *)&logmod->loggers[i];
            logmod->lock(logger, 0);
            return logger;
        }
    }
    if (logmod->length < logmod->real_length) {
        size_t *mut_length = (size_t *)&logmod->length;
        struct logmod_mut_logger *mut_logger =
            (struct logmod_mut_logger *)&logmod->loggers[logmod->length];
        memset(mut_logger, 0, sizeof *mut_logger);
        mut_logger->context_id = context_id;
        mut_logger->counter = &logmod->counter;
        mut_logger->options = logmod->default_options;
        ++*mut_length;
        logmod->lock((struct logmod_logger *)mut_logger, 0);
        return (struct logmod_logger *)mut_logger;
    }
    logmod->lock(NULL, 0);
    return NULL;
}

static logmod_err
_logmod_print(const struct logmod_logger *logger,
              const struct logmod_info *info,
              const char *fmt,
              va_list args,
              const int color,
              FILE *output)
{
    if (!logger->options.hide_counter) {
        LOGMOD_EXPECT(fprintf(output,
                              LMT(color, BOLD, FOREGROUND, WHITE, "%-3ld "),
                              logmod_logger_get_counter(logger))
                          >= 0,
                      LOGMOD_ERRNO);
    }
    if (!logger->options.suppress_time) {
        LOGMOD_EXPECT(
            fprintf(output,
                    LMT(color, UNDERLINE, FOREGROUND, WHITE, "%02d:%02d:%02d"),
                    info->time.tm_hour, info->time.tm_min, info->time.tm_sec)
                >= 0,
            LOGMOD_ERRNO);
        LOGMOD_EXPECT(putc(' ', output) != EOF, LOGMOD_ERRNO);
    }
    if (logger->options.show_application_id) {
        const struct logmod *logmod = LOGMOD_FROM_LOGGER(logger);
        LOGMOD_EXPECT(fprintf(output,
                              LMT(color, BOLD, FOREGROUND, BLACK, "%s"),
                              logmod->application_id)
                          >= 0,
                      LOGMOD_ERRNO);
        LOGMOD_EXPECT(fputs(LMT(color, BOLD, FOREGROUND, BLACK, " » "), output)
                          != EOF,
                      LOGMOD_ERRNO);
    }
    if (!logger->options.hide_context_id) {
        LOGMOD_EXPECT(fprintf(output,
                              LMT(color, BOLD, FOREGROUND, WHITE, "%s"),
                              logger->context_id)
                          >= 0,
                      LOGMOD_ERRNO);
        LOGMOD_EXPECT(fputs(LMT(color, BOLD, FOREGROUND, WHITE, " » "), output)
                          != EOF,
                      LOGMOD_ERRNO);
    }
    if (color) {
        LOGMOD_EXPECT(fprintf(output,
                              LME("%s", "%s", "%s", "%s") " " LMS(
                                  REGULAR, FOREGROUND, YELLOW,
                                  "%s") LMS(BOLD, FOREGROUND, WHITE, ":")
                                  LMS(REGULAR, FOREGROUND, WHITE, "%d") ": ",
                              info->label->style, info->label->visibility,
                              info->label->color, info->label->name,
                              info->filename, info->line)
                          >= 0,
                      LOGMOD_ERRNO);
    }
    else {
        LOGMOD_EXPECT(fprintf(output, "%s %s:%d: ", info->label->name,
                              info->filename, info->line)
                          >= 0,
                      LOGMOD_ERRNO);
    }
    LOGMOD_EXPECT(vfprintf(output, fmt, args) >= 0, LOGMOD_ERRNO);
    LOGMOD_EXPECT(putc('\n', output) != EOF, LOGMOD_ERRNO);
    LOGMOD_EXPECT(fflush(output) != EOF, LOGMOD_ERRNO);
    return LOGMOD_OK;
}

static struct logmod g_logmod;

/** global logger used as a fallback */
static struct logmod_logger g_loggers[] = {
    {
        LOGMOD_FALLBACK_CONTEXT_ID,
        { NULL, 0, 1 },
        &g_logmod.counter,
        NULL,
        NULL,
        default_labels,
        0,
    },
};
/** global logmod used as a fallback */
static struct logmod g_logmod = {
    LOGMOD_FALLBACK_APPLICATION_ID,
    g_loggers,
    sizeof(g_loggers) / sizeof *g_loggers,
    sizeof(g_loggers) / sizeof *g_loggers,
    0,
    { NULL, 0, 1 },
    _logmod_lock_noop,
};

static struct logmod_info
_logmod_info_populate(const struct logmod_logger *logger,
                      const unsigned line,
                      const char *const filename,
                      const unsigned level)
{
    const struct logmod *logmod = LOGMOD_FROM_LOGGER(logger);
    const time_t time_raw = time(NULL);
    struct logmod_info info;
    unsigned *mut_line = (unsigned *)&info.line;
    const char **mut_filename = (const char **)&info.filename;
    unsigned *mut_level = (unsigned *)&info.level;
    const struct logmod_label **mut_label =
        (const struct logmod_label **)&info.label;
    struct tm *mut_time = (struct tm *)&info.time;
    *mut_line = line;
    *mut_filename = filename;
    *mut_level = level;
    *mut_label = logmod_logger_get_label(logger, level);
    logmod->lock(logger, 1);
    *mut_time = *localtime(&time_raw);
    logmod->lock(logger, 0);
    return info;
}

LOGMOD_API logmod_err
_logmod_log(const struct logmod_logger *logger,
            const unsigned line,
            const char *const filename,
            const unsigned level,
            const char *fmt,
            ...)
{
    struct logmod *logmod =
        LOGMOD_FROM_LOGGER(!logger ? (logger = &g_loggers[0]) : logger);
    logmod_err code = LOGMOD_OK_SKIPPED;
    if (!logger->disabled) {
        const struct logmod_info info =
            _logmod_info_populate(logger, line, filename, level);
        va_list args;
        code = LOGMOD_OK_CONTINUE;
        if (logger->callback) {
            va_start(args, fmt);
            if ((code = logger->callback(logger, &info, fmt, args))
                < LOGMOD_OK)
            {
                goto _end;
            }
            va_end(args);
        }
        if (level >= logger->options.level && code == LOGMOD_OK_CONTINUE) {
            if (!logger->options.quiet || level == LOGMOD_LEVEL_FATAL) {
                va_start(args, fmt);
                if ((code = _logmod_print(
                         logger, &info, fmt, args, logger->options.color,
                         info.label->output == 0 ? stdout : stderr))
                    != LOGMOD_OK)
                {
                    goto _end;
                }
                va_end(args);
            }
            if (logger->options.logfile) {
                va_start(args, fmt);
                code = _logmod_print(logger, &info, fmt, args, 0,
                                     logger->options.logfile);
            }
        }
    _end:
        logmod->lock(logger, 1);
        ++logmod->counter;
        logmod->lock(logger, 0);
        va_end(args);
    }
    return code;
}

#undef LOGMOD_EXPECT

#endif /* LOGMOD_HEADER */

#ifdef __cplusplus
}
#endif /* __cplusplus */

#endif /* LOGMOD_H */