use sb_shared::{Character, CharacterStats, Class, Race};
use crate::spells;

pub struct TrainingGround {
    pub stat: &'static str,
    pub name: &'static str,
    pub description: &'static str,
}

pub const TRAINING_GROUNDS: &[TrainingGround] = &[
    TrainingGround { stat: "strength", name: "The Anvil", description: "Pound steel and lift stone under the guidance of master smiths." },
    TrainingGround { stat: "dexterity", name: "The Archery Range", description: "Sharpen reflexes with bow, blade, and balance drills." },
    TrainingGround { stat: "constitution", name: "The Endurance Pits", description: "Push your body past its limits in grueling trials of resilience." },
    TrainingGround { stat: "intelligence", name: "The Sage's Study", description: "Study ancient tomes and practice arcane disciplines." },
    TrainingGround { stat: "luck", name: "Fortune's Shrine", description: "Consult oracles and tempt fate in games of chance." },
];

pub struct RaceInfo {
    pub race: Race,
    pub name: &'static str,
    pub str_mod: i64,
    pub int_mod: i64,
    pub dex_mod: i64,
    pub con_mod: i64,
    pub luck_mod: i64,
}

pub const RACES: &[RaceInfo] = &[
    RaceInfo { race: Race::Human, name: "Human", str_mod: 0, int_mod: 0, dex_mod: 0, con_mod: 0, luck_mod: 0 },
    RaceInfo { race: Race::Elf, name: "Elf", str_mod: -2, int_mod: 4, dex_mod: 2, con_mod: -2, luck_mod: 0 },
    RaceInfo { race: Race::Dwarf, name: "Dwarf", str_mod: 2, int_mod: -2, dex_mod: -2, con_mod: 4, luck_mod: 0 },
    RaceInfo { race: Race::Hobbit, name: "Hobbit", str_mod: -4, int_mod: 0, dex_mod: 2, con_mod: -2, luck_mod: 4 },
    RaceInfo { race: Race::HalfElf, name: "Half-Elf", str_mod: 0, int_mod: 2, dex_mod: 2, con_mod: 0, luck_mod: 0 },
];

pub struct ClassInfo {
    pub class: Class,
    pub name: &'static str,
    pub primary_stat: &'static str,
    pub secondary_stat: &'static str,
    pub base_hp: i32,
    pub hp_per_con: f64,
}

pub const CLASSES: &[ClassInfo] = &[
    ClassInfo { class: Class::Warrior, name: "Warrior", primary_stat: "strength", secondary_stat: "constitution", base_hp: 20, hp_per_con: 3.0 },
    ClassInfo { class: Class::Paladin, name: "Paladin", primary_stat: "strength", secondary_stat: "luck", base_hp: 18, hp_per_con: 2.5 },
    ClassInfo { class: Class::Rogue, name: "Rogue", primary_stat: "dexterity", secondary_stat: "luck", base_hp: 14, hp_per_con: 2.0 },
    ClassInfo { class: Class::Bard, name: "Bard", primary_stat: "dexterity", secondary_stat: "intelligence", base_hp: 14, hp_per_con: 2.0 },
    ClassInfo { class: Class::Hunter, name: "Hunter", primary_stat: "dexterity", secondary_stat: "strength", base_hp: 16, hp_per_con: 2.5 },
    ClassInfo { class: Class::Monk, name: "Monk", primary_stat: "dexterity", secondary_stat: "constitution", base_hp: 15, hp_per_con: 2.5 },
    ClassInfo { class: Class::Mage, name: "Mage", primary_stat: "intelligence", secondary_stat: "dexterity", base_hp: 11, hp_per_con: 1.8 },
    ClassInfo { class: Class::Wizard, name: "Wizard", primary_stat: "intelligence", secondary_stat: "constitution", base_hp: 10, hp_per_con: 1.5 },
    ClassInfo { class: Class::Conjurer, name: "Conjurer", primary_stat: "intelligence", secondary_stat: "luck", base_hp: 10, hp_per_con: 1.5 },
    ClassInfo { class: Class::Sorcerer, name: "Sorcerer", primary_stat: "intelligence", secondary_stat: "strength", base_hp: 12, hp_per_con: 2.0 },
];

pub fn stat_bonus(stat: i64) -> i64 {
    (stat - 20) / 2
}

fn roll_stat(rng: &mut impl rand::Rng, modifier: i64) -> i64 {
    let base: i64 = rng.random_range(6..=16);
    base + modifier
}

