outputs 0.0.3

use std::collections::HashMap;
use chrono::prelude::*;

pub struct Log;

impl Log {
    pub fn log(text: &str, kwargs: Option<HashMap<&str, &str>>) {
        let gray = "\x1b[90m"; // ANSI escape code for gray color
        let reset = "\x1b[0m"; // ANSI escape code to reset color

        let log_message = if let Some(kwargs) = kwargs {
            format!(
                "{} {}",
                text,
                kwargs
                    .iter()
                    .map(|(key, value)| format!("{}{}={}{}", gray, key, reset, value))
                    .collect::<Vec<String>>()
                    .join(" ")
            )
        } else {
            text.to_string()
        };

        let timestamp = Log::get_timestamp();
        println!("{}{}{} {}", gray, timestamp, reset, log_message);
    }

    fn get_timestamp() -> String {
        let dt = Local::now();
        dt.format("%H:%M:%S").to_string()
    }
}

macro_rules! testlog {
    ($text:expr, {$($key:expr => $value:expr),*}) => {{
        let mut kwargs = std::collections::HashMap::new();
        $(kwargs.insert($key, $value);)*
        Log::log($text, Some(kwargs));
    }};
}

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

    #[test]
    fn test_log_function() {
        let kwargs = Some({
            let mut kwargs = HashMap::new();
            kwargs.insert("key1", "value1");
            kwargs.insert("key2", "value2");
            kwargs
        });

        Log::log("Test Logging:", kwargs);
        // Include assertions to validate the output or behavior
        // assert_eq!(expected_value, actual_value);
    }

    #[test]
    fn test_log_function_without_kwargs() {
        Log::log("Test Logging without kwargs:", None);
        // Include assertions for scenarios without kwargs
        // assert_eq!(expected_value, actual_value);
    }

    #[test]
    fn test_log_failed_signup_macro() {
        testlog!("Failed to signup", {
            "reason" => "Captcha Detected."
        });
        // Include assertions for the macro usage
        // assert_eq!(expected_value, actual_value);
    }

    #[test]
    fn test_timestamp_function() {
        // Write tests for the timestamp function if needed
        // For example, check the output format, accuracy, etc.
        let timestamp = Log::get_timestamp();
        // assert_eq!(expected_timestamp_format, timestamp);
    }
}