oxygen_orbit 0.0.6

use colored::Colorize;
use chrono::prelude::Local;

pub enum LogLevel {
    All,
    Info,
    Warning,
    Error,
    Fatal,
}

pub enum LogMessage<'a> {
    Message(&'a str),
    InfoMessage(&'a str),
    WarningMessage(&'a str),
    ErrorMessage(&'a str),
    FatalMessage(&'a str),
}

pub struct Logger<'a> {
    pub log_name: &'a str,
    pub log_level: LogLevel,
}

impl<'a> Logger<'a> {
    pub fn new(log_name: &'a str, log_level: LogLevel) -> Logger {
        Logger {
            log_name,
            log_level: log_level,
        }
    }

    pub fn set_level(&mut self, log_level: LogLevel) {
        self.log_level = log_level;
    }

    pub fn log(&self, message: LogMessage) {
        let  t_timestamp = format!("{}", Local::now());
        let mut t_timestamp = t_timestamp.split(" ");
        let datetime = t_timestamp.next().unwrap();
        let time = t_timestamp.next().unwrap();
        let mut time_split = time.split(".");

        let timestamp = format!("{} {}.{:.4}", datetime, time_split.next().unwrap(), time_split.next().unwrap());

        let result = match self.log_level {
            LogLevel::All => {
                match message {
                    LogMessage::Message(text) => {
                        (String::from(format!("\n({})[{}] Any: {}\n", self.log_name, timestamp, text))).blue()
                    },
                    LogMessage::InfoMessage(text) => {
                        (String::from(format!("\n({})[{}] Info: {}\n", self.log_name, timestamp, text))).green()
                    },
                    LogMessage::WarningMessage(text) => {
                        (String::from(format!("\n({})[{}] Warning: {}\n", self.log_name, timestamp, text))).yellow()
                    },
                    LogMessage::ErrorMessage(text) => {
                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
                    },
                    LogMessage::FatalMessage(text) => {
                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
                    }
                }
            },
            LogLevel::Info => {
                match message {
                    LogMessage::InfoMessage(text) => {
                        (String::from(format!("\n({})[{}] Info: {}\n", self.log_name, timestamp, text))).green()
                    },
                    LogMessage::WarningMessage(text) => {
                        (String::from(format!("\n({})[{}] Warning: {}\n", self.log_name, timestamp, text))).yellow()
                    },
                    LogMessage::ErrorMessage(text) => {
                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
                    },
                    LogMessage::FatalMessage(text) => {
                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
                    }
                    _ => "".normal(),
                }
            },
            LogLevel::Warning => {
                match message {
                    LogMessage::WarningMessage(text) => {
                        (String::from(format!("\n({})[{}] Warning: {}\n", self.log_name, timestamp, text))).yellow()
                    },
                    LogMessage::ErrorMessage(text) => {
                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
                    },
                    LogMessage::FatalMessage(text) => {
                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
                    },
                    _ => "".normal(),
                }
            },
            LogLevel::Error => {
                match message {
                    LogMessage::ErrorMessage(text) => {
                        (String::from(format!("\n({})[{}] Error: {}\n", self.log_name, timestamp, text))).red()
                    },
                    LogMessage::FatalMessage(text) => {
                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
                    },
                    _ => "".normal(),
                }
            },
            LogLevel::Fatal => {
                match message {
                    LogMessage::FatalMessage(text) => {
                        (String::from(format!("\n({})[{}] Fatal: {}\n", self.log_name, timestamp, text))).black().on_red()
                    },
                    _ => "".normal(),
                }
            }
        };

        print!("{}", result);
    }
}