log4rc 0.2.0

//! # log4rc - A log4j-like logging framework for Rust
//! 
//! This crate provides a simple, extensible logging framework similar to log4j.
//! 
//! ## Example
//! 
//! ```
//! use log4rc::{LogLevel, Logger};
//! 
//! Logger::init(LogLevel::Debug);
//! 
//! log4rc::trace!("This is a trace message");
//! log4rc::debug!("This is a debug message");
//! log4rc::info!("This is an info message");
//! log4rc::warn!("This is a warning message");
//! log4rc::error!("This is an error message");
//! ```

use std::{sync::Mutex, time};

/// Log levels compatible with log4j
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum LogLevel {
    /// The "trace" level.
    Trace,
    /// The "debug" level.
    Debug,
    /// The "info" level.
    Info,
    /// The "warn" level.
    Warn,
    /// The "error" level.
    Error,
}

impl LogLevel {
    /// Returns the string representation of the log level
    pub fn as_str(&self) -> &'static str {
        match self {
            LogLevel::Trace => "TRACE",
            LogLevel::Debug => "DEBUG",
            LogLevel::Info => "INFO",
            LogLevel::Warn => "WARN",
            LogLevel::Error => "ERROR",
        }
    }
}

/// Log event containing all information about a log message
pub struct LogEvent<'a> {
    /// The level of the log event
    pub level: LogLevel,
    /// The message to log
    pub message: &'a str,
    /// The timestamp when the event occurred
    pub timestamp: std::time::SystemTime,
}

/// Trait for formatting log events into strings
pub trait Layout: Send + Sync {
    /// Format a log event into a string
    fn format(&self, event: &LogEvent) -> String;
}

/// Simple layout that formats log events as "\[level\] message"
pub struct SimpleLayout;

impl Layout for SimpleLayout {
    fn format(&self, event: &LogEvent) -> String {
        format!("[{:<5}] {} {}", event.level.as_str(), get_now_str(event.timestamp), event.message)
    }
}

/// Trait for output targets (console, file, etc.)
pub trait Appender: Send + Sync {
    /// Append a log event to the output target
    fn append(&self, event: &LogEvent);
}

/// Console appender that writes to stdout
pub struct ConsoleAppender {
    layout: Box<dyn Layout>,
}

impl ConsoleAppender {
    /// Create a new console appender with a specific layout
    pub fn new(layout: Box<dyn Layout>) -> Self {
        Self { layout }
    }
}

impl Appender for ConsoleAppender {
    fn append(&self, event: &LogEvent) {
        println!("{}", self.layout.format(event));
    }
}

static LOGGER: Mutex<Option<Logger>> = Mutex::new(None);

/// The logger struct that holds the current log level
pub struct Logger {
    level: LogLevel,
    appenders: Vec<Box<dyn Appender>>,
}

/// Builder for configuring a [`Logger`] with custom appenders.
///
/// Construct one with [`Logger::builder`], add appenders, then call
/// [`LoggerBuilder::build`] to get the logger or [`LoggerBuilder::init`] to
/// install it as the global logger.
pub struct LoggerBuilder {
    level: LogLevel,
    appenders: Vec<Box<dyn Appender>>,
}

impl LoggerBuilder {
    /// Set the log level. Defaults to the level passed to [`Logger::builder`].
    pub fn level(mut self, level: LogLevel) -> Self {
        self.level = level;
        self
    }

    /// Add an appender. May be called multiple times to add several appenders.
    pub fn appender(mut self, appender: Box<dyn Appender>) -> Self {
        self.appenders.push(appender);
        self
    }

    /// Build the configured logger.
    pub fn build(self) -> Logger {
        Logger {
            level: self.level,
            appenders: self.appenders,
        }
    }

    /// Build the logger and install it as the global logger,
    /// replacing any previously configured logger.
    pub fn init(self) {
        Logger::set_logger(self.build());
    }
}

fn get_now_str(sys_time: time::SystemTime) -> String {
    use chrono::{Local, DateTime};
    let dt = DateTime::<Local>::from(sys_time);
    dt.format("%Y-%m-%d %H:%M:%S").to_string()
}
impl Logger {
    /// Start building a logger with custom appenders.
    ///
    /// ```
    /// use log4rc::{LogLevel, Logger};
    ///
    /// Logger::builder(LogLevel::Debug)
    ///     .appender(Box::new(log4rc::ConsoleAppender::new(Box::new(log4rc::SimpleLayout))))
    ///     .init();
    /// ```
    pub fn builder(level: LogLevel) -> LoggerBuilder {
        LoggerBuilder {
            level,
            appenders: Vec::new(),
        }
    }

