use crate::game::listener::Listeners;
use crate::game::role::spy::SpyListener;
use serde::{Deserialize, Serialize};
use std::fmt::{Display, Formatter};

mod spy;

#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
pub enum RoleColor {
    Green,
    Red,
    Blue,
    Purple,
}

impl Display for RoleColor {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            RoleColor::Green => "Green",
            RoleColor::Red => "Red",
            RoleColor::Blue => "Blue",
            RoleColor::Purple => "Purple",
        };

        write!(f, "{}", s)
    }
}

#[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
pub enum Role {
    // Human Roles
    Villager,
    Seer,
    Guardian,
    Jailer,
    Coroner,
    Vigilante,
    Hunter,
    Psychic,
    Miller,
    Herring,
    Spy,
    Jester,
    Mason,
    Shepard,
    // Wolf Roles
    MasterWolf,
    WolfShaman,
    Wolf,
    // Custom Role
    Custom(String, RoleColor),
}

impl Display for Role {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let s = match self {
            Role::Villager => "Villager",
            Role::Seer => "Seer",
            Role::Guardian => "Guardian",
            Role::Jailer => "Jailer",
            Role::Coroner => "Coroner",
            Role::Vigilante => "Vigilante",
            Role::Hunter => "Hunter",
            Role::Psychic => "Psychic",
            Role::Miller => "Miller",
            Role::Herring => "Herring",
            Role::Spy => "Spy",
            Role::Jester => "Jester",
            Role::Mason => "Mason",
            Role::Shepard => "Shepard",
            Role::MasterWolf => "Master Wolf",
            Role::WolfShaman => "Wolf Shaman",
            Role::Wolf => "Wolf",
            Role::Custom(role_name, _) => role_name,
        };

        write!(f, "{}", s)
    }
}

impl Role {
    /// Color as seen by host or seer
    pub fn seer_color(&self) -> RoleColor {
        match self {
            Role::Villager => RoleColor::Green,
            Role::Seer => RoleColor::Blue,
            Role::Guardian => RoleColor::Blue,
            Role::Jailer => RoleColor::Blue,
            Role::Coroner => RoleColor::Blue,
            Role::Vigilante => RoleColor::Blue,
            Role::Hunter => RoleColor::Blue,
            Role::Psychic => RoleColor::Blue,
            Role::Miller => RoleColor::Red,
            Role::Herring => RoleColor::Blue,
            Role::Spy => RoleColor::Blue,
            Role::Jester => RoleColor::Purple,
            Role::Mason => RoleColor::Green,
            Role::Shepard => RoleColor::Green,
            Role::MasterWolf => RoleColor::Green,
            Role::WolfShaman => RoleColor::Red,
            Role::Wolf => RoleColor::Red,
            Role::Custom(_, color) => color.clone(),
        }
    }

    /// Color as seen by player
    pub fn player_color(&self) -> RoleColor {
        match self {
            Role::Miller => RoleColor::Green,
            _ => self.seer_color(),
        }
    }

    /// Role name as seen by the player
    pub fn player_role_name(&self) -> String {
        match self {
            Role::Miller => Role::Villager.to_string(),
            _ => self.to_string(),
        }
    }

    pub fn register_role_listener(&self, listeners: &mut Listeners) {
        #[allow(clippy::single_match)]
        match self {
            Role::Spy => listeners.add_listener(Box::new(SpyListener {})),
            _ => {}
        }
    }
}