use serde_derive::{Deserialize, Serialize};

pub const MAX_HEDGEHOGS_PER_TEAM: u8 = 8;

#[derive(PartialEq, Eq, Clone, Debug)]
pub enum ServerVar {
    MOTDNew(String),
    MOTDOld(String),
    LatestProto(u16),
}

#[derive(PartialEq, Eq, Clone, Debug)]
pub enum GameCfg {
    FeatureSize(u32),
    MapType(String),
    MapGenerator(u32),
    MazeSize(u32),
    Seed(String),
    Template(u32),

    Ammo(String, Option<String>),
    Scheme(String, Vec<String>),
    Script(String),
    Theme(String),
    DrawnMap(String),
}

#[derive(PartialEq, Eq, Clone, Debug, Default)]
pub struct TeamInfo {
    pub owner: String,
    pub name: String,
    pub color: u8,
    pub grave: String,
    pub fort: String,
    pub voice_pack: String,
    pub flag: String,
    pub difficulty: u8,
    pub hedgehogs_number: u8,
    pub hedgehogs: [HedgehogInfo; MAX_HEDGEHOGS_PER_TEAM as usize],
}

#[derive(PartialEq, Eq, Clone, Debug, Default)]
pub struct HedgehogInfo {
    pub name: String,
    pub hat: String,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Ammo {
    pub name: String,
    pub settings: Option<String>,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct Scheme {
    pub name: String,
    pub settings: Vec<String>,
}

#[derive(Clone, Serialize, Deserialize, Debug)]
pub struct RoomConfig {
    pub feature_size: u32,
    pub map_type: String,
    pub map_generator: u32,
    pub maze_size: u32,
    pub seed: String,
    pub template: u32,

    pub ammo: Ammo,
    pub scheme: Scheme,
    pub script: String,
    pub theme: String,
    pub drawn_map: Option<String>,
}

impl RoomConfig {
    pub fn new() -> RoomConfig {
        RoomConfig {
            feature_size: 12,
            map_type: "+rnd+".to_string(),
            map_generator: 0,
            maze_size: 0,
            seed: "seed".to_string(),
            template: 0,

            ammo: Ammo {
                name: "Default".to_string(),
                settings: None,
            },
            scheme: Scheme {
                name: "Default".to_string(),
                settings: Vec::new(),
            },
            script: "Normal".to_string(),
            theme: "\u{1f994}".to_string(),
            drawn_map: None,
        }
    }

    pub fn set_config(&mut self, cfg: GameCfg) {
        match cfg {
            GameCfg::FeatureSize(s) => self.feature_size = s,
            GameCfg::MapType(t) => self.map_type = t,
            GameCfg::MapGenerator(g) => self.map_generator = g,
            GameCfg::MazeSize(s) => self.maze_size = s,
            GameCfg::Seed(s) => self.seed = s,
            GameCfg::Template(t) => self.template = t,

            GameCfg::Ammo(n, s) => {
                self.ammo = Ammo {
                    name: n,
                    settings: s,
                }
            }
            GameCfg::Scheme(n, s) => {
                self.scheme = Scheme {
                    name: n,
                    settings: s,
                }
            }
            GameCfg::Script(s) => self.script = s,
            GameCfg::Theme(t) => self.theme = t,
            GameCfg::DrawnMap(m) => self.drawn_map = Some(m),
        };
    }

    pub fn to_map_config(&self) -> Vec<String> {
        vec![
            self.feature_size.to_string(),
            self.map_type.to_string(),
            self.map_generator.to_string(),
            self.maze_size.to_string(),
            self.seed.to_string(),
            self.template.to_string(),
        ]
    }

    pub fn to_game_config(&self) -> Vec<GameCfg> {
        use GameCfg::*;
        let mut v = vec![
            Ammo(self.ammo.name.to_string(), self.ammo.settings.clone()),
            Scheme(self.scheme.name.to_string(), self.scheme.settings.clone()),
            Script(self.script.to_string()),
            Theme(self.theme.to_string()),
        ];
        if let Some(ref m) = self.drawn_map {
            v.push(DrawnMap(m.to_string()))
        }
        v
    }
}

#[derive(PartialEq, Eq, Clone, Debug)]
pub enum VoteType {
    Kick(String),
    Map(Option<String>),
    Pause,
    NewSeed,
    HedgehogsPerTeam(u8),
}

pub struct Vote {
    pub is_pro: bool,
    pub is_forced: bool,
}

//#[cfg(test)]
#[macro_use]
pub mod testing {
    use crate::types::ServerVar::*;
    use crate::types::*;
    use proptest::{
        arbitrary::{any, Arbitrary},
        strategy::{BoxedStrategy, Just, Strategy},
    };

    // Due to inability to define From between Options
    pub trait Into2<T>: Sized {
        fn into2(self) -> T;
    }
    impl<T> Into2<T> for T {
        fn into2(self) -> T {
            self
        }
    }
    impl Into2<Vec<String>> for Vec<Ascii> {
        fn into2(self) -> Vec<String> {
            self.into_iter().map(|x| x.0).collect()
        }
    }
    impl Into2<String> for Ascii {
        fn into2(self) -> String {
            self.0
        }
    }
    impl Into2<Option<String>> for Option<Ascii> {
        fn into2(self) -> Option<String> {
            self.map(|x| x.0)
        }
    }

    #[macro_export]
    macro_rules! proto_msg_case {
        ($val: ident()) => {
            Just($val)
        };
        ($val: ident($arg: ty)) => {
            any::<$arg>().prop_map(|v| $val(v.into2()))
        };
        ($val: ident($arg1: ty, $arg2: ty)) => {
            any::<($arg1, $arg2)>().prop_map(|v| $val(v.0.into2(), v.1.into2()))
        };
        ($val: ident($arg1: ty, $arg2: ty, $arg3: ty)) => {
            any::<($arg1, $arg2, $arg3)>().prop_map(|v| $val(v.0.into2(), v.1.into2(), v.2.into2()))
        };
    }

    #[macro_export]
    macro_rules! proto_msg_match {
    ($var: expr, def = $default: expr, $($num: expr => $constr: ident $res: tt),*) => (
        match $var {
            $($num => (proto_msg_case!($constr $res)).boxed()),*,
            _ => Just($default).boxed()
        }
    )
}

    /// Wrapper type for generating non-empty strings
    #[derive(Debug)]
    pub struct Ascii(String);

    impl Arbitrary for Ascii {
        type Parameters = <String as Arbitrary>::Parameters;

        fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
            "[a-zA-Z0-9]+".prop_map(Ascii).boxed()
        }

        type Strategy = BoxedStrategy<Ascii>;
    }

    impl Arbitrary for GameCfg {
        type Parameters = ();

        fn arbitrary_with(_args: <Self as Arbitrary>::Parameters) -> <Self as Arbitrary>::Strategy {
            use crate::types::GameCfg::*;
            (0..10)
                .no_shrink()
                .prop_flat_map(|i| {
                    proto_msg_match!(i, def = FeatureSize(0),
            0 => FeatureSize(u32),
            1 => MapType(Ascii),
            2 => MapGenerator(u32),
            3 => MazeSize(u32),
            4 => Seed(Ascii),
            5 => Template(u32),
            6 => Ammo(Ascii, Option<Ascii>),
            7 => Scheme(Ascii, Vec<Ascii>),
            8 => Script(Ascii),
            9 => Theme(Ascii),
            10 => DrawnMap(Ascii))
                })
                .boxed()
        }

        type Strategy = BoxedStrategy<GameCfg>;
    }

    impl Arbitrary for TeamInfo {
        type Parameters = ();

        fn arbitrary_with(_args: <Self as Arbitrary>::Parameters) -> <Self as Arbitrary>::Strategy {
            (
                "[a-z]+",
                0u8..127u8,
                "[a-z]+",
                "[a-z]+",
                "[a-z]+",
                "[a-z]+",
                0u8..127u8,
            )
                .prop_map(|(name, color, grave, fort, voice_pack, flag, difficulty)| {
                    fn hog(n: u8) -> HedgehogInfo {
                        HedgehogInfo {
                            name: format!("hog{}", n),
                            hat: format!("hat{}", n),
                        }
                    }
                    let hedgehogs = [
                        hog(1),
                        hog(2),
                        hog(3),
                        hog(4),
                        hog(5),
                        hog(6),
                        hog(7),
                        hog(8),
                    ];
                    TeamInfo {
                        owner: String::new(),
                        name,
                        color,
                        grave,
                        fort,
                        voice_pack,
                        flag,
                        difficulty,
                        hedgehogs,
                        hedgehogs_number: 0,
                    }
                })
                .boxed()
        }

        type Strategy = BoxedStrategy<TeamInfo>;
    }

    impl Arbitrary for ServerVar {
        type Parameters = ();

        fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
            (0..=2)
                .no_shrink()
                .prop_flat_map(|i| {
                    proto_msg_match!(i, def = ServerVar::LatestProto(0),
                        0 => MOTDNew(Ascii),
                        1 => MOTDOld(Ascii),
                        2 => LatestProto(u16)
                    )
                })
                .boxed()
        }

        type Strategy = BoxedStrategy<ServerVar>;
    }

    impl Arbitrary for VoteType {
        type Parameters = ();

        fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
            use VoteType::*;
            (0..=4)
                .no_shrink()
                .prop_flat_map(|i| {
                    proto_msg_match!(i, def = VoteType::Pause,
                        0 => Kick(Ascii),
                        1 => Map(Option<Ascii>),
                        2 => Pause(),
                        3 => NewSeed(),
                        4 => HedgehogsPerTeam(u8)
                    )
                })
                .boxed()
        }

        type Strategy = BoxedStrategy<VoteType>;
    }
}