pub fn roll_stats(rng: &mut impl rand::Rng, race: &Race) -> CharacterStats {
    let info = RACES.iter().find(|r| &r.race == race).expect("invalid race");
    CharacterStats {
        strength: roll_stat(rng, info.str_mod),
        intelligence: roll_stat(rng, info.int_mod),
        dexterity: roll_stat(rng, info.dex_mod),
        constitution: roll_stat(rng, info.con_mod),
        luck: roll_stat(rng, info.luck_mod),
    }
}

pub fn calc_max_hp(class: &Class, stats: &CharacterStats) -> i32 {
    let info = CLASSES.iter().find(|c| &c.class == class).expect("invalid class");
    (info.base_hp as f64 + stats.constitution as f64 * info.hp_per_con) as i32
}

pub fn calc_max_energy(class: &Class) -> i32 {
    let info = CLASSES.iter().find(|c| &c.class == class).expect("invalid class");
    30 + info.base_hp / 3
}

pub fn calc_max_nerve(class: &Class) -> i32 {
    let info = CLASSES.iter().find(|c| &c.class == class).expect("invalid class");
    100 + info.base_hp / 2
}

pub fn energy_regen_rate() -> i64 {
    180000
}

pub fn nerve_regen_rate() -> i64 {
    300000
}

pub fn hp_regen_rate() -> i64 {
    300000
}

pub fn apply_regen(char: &mut Character, now_ms: i64) {
    let elapsed = now_ms - char.last_regen;
    if elapsed <= 0 { return; }
    let energy_ticks = (elapsed / energy_regen_rate()) as i32;
    let nerve_ticks = (elapsed / nerve_regen_rate()) as i32;
    let hp_ticks = (elapsed / hp_regen_rate()) as i32;
    if energy_ticks > 0 {
        char.energy = (char.energy + energy_ticks).min(char.max_energy);
    }
    if nerve_ticks > 0 {
        char.nerve = (char.nerve + nerve_ticks).min(char.max_nerve);
    }
    if hp_ticks > 0 && char.hp > 0 && char.hp < char.max_hp {
        let regen_per_tick = (char.max_hp as f64 * 0.05).ceil() as i32;
        char.hp = (char.hp + regen_per_tick * hp_ticks).min(char.max_hp);
    }
    char.last_regen = now_ms;
}

pub fn training_cost(stat: i64) -> i32 {
    let scaled = (stat as f64 / 10.0).floor() as i32;
    (5.0_f64 * 1.3_f64.powi(scaled)) as i32
}

pub fn create_character(
    rng: &mut impl rand::Rng,
    user_id: u32,
    name: String,
    race: Race,
    class: Class,
) -> Character {
    let class_str = class.as_str().to_string();
    let stats = roll_stats(rng, &race);
    let max_hp = calc_max_hp(&class, &stats);
    let max_energy = calc_max_energy(&class);
    let max_nerve = calc_max_nerve(&class);

    let known_spells: Vec<String> = if spells::is_caster_class(&class_str) {
        spells::spells_for_class(&class_str, 1).iter()
            .filter(|s| s.spell_level <= 1)
            .map(|s| s.id.clone())
            .collect()
    } else {
        Vec::new()
    };

    Character {
        id: 0,
        user_id,
        name,
        race,
        class,
        level: 1,
        xp: 0,
        stats,
        hp: max_hp,
        max_hp,
        energy: max_energy,
        max_energy,
        nerve: max_nerve,
        max_nerve,
        gold: 50,
        last_regen: 0,
        equipment: [
            ("head".into(), None),
            ("body".into(), None),
            ("off_hand".into(), None),
            ("main_hand".into(), None),
            ("hands".into(), None),
            ("feet".into(), None),
            ("back".into(), None),
            ("neck".into(), None),
            ("ring".into(), None),
            ("trinket".into(), None),
            ("instrument".into(), None),
        ].into_iter().collect(),
        inventory: Vec::new(),
        active_song: None,
        known_spells,
        active_spell: None,
        spell_points: spells::max_spell_points(&class_str, 1),
        max_spell_points: spells::max_spell_points(&class_str, 1),
    }
}

pub const MAX_LEVEL: i32 = 100;
pub const XP_FACTOR: i64 = 18;

