use modules::EventLoop;
use toml::value::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::MediawikiSearcher;

use regex::Regex;
use std::collections::BTreeMap;

const DEFAULT_PATTERN: &str = r"\[\[([^\[\]]*)\]\]";

pub struct AutolinkModule {
    searcher_config: Table,
    pattern: Regex
}

impl AutolinkModule {
    pub fn new (_: &Table, configuration: &Table) -> Box<EventLoop> {
        let searcher_config = configuration.get("searchers").expect("No configuration for searcher found")
                                           .as_table().expect("Searcher config must be a table");

        let pattern = configuration.get("pattern")
                                   .and_then(|value| value.as_str())
                                   .or(Some(DEFAULT_PATTERN))
                                   .map(String::from)
                                   .and_then(|value| Regex::new(&value).ok())
                                   .expect("Invalid value for pattern");

        Box::new(AutolinkModule {
            searcher_config: searcher_config.clone(),
            pattern: pattern
        })
    }
}

fn create_searcher (configuration: &Table) -> AggregateSearcher {
    let mut searchers = AggregateSearcher::new();
    for (prefix, searcher_config) in configuration.iter() {
        if let Some(searcher_type) = searcher_config.get("type") {
            match searcher_type.as_str() {
                Some("mtg") => searchers.add_searcher(prefix, Box::new(MtgSearcher::new())),
                Some("ygo") => searchers.add_searcher(prefix, Box::new(YugiohSearcher::new())),
                Some("wiki") => {
                    if let Some(url) = searcher_config.get("url") {
                        match url.as_str() {
                            Some(url) => searchers.add_searcher(prefix, Box::new(MediawikiSearcher::new(url.to_owned()))),
                            None =>  warn!("Missing url for wiki searcher {}", prefix)
                        }
                    }
                },
                Some(unknown_type) => info!("Unrecognized searcher type {} for {}", unknown_type, prefix),
                None => warn!("No searcher type given for {}", prefix)
            }
        }
    }
    searchers
}

fn print_mtg_card (card: &MtgCard, message: &Message) {
    if let Some(ref image_uri) = card.image_uris.get("normal") {
        message.reply(&format!("{}", image_uri));
    }

    if let Some(ref cost) = card.mana_cost {
        message.reply(&format!("**{}** (**{}**)", card.name, cost));
    } else {
        message.reply(&format!("**{}**", card.name));
    }

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

    if let Some(ref rules) = card.oracle_text {
        message.reply(&format!("{}", rules));
    }

    if let Some(ref flavor) = card.flavor_text {
        message.reply(&format!("*{}*", flavor));
    }

    if let (&Some(ref power), &Some(ref toughness)) = (&card.power, &card.toughness) {
        message.reply(&format!("{}/{}", power, toughness));
    }
}

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

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

    if let Some(ref subtype) = card.subtype {
        message.reply(&format!("**{} - {}**", card.card_type, subtype));
    } else {
        message.reply(&format!("**{}**", card.card_type));
    }

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

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

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<Event>>, receiver: Receiver<Arc<Envelope>>) {
        let searcher = create_searcher(&self.searcher_config);
        let mut searcher_cache = BTreeMap::new();

        loop {
            match receiver.recv() {
                Ok(envelope) => {
                    if let Event::Message { ref message } = envelope.event {
                        debug!("Received message from module {:?}... {:?}", envelope.from, message.content);
                        for cap in self.pattern.captures_iter(&message.content) {
                            let term = cap[1].to_owned();
                            if let &mut Some(ref mut item) = searcher_cache.entry(term.to_owned()).or_insert_with(|| searcher.exact_search(&term)) {
                                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) }
            }
        }
    }
}