use modules::Module;
use toml::Table;

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

use event::{Event, Envelope};

use stc::searchers::{Searcher, AggregateSearcher};
use stc::searchers::yugioh::{YugiohCard, YugiohSearcher};
use stc::searchers::mtg::{MtgCard, MtgSearcher};

use regex::Regex;

pub struct AutolinkModule {}

impl AutolinkModule {
    pub fn new (_: &Table, _: &Table) -> Box<Module> {
        Box::new(AutolinkModule {})
    }
}

impl Module for AutolinkModule {
    fn run (&self, _: Box<ExtSender<Envelope>>, receiver: Receiver<Arc<Envelope>>) {
        let link_regex = Regex::new(r"\[\[([^\[\]]*)\]\]").expect("Invalid regex...");
        let mut searchers = AggregateSearcher::new();
        searchers.add_searcher("mtg", Box::new(MtgSearcher::new()));
        searchers.add_searcher("ygo", Box::new(YugiohSearcher::new()));

        loop {
            match receiver.recv() {
                Ok(envelope) => {
                    match envelope.event {
                        Event::Message { ref message } => {
                            debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
                            for cap in link_regex.captures_iter(&message.content) {
                                if let Some(item) = searchers.exact_search(&cap[1]) {
                                    message.reply(&format!("**Autolink:** {} -> {}", item.label(), item.url()));
                                }
                            }
                        }
                        _ => ()
                    }
                }
                Err(error) => { error!("Error {:?}", error) }
            }
        }
    }
}