use crate::server::client::HWClient;

use crate::server::room::HWRoom;

use crate::utils::to_engine_msg;

        HWServerMessage::{

            self, Bye, ChatMsg, ClientFlags, ForwardEngineMessage, LobbyLeft, RoomLeft, RoomRemove,

            RoomUpdated, TeamRemove,

        },

use std::iter::once;

pub fn remove_teams(room: &mut HWRoom, client: &HWClient, response: &mut super::Response) {

    let team_names: Vec<_> = room

        .client_teams(client.id)

        .map(|t| t.name.clone())

        .collect();

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

        for team_name in &team_names {

            info.left_teams.push(team_name.clone());

            if client.is_in_game() {

                let msg = once(b'F').chain(team_name.bytes());

                response.add(

                    ForwardEngineMessage(vec![to_engine_msg(msg)])

                        .send_all()

                        .in_room(room.id)

                        .but_self(),

                );

                info.teams_in_game -= 1;

                if info.teams_in_game == 0 {

                    //FinishRoomGame(room.id)

                }

                let remove_msg = to_engine_msg(once(b'F').chain(team_name.bytes()));

                if let Some(m) = &info.sync_msg {

                    info.msg_log.push(m.clone());

                    info.sync_msg = None

                }

                info.msg_log.push(remove_msg.clone());

                response.add(

                    ForwardEngineMessage(vec![remove_msg])

                        .send_all()

                        .in_room(room.id)

                        .but_self(),

                );

            }

        }

    }

    for team_name in team_names {

        room.remove_team(&team_name);

        response.add(TeamRemove(team_name).send_all().in_room(room.id));

    }

}

    let client_id = response.client_id();

    let lobby_id = server.lobby_id;

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

    let (nick, room_id) = (client.nick.clone(), client.room_id);

    if let Some(room_id) = room_id {

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

        if room.players_number > 1 || room.is_fixed() {

            room.players_number -= 1;

            if client.is_ready() && room.ready_players_number > 0 {

                room.ready_players_number -= 1;

            }

            remove_teams(room, client, response);

            if room.players_number > 1 {

                response.add(

                    RoomLeft(client.nick.clone(), msg.clone())

                        .send_all()

                        .in_room(room.id)

                        .but_self(),

                );

            }

            //ChangeMaster(room.id, None));

        }

        let update_msg = if room.players_number == 0 && !room.is_fixed() {

            RoomRemove(room.name.clone())

        } else {

            RoomUpdated(room.name.clone(), room.info(Some(&client)))

        };

        response.add(update_msg.send_all().with_protocol(room.protocol_number));

        response.add(ClientFlags("-i".to_string(), vec![nick.clone()]).send_all());

        client.room_id = Some(lobby_id);

    }

    server.remove_client(client_id);