use super::{

    client::HWClient,

    core::HWServer,

    coretypes::{ClientId, GameCfg, RoomId, VoteType},

    handlers,

    room::HWRoom,

    room::{GameInfo, RoomFlags},

};

use crate::{

    protocol::messages::{server_chat, HWProtocolMessage, HWServerMessage, HWServerMessage::*},

    utils::to_engine_msg,

};

use rand::{distributions::Uniform, thread_rng, Rng};

use std::{io, io::Write, iter::once, mem::replace};

#[cfg(feature = "official-server")]

use super::database;

pub enum Destination {

    ToId(ClientId),

    ToSelf,

    ToAll {

        room_id: Option<RoomId>,

        protocol: Option<u16>,

        skip_self: bool,

    },

}

pub struct PendingMessage {

    pub destination: Destination,

    pub message: HWServerMessage,

}

impl PendingMessage {

    pub fn send(message: HWServerMessage, client_id: ClientId) -> PendingMessage {

        PendingMessage {

            destination: Destination::ToId(client_id),

            message,

        }

    }

    pub fn send_self(message: HWServerMessage) -> PendingMessage {

        PendingMessage {

            destination: Destination::ToSelf,

            message,

        }

    }

    pub fn send_all(message: HWServerMessage) -> PendingMessage {

        let destination = Destination::ToAll {

            room_id: None,

            protocol: None,

            skip_self: false,

        };

        PendingMessage {

            destination,

            message,

        }

    }

    pub fn in_room(mut self, clients_room_id: RoomId) -> PendingMessage {

        if let Destination::ToAll {

            ref mut room_id, ..

        } = self.destination

        {

            *room_id = Some(clients_room_id)

        }

        self

    }

    pub fn with_protocol(mut self, protocol_number: u16) -> PendingMessage {

        if let Destination::ToAll {

            ref mut protocol, ..

        } = self.destination

        {

            *protocol = Some(protocol_number)

        }

        self

    }

    pub fn but_self(mut self) -> PendingMessage {

        if let Destination::ToAll {

            ref mut skip_self, ..

        } = self.destination

        {

            *skip_self = true

        }

        self

    }

    pub fn action(self) -> Action {

        Send(self)

    }

}

impl Into<Action> for PendingMessage {

    fn into(self) -> Action {

        self.action()

    }

}

impl HWServerMessage {

    pub fn send(self, client_id: ClientId) -> PendingMessage {

        PendingMessage::send(self, client_id)

    }

    pub fn send_self(self) -> PendingMessage {

        PendingMessage::send_self(self)

    }

    pub fn send_all(self) -> PendingMessage {

        PendingMessage::send_all(self)

    }

}

pub enum Action {

    Send(PendingMessage),

    CheckRegistered,

    JoinLobby,

    RemoveRoom(RoomId),

    MoveToRoom(RoomId),

    ChangeMaster(RoomId, Option<ClientId>),

    SendRoomUpdate(Option<String>),

    StartRoomGame(RoomId),

    SendTeamRemovalMessage(String),

    FinishRoomGame(RoomId),

    SendRoomData {

        to: ClientId,

        teams: bool,

        config: bool,

        flags: bool,

    },

    AddVote {

        vote: bool,

        is_forced: bool,

    },

    ApplyVoting(VoteType, RoomId),

    Warn(String),

    ProtocolError(String),

}

use self::Action::*;

