use crate::{StringKey, ValueIdentifiable, ValueIdentifier};
#[doc(inline)]
pub use growth_rates::*;
#[doc(inline)]
pub use items::*;
#[doc(inline)]
pub use libraries::*;
#[doc(inline)]
pub use moves::*;
#[doc(inline)]
pub use natures::*;
#[doc(inline)]
pub use species_data::*;
#[doc(inline)]
pub use statistic_set::*;
#[doc(inline)]
pub use statistics::*;
use std::fmt::{Display, Formatter};

/// Growth rates define how fast a Pokemon can level up.
mod growth_rates;
/// Items are objects which the player can pick up, keep in their Bag, and use in some manner
mod items;
/// The libraries module holds all data storage types.
pub(crate) mod libraries;
/// Moves are actions Pokemon can take in battle.
mod moves;
/// Natures give stat boosts to specific stats.
mod natures;
/// Species data holds base data for species.
mod species_data;
/// Statistic sets are collection of different statistics that can be used by Pokemon in multiple ways.
mod statistic_set;
/// Statistics are numerical values on Pokemon that are used in battle.
mod statistics;

/// A parameter for an effect. This is basically a simple way to dynamically store multiple different
/// primitives on data.
#[derive(PartialEq, Debug)]
#[cfg_attr(feature = "wasm", derive(unique_type_id_derive::UniqueTypeId))]
pub enum EffectParameter {
    /// A boolean value.
    Bool(ValueIdentifier, bool),
    /// An integer value. Stored as a 64 bit int to deal with potentially large numbers.
    Int(ValueIdentifier, i64),
    /// A float value. Stored as a 32 bit float.
    Float(ValueIdentifier, f32),
    /// A string value.
    String(ValueIdentifier, StringKey),
}

impl From<bool> for EffectParameter {
    fn from(b: bool) -> Self {
        EffectParameter::Bool(Default::default(), b)
    }
}

impl From<i64> for EffectParameter {
    fn from(i: i64) -> Self {
        EffectParameter::Int(Default::default(), i)
    }
}

impl From<f32> for EffectParameter {
    fn from(f: f32) -> Self {
        EffectParameter::Float(Default::default(), f)
    }
}

impl From<StringKey> for EffectParameter {
    fn from(s: StringKey) -> Self {
        EffectParameter::String(Default::default(), s)
    }
}

impl Display for EffectParameter {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            EffectParameter::Bool(_, v) => f.write_fmt(format_args!("EffectParameter::Bool({})", v)),
            EffectParameter::Int(_, v) => f.write_fmt(format_args!("EffectParameter::Int({})", v)),
            EffectParameter::Float(_, v) => f.write_fmt(format_args!("EffectParameter::Float({})", v)),
            EffectParameter::String(_, v) => f.write_fmt(format_args!("EffectParameter::String({})", v)),
        }
    }
}

impl ValueIdentifiable for EffectParameter {
    fn value_identifier(&self) -> ValueIdentifier {
        match self {
            EffectParameter::Bool(i, _) => *i,
            EffectParameter::Int(i, _) => *i,
            EffectParameter::Float(i, _) => *i,
            EffectParameter::String(i, _) => *i,
        }
    }
}