pub fn xp_for_level(level: i32) -> i64 {
    if level <= 1 { return 0; }
    let n = (level - 1) as f64;
    XP_FACTOR * (100.0 * n * n) as i64
}

pub fn level_up_cost(level: i32) -> i32 {
    500 * level
}

pub fn level_up(char: &mut Character) -> Result<i32, &'static str> {
    if char.level >= MAX_LEVEL {
        return Err("already at max level");
    }
    let next_level = char.level + 1;
    if char.xp < xp_for_level(next_level) {
        return Err("not enough XP");
    }
    let cost = level_up_cost(next_level);
    if char.gold < cost {
        return Err("not enough gold");
    }
    char.gold -= cost;
    char.level = next_level;
    let class_str = char.class.as_str().to_string();
    char.max_hp = calc_max_hp(&char.class, &char.stats);
    char.hp = char.max_hp;
    char.max_energy = calc_max_energy(&char.class);
    char.energy = char.max_energy;
    char.max_nerve = calc_max_nerve(&char.class);
    char.nerve = char.max_nerve;
    char.max_spell_points = spells::max_spell_points(&class_str, char.level);
    char.spell_points = char.max_spell_points;
    Ok(char.level)
}

pub fn find_race_info(race: &Race) -> &'static RaceInfo {
    RACES.iter().find(|r| &r.race == race).expect("invalid race")
}

pub fn find_class_info(class: &Class) -> &'static ClassInfo {
    CLASSES.iter().find(|c| &c.class == class).expect("invalid class")
}

#[cfg(test)]
mod tests {
    use super::*;
    use sb_shared::{Character, CharacterStats, Class, Race};
    use std::collections::HashMap;

    fn base_char() -> Character {
        Character {
            id: 1, user_id: 1, name: "Test".into(),
            race: Race::Human, class: Class::Warrior,
            level: 1, xp: 0,
            stats: CharacterStats { strength: 20, intelligence: 20, dexterity: 20, constitution: 20, luck: 20 },
            hp: 80, max_hp: 80, energy: 36, max_energy: 36,
            nerve: 110, max_nerve: 110, gold: 0, last_regen: 0,
            equipment: HashMap::new(), inventory: Vec::new(),
            active_song: None, known_spells: Vec::new(),
            active_spell: None, spell_points: 0, max_spell_points: 0,
        }
    }

    #[test]
    fn stat_bonus_at_20_is_zero() {
        assert_eq!(stat_bonus(20), 0);
    }

    #[test]
    fn stat_bonus_below_20_is_negative() {
        assert_eq!(stat_bonus(10), -5);
        assert_eq!(stat_bonus(1), -9);
    }

    #[test]
    fn stat_bonus_above_20_is_positive() {
        assert_eq!(stat_bonus(30), 5);
        assert_eq!(stat_bonus(100), 40);
    }

    #[test]
    fn stat_bonus_handles_large_values() {
        assert_eq!(stat_bonus(1_000_000_000), 499_999_990);
    }

    #[test]
    fn xp_for_level_1_is_zero() {
        assert_eq!(xp_for_level(1), 0);
    }

    #[test]
    fn xp_for_level_2_is_1800() {
        assert_eq!(xp_for_level(2), 1800);
    }

    #[test]
    fn xp_for_level_scales_subexponentially() {
        assert!(xp_for_level(3) > xp_for_level(2));
        assert!(xp_for_level(5) > xp_for_level(4));
        assert!(xp_for_level(10) > xp_for_level(5));
        assert!(xp_for_level(50) > xp_for_level(25));
    }

    #[test]
    fn xp_for_level_does_not_overflow() {
        assert!(xp_for_level(50) > 0);
        assert!(xp_for_level(50) < i64::MAX / 2);
    }

    #[test]
    fn level_up_fails_at_max_level() {
        let mut c = base_char();
        c.level = MAX_LEVEL;
        c.xp = i64::MAX;
        c.gold = i32::MAX;
        assert_eq!(level_up(&mut c), Err("already at max level"));
    }

    #[test]
    fn level_up_cost_scales() {
        assert_eq!(level_up_cost(2), 1000);
        assert_eq!(level_up_cost(3), 1500);
        assert_eq!(level_up_cost(10), 5000);
    }

