use super::tags;
use super::tags::Tag;
use super::dl_list;
use super::dl_list::DLListItem;
use super::section;
use super::section::Section;
use super::regex::Regex;
use super::tiles;

use std::collections::HashMap;

#[derive(Debug)]
pub struct Names {
    pub romaji: String,
    pub japanese: String,
    pub aliases: Vec<String>,
}

#[derive(Debug)]
pub struct Images {
    pub thumb: String,
    pub full: String,
}

#[derive(Debug)]
pub struct Traits {
    pub official: Vec<DLListItem>,
    pub indexed: Vec<DLListItem>,
}

#[derive(Debug)]
pub struct Character {
    pub name: Names,
    pub image: Images,
    pub tags: Vec<Tag>,
    pub traits: Traits,
    pub assignments: Vec<u32>,
    pub chars_similar_traits: Vec<u32>,
    pub extra: Vec<DLListItem>,

    pub role: Option<String>,
}

impl Names {
    pub fn new() -> Self {
        Names { romaji: String::new(), japanese: String::new(), aliases: vec![] }
    }
}

impl Images {
    pub fn new() -> Self {
        Images { thumb: String::new(), full: String::new() }
    }
}

impl Traits {
    pub fn new() -> Self {
        Traits { official: vec![], indexed: vec![] }
    }
}

impl Character {
    pub fn new() -> Self {
        Character {
            name: Names::new(),
            image: Images::new(),
            tags: vec![],
            traits: Traits::new(),
            assignments: vec![],
            chars_similar_traits: vec![],
            extra: vec![],
            role: None
        }
    }

    pub fn parse(&mut self, buf: &str) {
        let re_extras = Regex::new(r#"(?is)Extra Details \| [0-9]+</H3>.*?<dl>(.*?)</dl>"#).unwrap();
        let mut sections = get_sections();    
        section::process(&buf, &mut sections);

        let caps = re_extras.captures(&buf);
        if caps.is_some() {
            self.extra = dl_list::parse(caps.unwrap().at(1).unwrap());
        }

        {
            let name: &Section = &sections["name".into()];
            let image: &Section = &sections["image".into()];
            let misc: &Section = &sections["misc".into()];
            
            self.name.romaji = name.data["romaji".into()].clone();
            self.name.japanese = name.data["japanese".into()].clone();
            
            if name.data["aliases".into()].len() > 0 {
                self.name.aliases = name.data["aliases".into()].split(", ").map(|s| s.to_string()).collect();
            }
            
            self.image.thumb = image.data["thumb".into()].clone();
            self.image.full = image.data["full".into()].clone();
            
            self.tags = tags::parse(&(&sections["tags".into()] as &Section).data["tags_raw".into()]);

            self.traits.official = dl_list::parse(&(&sections["traits"] as &Section).data["official_raw".into()]);
            self.traits.indexed = dl_list::parse(&(&sections["traits"] as &Section).data["indexed_raw".into()]);

            self.assignments = tiles::parse_tile_link_ids(&(&sections["assignments"] as &Section).data["raw".into()], "series");
            self.chars_similar_traits = tiles::parse_tile_link_ids(&(&sections["chars_similar_traits"] as &Section).data["raw".into()], "character");
            
            if misc.data["role".into()].len() > 0 {
                self.role = Some(misc.data["role".into()].clone());
            }
        }
   }
}

fn get_sections() -> HashMap<String, Section> {
    let mut s: HashMap<String, Section> = HashMap::new();

    s.insert("name".into(), Section::new("name", r#"(?is)Romaji Name.*?<TD>(.*?)\s?</TD>.*?Japanese Name.*?<TD>(.*?)\s?</TD>.*?Aliases.*?<TD>(.*?)\s?</TD>"#, vec!["romaji", "japanese", "aliases"]));
    s.insert("misc".into(), Section::new("misc", r#"(?is)Role</TH>.*?<TD>(.*?)\s?</TD>"#, vec!["role"]));
    s.insert("image".into(), Section::new("image", r#"(?is)<H3 id="section99">.*<img src="(.*?)" alt=.*?></a><p><a href="(.*?)">View Full Size Image"#, vec!["thumb", "full"]));
    s.insert("tags".into(), Section::new("tags", r#"(?is)tagged as</P>.*?<TH>(.*?)</TH>"#, vec!["tags_raw"]));
    s.insert("traits".into(), Section::new("traits", r#"(?is)indexed traits</P>.*?<dl>(.*?)</dl>.*?official traits\s?</P>.*?<dl>(.*?)</dl>"#, vec!["indexed_raw", "official_raw"]));
    s.insert("assignments".into(), Section::new("assignments", r#"(?is)appears in the following</P>(.*?)</UL>"#, vec!["raw"]));
    s.insert("chars_similar_traits".into(), Section::new("assignments", r#"(?is)with Similar Traits</H3>(.*?)</UL>"#, vec!["raw"]));

    s
}