fake-log 0.1.0

//! Compatibility example with the log crate
//!
//! This example demonstrates how fake-log provides the same API as the standard log crate.
//! All the types and functions work exactly the same way, but with zero overhead.

use fake_log::{
    debug, error, info, log, log_enabled, logger, max_level, set_logger, set_max_level, trace,
    warn, Level, LevelFilter, Log, Metadata, Record,
};

struct DummyLogger;

impl Log for DummyLogger {
    fn enabled(&self, _metadata: &Metadata) -> bool {
        false // fake-log always returns false anyway
    }

    fn log(&self, _record: &Record) {
        // No-op
    }

    fn flush(&self) {
        // No-op
    }
}

static DUMMY_LOGGER: DummyLogger = DummyLogger;

fn main() {
    println!("=== Log Crate Compatibility Example ===");
    println!("This example shows that fake-log has the same API as the log crate");
    println!();

    // Test log level operations
    test_log_levels();

    // Test logger operations
    test_logger_operations();

    // Test log macros
    test_log_macros();

    // Test log_enabled macro
    test_log_enabled();

    // Test the generic log! macro
    test_generic_log();

    println!("All compatibility tests passed!");
    println!("(All log calls were optimized away by fake-log)");
}

fn test_log_levels() {
    println!("Testing log levels and filters...");

    // Test Level enum
    let levels = [
        Level::Error,
        Level::Warn,
        Level::Info,
        Level::Debug,
        Level::Trace,
    ];
    for level in &levels {
        println!("Level: {:?}", level);
    }

    // Test LevelFilter enum
    let filters = [
        LevelFilter::Off,
        LevelFilter::Error,
        LevelFilter::Warn,
        LevelFilter::Info,
        LevelFilter::Debug,
        LevelFilter::Trace,
    ];
    for filter in &filters {
        println!("Filter: {:?}", filter);
    }

    // Test max_level operations
    println!("Current max level: {:?}", max_level());
    set_max_level(LevelFilter::Debug);
    println!("After setting to Debug: {:?}", max_level());

    println!();
}

fn test_logger_operations() {
    println!("Testing logger operations...");

    // Set logger (no-op in fake-log)
    match set_logger(&DUMMY_LOGGER) {
        Ok(()) => println!("Logger set successfully"),
        Err(e) => println!("Failed to set logger: {}", e),
    }

    // Get logger reference
    let current_logger = logger();

    // Test metadata
    let metadata = Metadata::builder()
        .level(Level::Info)
        .target("test_module")
        .build();

    println!(
        "Logger enabled for metadata: {}",
        current_logger.enabled(&metadata)
    );

    // Test record creation and logging
    let record = Record::builder()
        .level(Level::Info)
        .target("test_module")
        .args(format_args!("Test message"))
        .file(Some("compatibility.rs"))
        .line(Some(42))
        .module_path(Some("examples"))
        .build();

    current_logger.log(&record);
    current_logger.flush();

    println!();
}

fn test_log_macros() {
    println!("Testing log macros (no output expected)...");

    // Standard log macros
    error!("Error message");
    warn!("Warning message");
    info!("Info message");
    debug!("Debug message");
    trace!("Trace message");

    // With target
    error!(target: "auth", "Authentication failed");
    warn!(target: "network", "Network latency high");
    info!(target: "app", "Application started");
    debug!(target: "db", "Database query: SELECT * FROM users");
    trace!(target: "parser", "Parsing token: {:?}", "identifier");

    // With complex formatting
    let user_id = 12345;
    let username = "test_user";
    let response_time = 150;

    info!(
        "User {} (ID: {}) request completed in {}ms",
        username, user_id, response_time
    );
    debug!(
        "Request details: user={}, time={}ms",
        username, response_time
    );

    println!("Log macro test completed (no log output should appear above)");
    println!();
}

fn test_log_enabled() {
    println!("Testing log_enabled macro...");

    // Test log_enabled for different levels
    println!("Error enabled: {}", log_enabled!(Level::Error));
    println!("Warn enabled: {}", log_enabled!(Level::Warn));
    println!("Info enabled: {}", log_enabled!(Level::Info));
    println!("Debug enabled: {}", log_enabled!(Level::Debug));
    println!("Trace enabled: {}", log_enabled!(Level::Trace));

    // Test with target
    println!(
        "Info enabled for 'auth': {}",
        log_enabled!(target: "auth", Level::Info)
    );

    // Conditional logging based on log_enabled
    if log_enabled!(Level::Debug) {
        debug!("This debug message would be logged if enabled");
    } else {
        println!("Debug logging is disabled (expected with fake-log)");
    }

    println!();
}

fn test_generic_log() {
    println!("Testing generic log! macro...");

    // Use the generic log! macro
    log!(Level::Error, "Generic error message");
    log!(Level::Info, "Generic info message with value: {}", 42);
    log!(target: "system", Level::Warn, "Generic warning with target");

    println!("Generic log macro test completed");
    println!();
}