use std::collections::HashMap;

use serde::{Deserialize, Serialize};

#[derive(Debug, Default)]
pub struct PrivateGameOptions {
    pub use_alternate_team_colors: bool,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct GameOptions {
    pub values: HashMap<GameOption, GameOptionValue>,
}

impl Default for GameOptions {
    fn default() -> Self {
        let mut opts = HashMap::new();
        opts.insert(GameOption::AllowAnyMap, GameOptionValue::Boolean(false));
        opts.insert(GameOption::AllowAnyTeam, GameOptionValue::Boolean(false));
        opts.insert(GameOption::FriendlyFire, GameOptionValue::Boolean(true));
        opts.insert(GameOption::GoalsNeededToWin, GameOptionValue::Number(5.));
        opts.insert(GameOption::RespawnTimer, GameOptionValue::Number(5.));
        opts.insert(GameOption::SpawnProtection, GameOptionValue::Number(3.));
        opts.insert(
            GameOption::TelegrenadesAllowed,
            GameOptionValue::Boolean(true),
        );
        Self { values: opts }
    }
}

impl GameOptions {
    pub fn is_true(&self, opt: GameOption) -> bool {
        let opt = self
            .values
            .get(&opt)
            .copied()
            .unwrap_or(GameOptionValue::Boolean(false));
        match opt {
            GameOptionValue::Boolean(value) => value,
            _ => false,
        }
    }

    pub fn get_float(&self, opt: GameOption) -> f64 {
        let opt = self
            .values
            .get(&opt)
            .copied()
            .unwrap_or(GameOptionValue::Number(0.));
        match opt {
            GameOptionValue::Number(value) => value,
            _ => 0.,
        }
    }
}

#[derive(Debug, PartialEq, Eq, PartialOrd, Hash, Copy, Clone, Serialize, Deserialize)]
pub enum GameOption {
    /// Allow anyone to select a map, not just the host
    AllowAnyMap,
    /// Allow anyone to select anyone's team, not just themselves and the host
    AllowAnyTeam,
    /// Allow anyone to shoot anyone, not just other team's members
    FriendlyFire,
    /// The number of goals needed to win a match
    GoalsNeededToWin,
    /// Whether telegrenades are allowed or not.
    TelegrenadesAllowed,
    /// How long in seconds does it take for a player to respawn
    RespawnTimer,
    /// How long in seconds is spawn protected
    SpawnProtection,
}

impl ToString for GameOption {
    fn to_string(&self) -> String {
        match self {
            GameOption::AllowAnyMap => "Allow anyone to select the map",
            GameOption::AllowAnyTeam => "Allow anyone to select any teams",
            GameOption::FriendlyFire => "Friendly fire",
            GameOption::GoalsNeededToWin => "Goals needed to win",
            GameOption::TelegrenadesAllowed => "Telegrenades allowed",
            GameOption::RespawnTimer => "Respawn Time (seconds)",
            GameOption::SpawnProtection => "Spawn Protection",
        }
        .to_owned()
    }
}

#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
pub enum GameOptionValue {
    Boolean(bool),
    Number(f64),
}