#![crate_type = "lib"]
#![crate_name = "lolog"]

extern crate log;

use std::io;

use log::{LogRecord, LogLevel, LogMetadata, SetLoggerError};
use std::sync::{Arc, Mutex};

pub struct Logger {
    max_level: LogLevel,
    output: Arc<Mutex<&mut (io::Write + Send)>>,
}

impl log::Log for Logger {
    fn enabled(&self, metadata: &LogMetadata) -> bool {
        metadata.level() <= self.max_level
    }

    fn log(&self, record: &LogRecord) {
        if self.enabled(record.metadata()) {
            let o = self.output.clone();
            let mut f = o.lock().unwrap();

            let err = f.write_all(
                format!("{} - {}", record.level(), record.args()).as_str().as_bytes());
            match err {
                Ok(_) => {},
                Err(e) => { panic!(e) }, // FIXME
            }
        }
    }
}

impl Logger {
    pub fn new<W: io::Write + Send>(
        max_level: LogLevel,
        writer: &mut W,
    ) -> Logger {
        Logger{
            max_level: max_level,
            output: Arc::new(Mutex::new(writer as &mut (io::Write + Send))),
        }
    }

}

pub fn init_logger(logger: &Logger) -> Result<(), SetLoggerError> {
    log::set_logger(|max_log_level| {
        max_log_level.set(logger.max_level.to_log_level_filter());
        Box::new(logger)
    })
}

/*
pub fn init<W: io::Write + Send>(
        max_level: LogLevel,
        writer: &'static mut W,
) -> Result<(), SetLoggerError> {
    log::set_logger(move |max_log_level| {
        let logger = Logger::new(max_level, writer);
        max_log_level.set(max_level.to_log_level_filter());
        Box::new(logger)
    })
}
pub fn init<W: io::Write + Send>(max_level: LogLevel, writer: &'static mut W) -> Result<(), SetLoggerError>
{
    let output = Arc::new(Mutex::new(writer as &mut (io::Write + Send)));
    let logger = Box::new(Logger{
        max_level: max_level,
        output: output,
    });

    log::set_logger(|max_log_level| {
        max_log_level.set(max_level.to_log_level_filter());
        logger
    })
}
*/

#[cfg(test)]
mod test {
    #[test]
    fn it_works() {
    }
}