extern crate base64;
extern crate clap;
extern crate image;
extern crate imageproc;
extern crate itertools;
extern crate md5;
extern crate reqwest;
extern crate rusttype;
extern crate xdg;
#[macro_use]
extern crate quick_error;

use std::error::Error as StdError;
use std::fmt;

mod api;
mod bt;
mod cache;
mod render;

use clap::{App, Arg, ArgMatches};

use api::{Api, Profession, Skill};
use bt::{BuildTemplate, ExtraData, Legend, TraitChoice, Traitline};

const APP_NAME: &str = "kondou";

#[derive(Debug, Clone)]
enum Error {
    ProfessionNotFound(String),
    SkillIdNotFound(u32),
    SkillNotFound(String),
    SpecializationNotFound(String),
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            Error::ProfessionNotFound(ref name) => {
                write!(f, "the profession '{}' could not be found", name)
            }
            Error::SkillIdNotFound(id) => write!(f, "the skill with the ID '{}' was not found", id),
            Error::SkillNotFound(ref name) => {
                write!(f, "the skill with the name '{}' was not found", name)
            }
            Error::SpecializationNotFound(ref name) => write!(
                f,
                "the specialization with the name '{}' was not found",
                name
            ),
        }
    }
}

impl StdError for Error {}

type MainResult<T> = Result<T, Box<dyn StdError>>;

fn find_profession(api: &mut Api, name: &str) -> MainResult<Profession> {
    let profession_ids = api.get_profession_ids()?;
    let lower_name = name.to_lowercase();
    let profession_id = profession_ids
        .iter()
        .find(|id| id.to_lowercase() == lower_name)
        .ok_or_else(|| Error::ProfessionNotFound(name.to_owned()))?
        .clone();

    Ok(api.get_professions(&[profession_id])?.remove(0))
}

fn resolve_skill(api: &mut Api, profession: &Profession, text: &str) -> MainResult<Skill> {
    // Try it as an ID first
    let numeric = text.parse::<u32>();
    if let Ok(num_id) = numeric {
        let exists = profession.skills.iter().any(|s| s.id == num_id);
        if exists {
            return Ok(api.get_skills(&[num_id])?.remove(0));
        } else {
            return Err(Error::SkillIdNotFound(num_id).into());
        }
    }

    // Check all names of the profession skills
    let all_ids = profession.skills.iter().map(|s| s.id).collect::<Vec<_>>();
    let all_skills = api.get_skills(&all_ids)?;
    let lower_text = text.to_lowercase();
    all_skills
        .into_iter()
        .find(|s| s.name.to_lowercase().contains(&lower_text))
        .ok_or_else(|| Error::SkillNotFound(text.to_owned()).into())
}

fn resolve_traitline(api: &mut Api, profession: &Profession, text: &str) -> MainResult<Traitline> {
    let parts = text.split(':').collect::<Vec<_>>();
    assert_eq!(
        parts.len(),
        4,
        "invalid text format passed to resolve_traitline"
    );

    let name = parts[0];
    let lower_name = name.to_lowercase();
    let spec = api
        .get_specializations(&profession.specializations)?
        .into_iter()
        .find(|s| s.name.to_lowercase() == lower_name)
        .ok_or_else(|| Error::SpecializationNotFound(name.to_owned()))?;

    let mut choices = [TraitChoice::None; 3];
    for (i, text_choice) in parts.iter().skip(1).enumerate() {
        let choice = text_choice
            .parse()
            .expect("Argument validation failed us, there is an invalid value here");
        choices[i] = choice;
    }
    Ok((spec, choices))
}

