use std::io;

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

use {MessageSender, Message, User, Channel};

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

use event::{Event, Envelope};

pub struct StdinModule {
    name: String,
    channel: Option<String>
}

const DEFAULT_NICK: &'static str = "user";

#[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, configuration: &Table) -> Box<EventLoop> {
        Box::new(StdinModule {
            name: configuration.get("name")
                               .and_then(|value| value.as_str())
                               .unwrap_or(DEFAULT_NICK)
                               .to_owned(),
            channel: configuration.get("channel")
                                  .and_then(|value| value.as_str())
                                  .map(String::from)
        })
    }
}

impl EventLoop for StdinModule {
    fn run(&self, sender: Box<ExtSender<Event>>, _: Receiver<Arc<Envelope>>) {
        let name = self.name.clone();
        let channel = self.channel.clone();

        loop {
            let mut input = String::new();
            match io::stdin().read_line(&mut input) {
                Ok(_) => {
                    let message = Message {
                        author: User {
                            name: name.clone(),
                            sender: Box::new(StdinMessageSender {
                                name: name.clone()
                            })
                        },
                        content: input,
                        channel: channel.as_ref().map(|channel| Channel {
                            name: channel.to_owned(),
                            description: "".to_owned(),
                            sender: Box::new(StdinMessageSender {
                                name: channel.clone()
                            }),
                            topic: "".to_owned()
                        })
                    };

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