use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use std::convert::TryInto;
use serde::Deserialize;
use rand::{Rng, SeedableRng};
use rand::distributions::{WeightedIndex, Distribution};
use entity::item::ItemDetail;
use entity::item::armor::{Armor, ArmorType};
use entity::item::shield::{Shield, ShieldType};
use entity::item::unit::{Unit, UnitType};
use crate::ShopItem;
use stats::items::{ARMOR_STATS, SHIELD_STATS, UNIT_STATS};

// #[derive(Debug)]
// pub enum ArmorShopItem {
//     Frame(ArmorType, usize), // slots
//     Barrier(ShieldType),
//     Unit(UnitType),
// }

#[derive(Debug)]
pub enum ArmorShopItem {
    Frame(Armor), // slots
    Barrier(Shield),
    Unit(Unit),
}

const ARMOR_MULTIPLIER: f32 = 0.799_999_95;
const SHIELD_MULTIPLIER: f32 = 1.5;
const UNIT_MULTIPLIER: f32 = 1000.0;

// TODO: reduce the number of type casts?
impl ShopItem for ArmorShopItem {
    fn price(&self) -> usize {
        match self {
            ArmorShopItem::Frame(frame) => {
                ARMOR_STATS.get(&frame.armor)
                    .map(|frame_stats| {
                        let mut price = (frame_stats.dfp + frame_stats.evp + frame.dfp as i32 + frame.evp as i32) as f32;
                        price *= price;
                        price /= ARMOR_MULTIPLIER;
                        price += 70.0 * (frame_stats.level_req + 1) as f32;
                        price += 70.0 * (frame_stats.level_req + 1) as f32 * frame.slots as f32;
                        price as usize
                    })
                    .unwrap_or(0xFFFF)
            },
            ArmorShopItem::Barrier(barrier) => {
                SHIELD_STATS.get(&barrier.shield)
                    .map(|barrier_stats| {
                        let mut price = (barrier_stats.dfp + barrier_stats.evp + barrier.dfp as i32 + barrier.evp as i32) as f32;
                        price *= price;
                        price /= SHIELD_MULTIPLIER;
                        price += 70.0 * (barrier_stats.level_req + 1) as f32;
                        price as usize
                    })
                    .unwrap_or(0xFFFF)
            },
            ArmorShopItem::Unit(unit) => {
                UNIT_STATS.get(&unit.unit)
                    .map(|unit_stats| {
                        ((unit_stats.stars as f32 + unit.modifier_stars() as f32) * UNIT_MULTIPLIER) as usize
                    })
                    .unwrap_or(0xFFFF)
            }
        }
    }

    fn as_bytes(&self) -> [u8; 12] {
        self.as_item().as_client_bytes()[0..12].try_into().unwrap()
    }

    fn as_item(&self) -> ItemDetail {
        match self {
            ArmorShopItem::Frame(frame) => {
                ItemDetail::Armor(Armor {
                    armor: frame.armor,
                    dfp: 0,
                    evp: 0,
                    slots: frame.slots,
                })
            },
            ArmorShopItem::Barrier(barrier) => {
                ItemDetail::Shield(Shield {
                    shield: barrier.shield,
                    dfp: 0,
                    evp: 0,
                })
            },
            ArmorShopItem::Unit(unit) => {
                ItemDetail::Unit(Unit {
                    unit: unit.unit,
                    modifier: None,
                })
            },
        }
    }
}

impl From<&Armor> for ArmorShopItem {
    fn from(armor: &Armor) -> ArmorShopItem {
        ArmorShopItem::Frame(*armor)
    }
}

impl From<&Shield> for ArmorShopItem {
    fn from(shield: &Shield) -> ArmorShopItem {
        ArmorShopItem::Barrier(*shield)
    }
}

impl From<&Unit> for ArmorShopItem {
    fn from(unit: &Unit) -> ArmorShopItem {
        ArmorShopItem::Unit(*unit)
    }
}


#[derive(Debug, Deserialize, Clone)]
struct FrameTierItem {
    item: ArmorType,
    probability: usize,
}

#[derive(Debug, Deserialize, Clone)]
struct FrameTier {
    level: usize,
    item: Vec<FrameTierItem>,
}

#[derive(Debug, Deserialize)]
struct SlotRate {
    slot: usize,
    probability: usize,
}

#[derive(Debug, Deserialize)]
struct FrameTable {
    frame: Vec<FrameTier>,
    slot_rate: Vec<SlotRate>,
}


#[derive(Debug, Deserialize, Clone)]
struct BarrierTierItem {
    item: ShieldType,
    probability: usize,
}

#[derive(Debug, Deserialize, Clone)]
struct BarrierTier {
    level: usize,
    item: Vec<BarrierTierItem>,
}

#[derive(Debug, Deserialize)]
struct BarrierTable {
    barrier: Vec<BarrierTier>,
}

#[derive(Debug, Deserialize, Clone)]
struct UnitTierItem {
    item: UnitType,
    probability: usize,
}

#[derive(Debug, Deserialize, Clone)]
struct UnitTier {
    level: usize,
    item: Vec<UnitTierItem>,
}