fn run_searching(api: &mut Api, matches: &ArgMatches) -> MainResult<BuildTemplate> {
    let requested_profession = matches
        .value_of("profession")
        .expect("clap handles missing argument");

    let profession = find_profession(api, requested_profession)?;
    let prof_enum = profession
        .name
        .parse()
        .expect("Profession object has unparseable name");

    let legends = matches
        .values_of("legend")
        .map(Iterator::collect::<Vec<_>>)
        .unwrap_or_default()
        .into_iter()
        .map(str::parse)
        .map(Result::unwrap)
        .collect::<Vec<_>>();

    let extra_data = if prof_enum == bt::Profession::Revenant {
        let mut array_legends = [Legend::None; 4];
        for (i, l) in legends.iter().enumerate() {
            array_legends[i] = *l;
        }
        ExtraData::Legends(array_legends)
    } else {
        ExtraData::None
    };

    let skills = if prof_enum != bt::Profession::Revenant {
        matches
            .values_of("skill")
            .map(Iterator::collect::<Vec<_>>)
            .unwrap_or_default()
            .into_iter()
            .map(|s| resolve_skill(api, &profession, s))
            .collect::<Result<Vec<_>, _>>()?
    } else {
        if let Some(l) = legends.first() {
            let l = api.get_legends(&[l.get_api_id().unwrap()])?.remove(0);
            let mut result = Vec::new();
            for skill_id in (&[l.heal]).iter().chain(&l.utilities).chain(&[l.elite]) {
                let skill = api.get_skills(&[*skill_id])?.remove(0);
                result.push(skill);
            }
            result
        } else {
            Vec::new()
        }
    };

    let traitlines = matches
        .values_of("traitline")
        .map(Iterator::collect::<Vec<_>>)
        .unwrap_or_default()
        .into_iter()
        .map(|t| resolve_traitline(api, &profession, t))
        .collect::<Result<Vec<_>, _>>()?;

    assert!(skills.len() <= bt::SKILL_COUNT, "got too many skills");
    assert!(
        traitlines.len() <= bt::TRAITLINE_COUNT,
        "got too many traitlines"
    );

    let build = BuildTemplate::new(prof_enum, &skills, &traitlines, extra_data)
        .expect("BuildTemplate could not be constructed");

    Ok(build)
}

fn validate_traitline_format(input: String) -> Result<(), String> {
    let parts = input.split(':').collect::<Vec<_>>();
    if parts.len() != 4 {
        return Err("traitline format is line:trait_1:trait_2:trait_3".to_owned());
    }

    for part in parts.iter().skip(1) {
        let parsed = part.parse::<TraitChoice>();
        if parsed.is_err() {
            return Err(format!(
                "{} is not a valid trait. Use top, middle or bottom.",
                part
            ));
        }
    }

    Ok(())
}

fn validate_legend(input: String) -> Result<(), String> {
    input
        .parse::<Legend>()
        .map(|_| ())
        .map_err(|_| "invalid legend name".to_owned())
}

fn run() -> MainResult<()> {
    let matches = App::new(APP_NAME)
        .version("0.1")
        .author("Daniel <kingdread@gmx.de>")
        .about("Renders GW2 skills and traits.")
        .arg(
            Arg::with_name("profession")
                .help("Selects which profession to use.")
                .required_unless("chatlink"),
        )
        .arg(
            Arg::with_name("skill")
                .help("Selects a skill based on either the name or the ID.")
                .takes_value(true)
                .number_of_values(1)
                .long("skill")
                .short("s")
                .multiple(true)
                .max_values(bt::SKILL_COUNT as u64),
        )
        .arg(
            Arg::with_name("traitline")
                .help("Selects a traitline.")
                .takes_value(true)
                .number_of_values(1)
                .long("traitline")
                .short("t")
                .multiple(true)
                .validator(validate_traitline_format)
                .max_values(bt::TRAITLINE_COUNT as u64),
        )
        .arg(
            Arg::with_name("legend")
                .help("Selects a revenant legend.")
                .takes_value(true)
                .number_of_values(1)
                .long("legend")
                .short("l")
                .multiple(true)
                .max_values(bt::LEGEND_COUNT as u64)
                .validator(validate_legend),
        )
        .arg(
            Arg::with_name("chatlink")
                .help("Specifies a chat link to parse.")
                .short("c")
                .long("chatlink")
                .takes_value(true)
                .conflicts_with_all(&["profession", "skill"]),
        )
        .arg(
            Arg::with_name("outfile")
                .help("Specifies the output filename")
                .short("o")
                .long("outfile")
                .default_value("buildtemplate.png")
                .takes_value(true),
        )
        .get_matches();

    let mut api = Api::new(cache::FileCache::new());
    let build = match matches.is_present("chatlink") {
        false => run_searching(&mut api, &matches)?,
        true => unimplemented!(),
    };

    println!("Chat code: {}", build.chatlink());

    let mut renderer = render::Renderer::new(&mut api, Default::default());
    let img = renderer.render_buildtemplate(&build).unwrap();
    let filename = matches.value_of("outfile").unwrap();
    img.save(filename)?;

    Ok(())
}

fn main() {
    let result = run();
    if let Err(e) = result {
        eprintln!("[Error] {}", e);
        let mut source = e.source();
        while let Some(s) = source {
            eprintln!("  caused by {}", s);
            source = s.source();
        }
    }
}