use discord;
use discord::Discord;
use discord::model::Event;

use plugins::Plugin;
use toml::Table;

use event;
use std::sync::mpsc::Sender;

use MessageSender;
use User;
use Channel;

pub struct DiscordPlugin {
    token: String
}

impl DiscordPlugin {
    pub fn new (configuration: &Table) -> Box<Plugin> {
        let token = configuration.get("token")
                                 .and_then(|value| value.as_str())
                                 .unwrap_or("");

        Box::new(DiscordPlugin {
            token: String::from(token)
        })
    }
}

#[derive(Clone)]
pub struct DiscordMessageSender {
    name: String
}

impl MessageSender for DiscordMessageSender {
    fn box_clone (&self) -> Box<MessageSender> {
        Box::new((*self).clone())
    }

    fn send_message (&self, message: &str) {
        println!("send to {:?}: {:?}", self.name, message);
    }
}

impl Plugin for DiscordPlugin {
    fn produce_events<'a>(&'a self, sender: Sender<event::Event>) {
        let discord = Discord::from_bot_token(&self.token[..]).expect("Login failed");
        let (mut connection, _) = discord.connect().expect("Connection failed");
        loop {
            match connection.recv_event() {
                Ok(Event::MessageCreate(message)) => {
                    let author = User {
                        name: message.author.name.clone(),
                        sender: Box::new(DiscordMessageSender {
                            name: message.author.name
                        })
                    };

                    let channel = Channel {
                        name: String::from("channel"),
                        description: String::from(""),
                        topic: String::from(""),
                        sender: Box::new(DiscordMessageSender {
                            name: String::from("channel")
                        })
                    };

                    sender.send(event::Event::Message { sender: author, content: message.content, channel: Option::Some(channel) });
                }
    			Ok(_) => {}
    			Err(discord::Error::Closed(code, body)) => {
	                println!("Gateway closed on us with code {:?}: {}", code, body);
    				break
    			}
    			Err(err) => println!("Receive error: {:?}", err)
            }
        }
    }
}