#![allow(dead_code)]
use std::collections::HashMap;
use std::fs::File;
use std::io::Read;
use std::path::PathBuf;
use serde::{Serialize, Deserialize};
use crate::ship::room::{Difficulty, Episode, RoomMode};


#[derive(Debug)]
pub enum MonsterParseError {
    UnknownMonster(String),
}


#[derive(Debug, Serialize, Deserialize, Copy, Clone, Hash, Eq, PartialEq, enum_utils::FromStr, derive_more::Display)]
pub enum MonsterType {
    Hildebear,
    Hildeblue,
    SandRappy,
    RagRappy,
    AlRappy,
    EasterRappy,
    StRappy,
    HalloRappy,
    LoveRappy,
    Monest,
    Mothmant,
    SavageWolf,
    BarbarousWolf,
    Booma,
    Gobooma,
    Gigobooma,
    GrassAssassin,
    DelLily,
    PoisonLily,
    NarLily,
    NanoDragon,
    EvilShark,
    PalShark,
    GuilShark,
    PofuillySlime,
    PouillySlime,
    PanArms,
    Hidoom,
    Migium,
    Dubchic,
    Gillchic,
    Garanz,
    SinowBeat,
    SinowGold,
    Canadine,
    RingCanadine,
    Canane,
    Dubwitch,
    Delsaber,
    ChaosSorcerer,
    BeeR,
    BeeL,
    DarkGunner,
    DeathGunner,
    ChaosBringer,
    DarkBelra,
    Dimenian,
    LaDimenian,
    SoDimenian,
    Bulclaw,
    Bulk,
    Claw,
    Dragon,
    GalGryphon,
    DeRolLe,
    DeRolLeBody,
    DeRolLeMine,
    VolOptPartA,
    VolOptPillar,
    VolOptMonitor,
    VolOptAmp,
    VolOptCore,
    VolOptUnused,
    VolOpt,
    VolOptTrap,
    DarkFalz,
    DarkFalz1,
    DarkFalz2,
    DarkFalz3,
    Darvant,
    UltDarvant,
    OlgaFlow,
    BarbaRay,
    GolDragon,
    SinowBerill,
    SinowSpigell,
    Merillia,
    Meriltas,
    Mericarol,
    Merikle,
    Mericus,
    UlGibbon,
    ZolGibbon,
    Gibbles,
    Gee,
    GiGue,
    Deldepth,
    Delbiter,
    Dolmdarl,
    Dolmolm,
    Morfos,
    Recon,
    Recobox,
    Epsilon,
    Epsiguard,
    SinowZoa,
    SinowZele,
    IllGill,
    Astark,
    SatelliteLizard,
    Yowie,
    MerissaA,
    Girtablulu,
    Zu,
    Boota,
    ZeBoota,
    BaBoota,
    Dorphon,
    Goran,
    PyroGoran,
    GoranDetonator,
    SaintMillion,
    Shambertin,
}


#[derive(serde::Deserialize, Debug)]
pub struct MonsterStats {
    pub atp: u16,
    pub mst: u16,
    pub evp: u16,
    pub hp: u16,
    pub dfp: u16,
    pub ata: u16,
    pub lck: u16,
    pub esp: u16,
    pub exp: u32,
}

fn load_battle_param(filename: &str) -> HashMap<MonsterType, MonsterStats> {
    let mut path = PathBuf::from("data/battle_param/");
    path.push(filename);

    let mut f = File::open(path).unwrap();
    let mut s = String::new();
    f.read_to_string(&mut s).unwrap();
    toml::from_str::<HashMap<String, MonsterStats>>(s.as_str()).unwrap()
        .into_iter()
        .map(|(monster_name, stats)| {
            (monster_name.parse().unwrap(), stats)
        }).collect()
}

pub fn load_monster_stats_table(mode: &RoomMode) -> HashMap<MonsterType, MonsterStats> {
    match mode {
        RoomMode::Multi {episode: Episode::One, difficulty: Difficulty::Normal} => load_battle_param("ep1_multi_normal.toml"),
        RoomMode::Multi {episode: Episode::One, difficulty: Difficulty::Hard} => load_battle_param("ep1_multi_hard.toml"),
        RoomMode::Multi {episode: Episode::One, difficulty: Difficulty::VeryHard} => load_battle_param("ep1_multi_veryhard.toml"),
        RoomMode::Multi {episode: Episode::One, difficulty: Difficulty::Ultimate} => load_battle_param("ep1_multi_ultimate.toml"),
        _ => panic!(),
    }
}