    #[test]
    fn level_up_succeeds_with_enough_xp_and_gold() {
        let mut c = base_char();
        c.xp = 1800;
        c.gold = 1000;
        let result = level_up(&mut c);
        assert_eq!(result, Ok(2));
        assert_eq!(c.level, 2);
        assert_eq!(c.gold, 0);
        assert_eq!(c.hp, c.max_hp);
        assert_eq!(c.energy, c.max_energy);
        assert_eq!(c.nerve, c.max_nerve);
    }

    #[test]
    fn level_up_fails_without_enough_xp() {
        let mut c = base_char();
        c.xp = 100;
        c.gold = 10000;
        assert_eq!(level_up(&mut c), Err("not enough XP"));
        assert_eq!(c.level, 1);
        assert_eq!(c.gold, 10000);
    }

    #[test]
    fn level_up_fails_without_enough_gold() {
        let mut c = base_char();
        c.xp = 1800;
        c.gold = 0;
        assert_eq!(level_up(&mut c), Err("not enough gold"));
        assert_eq!(c.level, 1);
    }

    #[test]
    fn calc_max_hp_depends_on_class_and_con() {
        let stats_high = CharacterStats { strength: 10, intelligence: 10, dexterity: 10, constitution: 30, luck: 10 };
        let stats_low = CharacterStats { strength: 10, intelligence: 10, dexterity: 10, constitution: 10, luck: 10 };
        let hp_high = calc_max_hp(&Class::Warrior, &stats_high);
        let hp_low = calc_max_hp(&Class::Warrior, &stats_low);
        assert!(hp_high > hp_low);
    }

    #[test]
    fn calc_max_energy_and_nerve_vary_by_class() {
        let warrior_energy = calc_max_energy(&Class::Warrior);
        let mage_energy = calc_max_energy(&Class::Mage);
        assert!(warrior_energy > mage_energy);
    }

    #[test]
    fn training_cost_scales_with_stat() {
        assert!(training_cost(20) < training_cost(30));
        assert!(training_cost(30) < training_cost(40));
    }

    #[test]
    fn apply_regen_restores_resources() {
        let mut c = base_char();
        c.hp = 40;
        c.energy = 10;
        c.nerve = 50;
        c.last_regen = 0;
        apply_regen(&mut c, 1_800_000);
        assert!(c.energy > 10);
        assert!(c.nerve > 50);
        assert!(c.hp > 40);
    }

    #[test]
    fn apply_regen_no_change_if_no_time_passed() {
        let mut c = base_char();
        c.hp = 40;
        c.last_regen = 1_800_000;
        let before = c.hp;
        apply_regen(&mut c, 1_800_000);
        assert_eq!(c.hp, before);
    }

    #[test]
    fn roll_stats_returns_all_five() {
        use rand:: SeedableRng;
        let mut rng = rand::rngs::StdRng::seed_from_u64(42);
        let stats = roll_stats(&mut rng, &Race::Human);
        assert!(stats.strength >= 6 && stats.strength <= 16);
        assert!(stats.intelligence >= 6 && stats.intelligence <= 16);
        assert!(stats.dexterity >= 6 && stats.dexterity <= 16);
        assert!(stats.constitution >= 6 && stats.constitution <= 16);
        assert!(stats.luck >= 6 && stats.luck <= 16);
    }

    #[test]
    fn race_modifiers_apply() {
        use rand:: SeedableRng;
        let mut rng = rand::rngs::StdRng::seed_from_u64(42);
        let human = roll_stats(&mut rng, &Race::Human);
        let mut rng2 = rand::rngs::StdRng::seed_from_u64(42);
        let dwarf = roll_stats(&mut rng2, &Race::Dwarf);
        assert!(dwarf.constitution > human.constitution);
        assert!(dwarf.strength > human.strength);
        assert!(dwarf.intelligence < human.intelligence);
    }

    #[test]
    fn create_character_is_deterministic_under_seeded_rng() {
        use rand::SeedableRng;
        let first = create_character(
            &mut rand::rngs::StdRng::seed_from_u64(42),
            7,
            "Twin".into(),
            Race::Human,
            Class::Warrior,
        );
        let second = create_character(
            &mut rand::rngs::StdRng::seed_from_u64(42),
            7,
            "Twin".into(),
            Race::Human,
            Class::Warrior,
        );
        assert_eq!(format!("{:?}", first.stats), format!("{:?}", second.stats));
        assert_eq!(first.hp, second.hp);
        assert_eq!(first.max_hp, second.max_hp);
        assert_eq!(first.energy, second.energy);
        assert_eq!(first.nerve, second.nerve);
    }
}