use uuid::Uuid;

use rand::prelude::*;
use rand::distributions::Alphanumeric;
use std::iter;

use cryp::{Cryp};
use game::{Team};
use skill::{Skill};

#[derive(Debug,Clone,Serialize,Deserialize)]
pub enum PveMode {
    Boss,
    Normal,
    Zone3v2Attack,
    Zone2v2Caster,
    Zone3v3MeleeMiniboss,
    Zone3v3HealerBoss,
}

fn generate_mob(lvl: u8) -> Cryp {
    let mut rng = thread_rng();

    let name: String = iter::repeat(())
        .map(|()| rng.sample(Alphanumeric))
        .take(8)
        .collect();

    // rng panics on min == max
    // let mob_lvl: u8 = match lvl {
    //   1 => 1,
    //   _ => rng.gen_range(lvl.saturating_sub(2), lvl)
    // };

    return Cryp::new()
        .named(&name)
        .level(lvl)
        .create();
}

fn quick_game(mob_lvl: u8, team_size: usize) -> Vec<Cryp> {
    iter::repeat_with(||
            generate_mob(mob_lvl)
                .set_account(Uuid::nil())
                .learn(Skill::Attack))
        .take(team_size)
        .collect::<Vec<Cryp>>()
}

fn zone_3v2_attack(player_lvl: u8) -> Vec<Cryp> {
    let x = Cryp::new()
        .named(&"hench".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .create();

    let y = Cryp::new()
        .named(&"bench".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .create();

    return vec![x, y];
}

fn zone_2v2_caster(player_lvl: u8) -> Vec<Cryp> {
    let x = Cryp::new()
        .named(&"robe".to_string())
        .level(player_lvl)
        .learn(Skill::Blast)
        .create();

    let y = Cryp::new()
        .named(&"wizard hat".to_string())
        .level(player_lvl)
        .learn(Skill::Blast)
        .create();

    return vec![x, y];
}

fn zone_3v3_melee_miniboss(player_lvl: u8) -> Vec<Cryp> {
    let x = Cryp::new()
        .named(&"jungle juice".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .create();

    let y = Cryp::new()
        .named(&"bamboo basher".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .learn(Skill::Stun)
        .create();

    let z = Cryp::new()
        .named(&"lemongrass tea".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .create();

    return vec![x, y, z];
}

fn zone_3v3_healer_boss(player_lvl: u8) -> Vec<Cryp> {
    let x = Cryp::new()
        .named(&"coinage".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .learn(Skill::Evade)
        .learn(Skill::Block)
        .create();

    let y = Cryp::new()
        .named(&"wololo".to_string())
        .level(player_lvl + 1)
        // big strong
        // .learn(Skill::Blast)
        .learn(Skill::Heal)
        .learn(Skill::Triage)
        .create();

    let z = Cryp::new()
        .named(&"quarry".to_string())
        .level(player_lvl)
        .learn(Skill::Attack)
        .learn(Skill::Evade)
        .learn(Skill::Stun)
        .create();

    return vec![x, y, z];
}


pub fn generate_mob_team(mode: PveMode, cryps: &Vec<Cryp>) -> Team {
    let mut mob_team = Team::new(Uuid::nil());

    let cryp_lvl = cryps.iter().max_by_key(|c| c.lvl).unwrap().lvl;
    let team_size = cryps.len();

    let mobs = match mode {
        PveMode::Normal => quick_game(cryp_lvl, team_size),
        PveMode::Boss => quick_game(cryp_lvl + 2, 1),
        PveMode::Zone3v2Attack => zone_3v2_attack(cryp_lvl),
        PveMode::Zone2v2Caster => zone_2v2_caster(cryp_lvl),
        PveMode::Zone3v3MeleeMiniboss => zone_3v3_melee_miniboss(cryp_lvl),
        PveMode::Zone3v3HealerBoss => zone_3v3_healer_boss(cryp_lvl),
    };

    mob_team.set_cryps(mobs);

    return mob_team;

}