use std::io;

use modules::EventLoop;
use toml::value::Table;

use {MessageSender, Message, User};

use std::sync::Arc;
use std::sync::mpsc::Receiver;
use transformable_channels::mpsc::ExtSender;

use event::{Event, Envelope};

pub struct StdinModule {}

#[derive(Debug)]
pub struct StdinMessageSender {
    name: String
}

impl MessageSender for StdinMessageSender {
    fn send_message (&self, message: &str) {
        debug!("Send message to stdout: {:?}", message);
        println!("{}: {}", self.name, message);
    }
}

impl StdinModule {
    pub fn new (_: &Table, config: &Table) -> Box<EventLoop> {
        Box::new(StdinModule {})
    }
}

impl EventLoop for StdinModule {
    fn run(&self, sender: Box<ExtSender<Event>>, _: Receiver<Arc<Envelope>>) {
        loop {
            let mut input = String::new();
            match io::stdin().read_line(&mut input) {
                Ok(_) => {
                    let message = Message {
                        author: User {
                            name: String::from("Dave"),
                            sender: Box::new(StdinMessageSender {
                                name: String::from("Dave")
                            })
                        },
                        content: input,
                        channel: None
                    };

                    match sender.send(Event::Message { message: message }) {
                        Err(err) => error!("Error sending message event: {:?}", err),
                        Ok(_) => {}
                    }
                }
                Err(error) => error!("error: {}", error),
            }
        }
    }
}