use engine::prelude::*;
use serde::{Deserialize, Serialize};

use crate::components::npc_type::NPCType;

create_settings_section!(
    ExperienceCurveSettings,
    "Curve",
    {
        exponential: f32,
        square: f32,
        linear: f32,
        starting_point: f32,
    },
    Serialize, Deserialize,
);

create_settings_section!(
    MobExperienceSettings,
    "Mobs",
    {
        linear: f32,
        starting_point: f32,
        elite_multiplier: f32,
        boss_multiplier: f32,
    },
    Serialize, Deserialize,
);

create_settings_container!(
    ExperienceSettings,
    {
        mob_experience: MobExperienceSettings,
        experience_curve: ExperienceCurveSettings,
    },
    Serialize, Deserialize,
);

impl ExperienceSettings {
    pub fn player_experience_needed(&self, level: u32) -> u32 {
        let exponential = self.experience_curve.exponential;
        let square = self.experience_curve.square;
        let linear = self.experience_curve.linear;
        let base = self.experience_curve.starting_point;
        let level = level as f32;

        // x^exponential + square * x^2 + linear * x + base
        (level.powf(exponential) + square * level * level + linear * level + base) as u32
    }

    pub fn mob_experience(&self, level: u32, npc_type: impl Into<NPCType>) -> u32 {
        let linear = self.mob_experience.linear;
        let base = self.mob_experience.starting_point;
        let level = level as f32;

        let mut exp = linear * level + base;

        match npc_type.into() {
            NPCType::Normal => (),
            NPCType::Elite => exp *= self.mob_experience.elite_multiplier,
            NPCType::Boss => exp *= self.mob_experience.boss_multiplier,
        }

        exp as u32
    }
}