pub fn run_action(server: &mut HWServer, client_id: usize, action: Action) {

    match action {

        Send(msg) => server.send(client_id, &msg.destination, msg.message),

        CheckRegistered => {

            let client = &server.clients[client_id];

            if client.protocol_number > 0 && client.nick != "" {

                let has_nick_clash = server

                    .clients

                    .iter()

                    .any(|(id, c)| id != client_id && c.nick == client.nick);

                let actions = if !client.is_checker() && has_nick_clash {

                    if client.protocol_number < 38 {

                        //ByeClient("Nickname is already in use".to_string())

                        vec![]

                    } else {

                        server.clients[client_id].nick.clear();

                        vec![Notice("NickAlreadyInUse".to_string()).send_self().action()]

                    }

                } else {

                    vec![JoinLobby]

                };

                server.react(client_id, actions);

            }

        }

        JoinLobby => {

            server.clients[client_id].room_id = Some(server.lobby_id);

            let mut lobby_nicks = Vec::new();

            for (_, c) in server.clients.iter() {

                if c.room_id.is_some() {

                    lobby_nicks.push(c.nick.clone());

                }

            }

            let joined_msg = LobbyJoined(lobby_nicks);

            let everyone_msg = LobbyJoined(vec![server.clients[client_id].nick.clone()]);

            let flags_msg = ClientFlags(

                "+i".to_string(),

                server

                    .clients

                    .iter()

                    .filter(|(_, c)| c.room_id.is_some())

                    .map(|(_, c)| c.nick.clone())

                    .collect(),

            );

            let server_msg = ServerMessage("\u{1f994} is watching".to_string());

            let rooms_msg = Rooms(

                server

                    .rooms

                    .iter()

                    .filter(|(id, _)| *id != server.lobby_id)

                    .flat_map(|(_, r)| r.info(r.master_id.map(|id| &server.clients[id])))

                    .collect(),

            );

            server.react(

                client_id,

                vec![

                    everyone_msg.send_all().but_self().action(),

                    joined_msg.send_self().action(),

                    flags_msg.send_self().action(),

                    server_msg.send_self().action(),

                    rooms_msg.send_self().action(),

                ],

            );

        }

        RemoveRoom(room_id) => {

            let r = &mut server.rooms[room_id];

            let actions = vec![RoomRemove(r.name.clone())

                .send_all()

                .with_protocol(r.protocol_number)

                .action()];

            server.rooms.remove(room_id);

            server.react(client_id, actions);

        }

        MoveToRoom(room_id) => {

            let r = &mut server.rooms[room_id];

            let c = &mut server.clients[client_id];

            r.players_number += 1;

            c.room_id = Some(room_id);

            let is_master = r.master_id == Some(c.id);

            c.set_is_master(is_master);

            c.set_is_ready(is_master);

            c.set_is_joined_mid_game(false);

            if is_master {

                r.ready_players_number += 1;

            }

            let mut v = vec![

                RoomJoined(vec![c.nick.clone()])

                    .send_all()

                    .in_room(room_id)

                    .action(),

                ClientFlags("+i".to_string(), vec![c.nick.clone()])

                    .send_all()

                    .action(),

                SendRoomUpdate(None),

            ];

            if !r.greeting.is_empty() {

                v.push(

                    ChatMsg {

                        nick: "[greeting]".to_string(),

                        msg: r.greeting.clone(),

                    }

                    .send_self()

                    .action(),

                );

            }

            if !c.is_master() {

                let team_names: Vec<_>;

                if let Some(ref mut info) = r.game_info {

                    c.set_is_in_game(true);

                    c.set_is_joined_mid_game(true);

                    {

                        let teams = info.client_teams(c.id);

                        c.teams_in_game = teams.clone().count() as u8;

                        c.clan = teams.clone().next().map(|t| t.color);

                        team_names = teams.map(|t| t.name.clone()).collect();

                    }

                    if !team_names.is_empty() {

                        info.left_teams.retain(|name| !team_names.contains(&name));

                        info.teams_in_game += team_names.len() as u8;

                        r.teams = info

                            .teams_at_start

                            .iter()

                            .filter(|(_, t)| !team_names.contains(&t.name))

                            .cloned()

                            .collect();

                    }

                } else {

                    team_names = Vec::new();

                }

                v.push(SendRoomData {

                    to: client_id,

                    teams: true,

                    config: true,

                    flags: true,

                });

                if let Some(ref info) = r.game_info {

                    v.push(RunGame.send_self().action());

                    v.push(

                        ClientFlags("+g".to_string(), vec![c.nick.clone()])

                            .send_all()

                            .in_room(r.id)

                            .action(),

                    );

                    v.push(

                        ForwardEngineMessage(vec![to_engine_msg("e$spectate 1".bytes())])

                            .send_self()

                            .action(),

                    );

                    v.push(

                        ForwardEngineMessage(info.msg_log.clone())

                            .send_self()

                            .action(),

                    );

                    for name in &team_names {

                        v.push(

                            ForwardEngineMessage(vec![to_engine_msg(

                                once(b'G').chain(name.bytes()),

                            )])

                            .send_all()

                            .in_room(r.id)

                            .action(),

                        );

                    }

                    if info.is_paused {

                        v.push(

                            ForwardEngineMessage(vec![to_engine_msg(once(b'I'))])

                                .send_all()

                                .in_room(r.id)

                                .action(),

                        )

                    }

                }

            }

            server.react(client_id, v);

        }

        SendRoomData {

            to,

            teams,

            config,

            flags,

        } => {

            let mut actions = Vec::new();

            let room_id = server.clients[client_id].room_id;

            if let Some(r) = room_id.and_then(|id| server.rooms.get(id)) {

                if config {

                    actions.push(

                        ConfigEntry("FULLMAPCONFIG".to_string(), r.map_config())

                            .send(to)

                            .action(),

                    );

                    for cfg in r.game_config() {

                        actions.push(cfg.to_server_msg().send(to).action());

                    }

                }

                if teams {

                    let current_teams = match r.game_info {

                        Some(ref info) => &info.teams_at_start,

                        None => &r.teams,

                    };

                    for (owner_id, team) in current_teams.iter() {

                        actions.push(

                            TeamAdd(HWRoom::team_info(&server.clients[*owner_id], &team))

                                .send(to)

                                .action(),

                        );

                        actions.push(TeamColor(team.name.clone(), team.color).send(to).action());

                        actions.push(

                            HedgehogsNumber(team.name.clone(), team.hedgehogs_number)

                                .send(to)

                                .action(),

                        );

                    }

                }

                if flags {

                    if let Some(id) = r.master_id {

                        actions.push(

                            ClientFlags("+h".to_string(), vec![server.clients[id].nick.clone()])

                                .send(to)

                                .action(),

                        );

                    }

                    let nicks: Vec<_> = server

                        .clients

                        .iter()

                        .filter(|(_, c)| c.room_id == Some(r.id) && c.is_ready())

                        .map(|(_, c)| c.nick.clone())

                        .collect();

                    if !nicks.is_empty() {

                        actions.push(ClientFlags("+r".to_string(), nicks).send(to).action());

                    }

                }

            }

            server.react(client_id, actions);

        }

        AddVote { vote, is_forced } => {

            let mut actions = Vec::new();

            if let Some(r) = server.room(client_id) {

                let mut result = None;

                if let Some(ref mut voting) = r.voting {

                    if is_forced || voting.votes.iter().all(|(id, _)| client_id != *id) {

                        actions.push(

                            server_chat("Your vote has been counted.".to_string())

                                .send_self()

                                .action(),

                        );

                        voting.votes.push((client_id, vote));

                        let i = voting.votes.iter();

                        let pro = i.clone().filter(|(_, v)| *v).count();

                        let contra = i.filter(|(_, v)| !*v).count();

                        let success_quota = voting.voters.len() / 2 + 1;

                        if is_forced && vote || pro >= success_quota {

                            result = Some(true);

                        } else if is_forced && !vote || contra > voting.voters.len() - success_quota

                        {

                            result = Some(false);

                        }

                    } else {

                        actions.push(

                            server_chat("You already have voted.".to_string())

                                .send_self()

                                .action(),

                        );

                    }

                } else {

                    actions.push(

                        server_chat("There's no voting going on.".to_string())

                            .send_self()

                            .action(),

                    );

                }

                if let Some(res) = result {

                    actions.push(

                        server_chat("Voting closed.".to_string())

                            .send_all()

                            .in_room(r.id)

                            .action(),

                    );

                    let voting = replace(&mut r.voting, None).unwrap();

                    if res {

                        actions.push(ApplyVoting(voting.kind, r.id));

                    }

                }

            }

            server.react(client_id, actions);

        }

        ApplyVoting(kind, room_id) => {

            let mut actions = Vec::new();

            let mut id = client_id;

            match kind {

                VoteType::Kick(nick) => {

                    if let Some(c) = server.find_client(&nick) {

                        if c.room_id == Some(room_id) {

                            id = c.id;

                            actions.push(Kicked.send_self().action());

                        }

                    }

                }

                VoteType::Map(None) => (),

                VoteType::Map(Some(name)) => {

                    if let Some(location) = server.rooms[room_id].load_config(&name) {

                        actions.push(

                            server_chat(location.to_string())

                                .send_all()

                                .in_room(room_id)

                                .action(),

                        );

                        actions.push(SendRoomUpdate(None));

                        for (_, c) in server.clients.iter() {

                            if c.room_id == Some(room_id) {

                                actions.push(SendRoomData {

                                    to: c.id,

                                    teams: false,

                                    config: true,

                                    flags: false,

                                })

                            }

                        }

                    }

                }

                VoteType::Pause => {

                    if let Some(ref mut info) = server.rooms[room_id].game_info {

                        info.is_paused = !info.is_paused;

                        actions.push(

                            server_chat("Pause toggled.".to_string())

                                .send_all()

                                .in_room(room_id)

                                .action(),

                        );

                        actions.push(

                            ForwardEngineMessage(vec![to_engine_msg(once(b'I'))])