extern crate regex;
extern crate yaml_rust;

extern crate walkdir;
use walkdir::WalkDir;

use std::io::prelude::*;
use std::fs::File;
use std::env;
use std::path::Path;
use std::collections::HashMap;

mod pre_process;
use pre_process::Section;

mod config;
use config::Config;

mod character;
use character::{Images, Names, Traits, Character};

mod tags;
mod traits;

fn main() {
    let raw_files = env::var("RAW_FILES").unwrap_or("characters".into());
    let base_path = Path::new(&raw_files);

    let cfg = Config::from_file("config.yml", vec!["name", "image", "misc", "tags", "traits"]);

    let mut sections: HashMap<String, Section> = HashMap::new();
    for (name, sec) in &cfg.sections {
        sections.insert(name.clone(), Section::new(&name, &sec.pattern, sec.groups.clone()));
    }

    for entry in WalkDir::new(base_path).min_depth(1).into_iter().filter_map(|e| e.ok()) {
        let mut f = File::open(entry.path()).expect("could not open file");
        let mut buf = String::new();
        if let Err(_) = f.read_to_string(&mut buf) {
            println!("invalid file: {}", entry.path().to_str().unwrap());
            continue;
        }

        let buf = pre_process::strip_irrelevant_content(&buf);

        pre_process::split_sections(&buf, &mut sections);

        {
            let name: &Section = &sections["name".into()];
            let image: &Section = &sections["image".into()];
            let misc: &Section = &sections["misc".into()];
            println!("{:?}", Character {
                name: Names {
                    romaji: name.data["romaji".into()].clone(),
                    japanese: name.data["japanese".into()].clone(),
                    aliases: name.data["aliases".into()].split(", ").map(|s| s.to_string()).collect(),
                },
                image: Images {
                    thumb: image.data["thumb".into()].clone(),
                    full: image.data["full".into()].clone(),
                },
                tags: tags::parse(&(&sections["tags".into()] as &Section).data["tags_raw".into()]),
                traits: Traits {
                    official: traits::parse(&(&sections["traits"] as &Section).data["official_raw".into()]),
                    indexed: traits::parse(&(&sections["traits"] as &Section).data["indexed_raw".into()]),
                },
                role: match misc.data["role".into()].len() > 0 {
                    true => Some(misc.data["role".into()].clone()),
                    false => None
                }
            });
        }
    }
}