#[derive(Debug, Deserialize)]
struct UnitTable {
    unit: Vec<UnitTier>,
}



fn load_frame_table() -> FrameTable {
    let path = PathBuf::from("data/shops/frame.toml");
    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();

    let table: FrameTable = toml::from_str(s.as_str()).unwrap();
    table
}

fn load_barrier_table() -> BarrierTable {
    let path = PathBuf::from("data/shops/barrier.toml");
    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();

    let table: BarrierTable = toml::from_str(s.as_str()).unwrap();
    table
}

fn load_unit_table() -> UnitTable {
    let path = PathBuf::from("data/shops/unit.toml");
    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();

    let table: UnitTable = toml::from_str(s.as_str()).unwrap();
    table
}


fn number_of_frames_to_generate(character_level: usize) -> usize {
    if character_level <= 10 {
        4
    }
    else if character_level <= 25 {
        6
    }
    else if character_level <= 42 {
        7
    }
    else {
        8
    }
}

fn number_of_barriers_to_generate(character_level: usize) -> usize {
    if character_level <= 10 {
        4
    }
    else if character_level <= 25 {
        5
    }
    else if character_level <= 42 {
        6
    }
    else {
        7
    }
}

fn number_of_units_to_generate(character_level: usize) -> usize {
    if character_level <= 10 {
        0
    }
    else if character_level <= 25 {
        3
    }
    else if character_level <= 42 {
        5
    }
    else {
        6
    }
}

#[derive(Debug)]
pub struct ArmorShop<R: Rng + SeedableRng> {
    frame: FrameTable,
    barrier: BarrierTable,
    unit: UnitTable,
    rng: R,
}

impl<R: Rng + SeedableRng> Default for ArmorShop<R> {
    fn default() -> ArmorShop<R> {
        ArmorShop {
            frame: load_frame_table(),
            barrier: load_barrier_table(),
            unit: load_unit_table(),
            rng: R::from_entropy(),
        }
    }
}

impl<R: Rng + SeedableRng> ArmorShop<R> {
    fn generate_frame_list(&mut self, character_level: usize) -> Vec<ArmorShopItem> {
        let tier = self.frame.frame.iter()
            .filter(|t| t.level <= character_level)
            .last()
            .cloned()
            .unwrap();

        let frame_choice = WeightedIndex::new(tier.item.iter().map(|f| f.probability)).unwrap();
        let slot_choice = WeightedIndex::new(self.frame.slot_rate.iter().map(|sr| sr.probability)).unwrap();
        (0..number_of_frames_to_generate(character_level))
            .map(|_| {
                let frame_detail = tier.item.get(frame_choice.sample(&mut self.rng)).unwrap();
                let slot = self.frame.slot_rate.get(slot_choice.sample(&mut self.rng)).unwrap();

                ArmorShopItem::Frame(Armor {
                    armor: frame_detail.item,
                    dfp: 0,
                    evp: 0,
                    slots: slot.slot as u8,
                })
            })
            .collect()
    }

    fn generate_barrier_list(&mut self, character_level: usize) -> Vec<ArmorShopItem> {
        let tier = self.barrier.barrier.iter()
            .filter(|t| t.level <= character_level)
            .last()
            .cloned()
            .unwrap();

        let barrier_choice = WeightedIndex::new(tier.item.iter().map(|b| b.probability)).unwrap();
        (0..number_of_barriers_to_generate(character_level))
            .map(|_| {
                let barrier_detail = tier.item.get(barrier_choice.sample(&mut self.rng)).unwrap();

                ArmorShopItem::Barrier(Shield {
                    shield: barrier_detail.item,
                    dfp: 0,
                    evp: 0,
                })
            })
            .collect()
    }

    fn generate_unit_list(&mut self, character_level: usize) -> Vec<ArmorShopItem> {
        self.unit.unit.iter()
            .filter(|t| t.level <= character_level)
            .last()
            .cloned()
            .map(|tier| {
                let unit_choice = WeightedIndex::new(tier.item.iter().map(|u| u.probability)).unwrap();
                (0..number_of_units_to_generate(character_level))
                    .map(|_| {
                        let unit_detail = tier.item.get(unit_choice.sample(&mut self.rng)).unwrap();

                ArmorShopItem::Unit(Unit {
                    unit: unit_detail.item,
                    modifier: None,
                })
                    })
                    .collect()
            })
            .unwrap_or_else(Vec::new)
    }

    pub fn generate_armor_list(&mut self, character_level: usize) -> Vec<ArmorShopItem> {
        self.generate_frame_list(character_level).into_iter()
            .chain(self.generate_barrier_list(character_level))
            .chain(self.generate_unit_list(character_level))
            .collect()
    }
}



#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_loading_tool_shop() {
        ArmorShop::<rand_chacha::ChaCha20Rng>::default();
    }

    #[test]
    fn test_generating_some_armor() {
        let mut fs = ArmorShop::<rand_chacha::ChaCha20Rng>::default();
        for i in 0..200 {
            fs.generate_armor_list(i);
        }
    }
}