    /// Replace the global logger with a custom-built one.
    pub fn set_logger(logger: Logger) {
        *LOGGER.lock().unwrap_or_else(|e| e.into_inner()) = Some(logger);
    }

    /// Initialize the logger with a specific log level.
    ///
    /// This configures a single [`ConsoleAppender`] with a [`SimpleLayout`].
    /// Calling this again replaces the previous logger, allowing the log level
    /// (and appenders) to be reconfigured at runtime. Use [`Logger::builder`]
    /// for full control over appenders.
    pub fn init(level: LogLevel) {
        Logger::set_logger(Logger {
            level,
            appenders: vec![Box::new(ConsoleAppender::new(Box::new(SimpleLayout)))],
        });
    }

    /// Get a lock on the current logger instance.
    ///
    /// Returns `None` if the logger has not been initialized yet.
    pub fn get() -> std::sync::MutexGuard<'static, Option<Logger>> {
        LOGGER.lock().unwrap_or_else(|e| e.into_inner())
    }

    /// Check if a message at the specified level should be logged
    fn should_log(&self, level: LogLevel) -> bool {
        level >= self.level
    }

    /// Log a message at the specified level
    pub fn log(&self, level: LogLevel, message: &str) {
        if self.should_log(level) {
            let event = LogEvent {
                level,
                message,
                timestamp: std::time::SystemTime::now(),
            };
            
            for appender in &self.appenders {
                appender.append(&event);
            }
        }
    }
}

/// Macro for logging trace messages
#[macro_export]
macro_rules! trace {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get().as_ref() {
            logger.log($crate::LogLevel::Trace, &format!($($arg)*));
        }
    };
}

/// Macro for logging debug messages
#[macro_export]
macro_rules! debug {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get().as_ref() {
            logger.log($crate::LogLevel::Debug, &format!($($arg)*));
        }
    };
}

/// Macro for logging info messages
#[macro_export]
macro_rules! info {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get().as_ref() {
            logger.log($crate::LogLevel::Info, &format!($($arg)*));
        }
    };
}

/// Macro for logging warning messages
#[macro_export]
macro_rules! warn {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get().as_ref() {
            logger.log($crate::LogLevel::Warn, &format!($($arg)*));
        }
    };
}

/// Macro for logging error messages
#[macro_export]
macro_rules! error {
    ($($arg:tt)*) => {
        if let Some(logger) = $crate::Logger::get().as_ref() {
            logger.log($crate::LogLevel::Error, &format!($($arg)*));
        }
    };
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::sync::Arc;

    #[test]
    fn init_reconfigures_logger() {
        Logger::init(LogLevel::Error);
        assert_eq!(Logger::get().as_ref().unwrap().level, LogLevel::Error);

        // A second init should replace the logger rather than silently no-op
        Logger::init(LogLevel::Trace);
        assert_eq!(Logger::get().as_ref().unwrap().level, LogLevel::Trace);
    }

    #[test]
    fn should_log_filters_by_level() {
        Logger::init(LogLevel::Info);
        let guard = Logger::get();
        let logger = guard.as_ref().unwrap();
        assert!(!logger.should_log(LogLevel::Trace));
        assert!(!logger.should_log(LogLevel::Debug));
        assert!(logger.should_log(LogLevel::Info));
        assert!(logger.should_log(LogLevel::Warn));
        assert!(logger.should_log(LogLevel::Error));
    }

    #[test]
    fn custom_appender_receives_events() {
        struct CaptureAppender(Arc<Mutex<Vec<String>>>);

        impl Appender for CaptureAppender {
            fn append(&self, event: &LogEvent) {
                self.0.lock().unwrap().push(event.message.to_string());
            }
        }

        let buffer = Arc::new(Mutex::new(Vec::new()));
        Logger::builder(LogLevel::Info)
            .appender(Box::new(CaptureAppender(buffer.clone())))
            .init();

        crate::info!("hello {}", 42);
        crate::debug!("filtered at Info level");

        let messages = buffer.lock().unwrap();
        assert_eq!(messages.len(), 1);
        assert_eq!(messages[0], "hello 42");
    }
}