use modules::{Module, EventLoop};
use toml::Table;

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

use Message;
use event::{Event, Envelope};

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

use regex::Regex;

pub struct AutolinkModule {}

impl AutolinkModule {
    pub fn new (_: &Table, config: &Table) -> Module {
        Module {
            event_loop: Box::new(AutolinkModule {}),
            module_type: String::from("autolink"),
            config: config.clone()
        }
    }
}

fn print_mtg_card (card: &MtgCard, message: &Message) {
    message.reply(&format!("{}", card.image_url));
    message.reply(&format!("**{}** (**{}**)", card.name, card.cost));
    message.reply(&format!("**{}**", card.typeline));
    message.reply(&format!("{}", card.rules));

    match card.flavor {
        Some(ref flavor) => message.reply(&format!("*{}*", flavor)),
        None => {}
    }

    // 12 March 2017: Is there a better way to do this?
    match card.power {
        Some(ref power) => {
            match card.toughness {
                Some(ref toughness) => {
                    message.reply(&format!("{}/{}", power, toughness));
                },
                None => {}
            }
        }
        None => {}
    }
}

fn print_ygo_card (card: &YugiohCard, message: &Message) {
    match card.family {
        Some(ref family) => {
            message.reply(&format!("**{}** ({})", card.name, family));
        },
        None => {
            message.reply(&format!("**{}**", card.name));
        }
    }

    match card.level {
        Some(ref level) => {
            message.reply(&format!("**Level**: {}", level));
        }
        None => {}
    }

    match card.subtype {
        Some(ref subtype) => {
            message.reply(&format!("**{} - {}**", card.card_type, subtype));
        }
        None => {
            message.reply(&format!("**{}**", card.card_type));
        }
    }

    message.reply(&format!("{}", card.text));

    match card.atk {
        Some(ref atk) => {
            match card.def {
                Some(ref def) => {
                    message.reply(&format!("{}/{}", atk, def));
                },
                None => {}
            }
        }
        None => {}
    }
}

fn print_any_link (link: &Link, message: &Message) {
    message.reply(&format!("**Autolink:** {} -> {}", link.label(), link.url()));
}

impl EventLoop 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()));
        searchers.add_searcher("gp", Box::new(MediawikiSearcher::new(String::from("https://gammapedia.monarch-pass.net/wiki/"))));
        searchers.add_searcher("ip", Box::new(MediawikiSearcher::new(String::from("http://infinitypedia.org/wiki/"))));
        searchers.add_searcher("gcl", Box::new(MediawikiSearcher::new(String::from("https://glitchcity.info/wiki/"))));
        searchers.add_searcher("wp", Box::new(MediawikiSearcher::new(String::from("https://en.wikipedia.org/wiki/"))));

        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]) {
                                    print_any_link(&item, message);
                                    if let Some(card) = item.downcast_ref::<MtgCard>() {
                                        print_mtg_card(card, message);
                                    } else if let Some(card) = item.downcast_ref::<YugiohCard>() {
                                        print_ygo_card(card, message);
                                    }
                                }
                            }
                        }
                        _ => ()
                    }
                }
                Err(error) => { error!("Error {:?}", error) }
            }
        }
    }
}