room::RoomId,

    client::{ClientId, HWClient},

pub enum Destination {

    ToSelf,

        ToAll {

        room_id: Option<RoomId>,

        protocol: Option<u32>,

        skip_self: bool

    }

}

pub struct PendingMessage {

    pub destination: Destination,

    pub message: HWServerMessage

}

impl PendingMessage {

    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: u32) -> 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(self) -> PendingMessage { PendingMessage::send_self(self) }

    pub fn send_all(self) -> PendingMessage { PendingMessage::send_all(self) }

}

    Send(PendingMessage),

    RemoveTeam(String),

    RemoveClientTeams,

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

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

                let c = &server.clients[client_id];

            room_id.map (|id| {

                if id != server.lobby_id {

                    server.react(client_id, vec![

                        MoveToLobby(format!("quit: {}", msg.clone()))]);

            server.react(client_id, vec![

                LobbyLeft(nick, msg.clone()).send_all().action(),

                Bye(msg).send_self().action(),

            server.removed_clients.push(client_id);

            if server.clients.contains(client_id) {

                server.clients.remove(client_id);

            handlers::handle(server, client_id, msg),

            if server.clients[client_id].protocol_number > 0 && server.clients[client_id].nick != "" {

                server.react(client_id, vec![

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

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

            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(),

            let actions = {

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

                vec![

                    RoomAdd(r.info(Some(&c))).send_all()

                        .with_protocol(r.protocol_number).action(),

                    MoveToRoom(room_id)]

            };

            server.react(client_id, actions);

            let actions = {

                vec![RoomRemove(r.name.clone()).send_all()

                        .with_protocol(r.protocol_number).action()]

            };

            server.react(client_id, actions);

            let actions = {

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

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

                vec![RoomJoined(vec![c.nick.clone()]).send_all().in_room(room_id).action(),

                     flags_msg.send_all().action(),

                     SendRoomUpdate(None)]

            };

            server.react(client_id, actions);

            if let (c, Some(r)) = server.client_and_room(client_id) {

                actions.push(RemoveClientTeams);

                actions.push(RoomLeft(c.nick.clone(), msg)

                    .send_all().in_room(r.id).but_self().action());

                actions.push(ClientFlags("-i".to_string(), vec![c.nick.clone()])

                    .send_all().action());

            server.react(client_id, actions);

            if let (c, Some(r)) = server.client_and_room(client_id) {

            server.react(client_id, actions)

                room_client_ids.iter().find(|id| **id != client_id).map(|id| *id));

            if let (c, Some(r)) = server.client_and_room(client_id) {

                match r.master_id {

                    Some(id) if id == c.id => {

                        c.is_master = false;

                        r.master_id = None;

                        actions.push(ClientFlags("-h".to_string(), vec![c.nick.clone()])

                            .send_all().in_room(r.id).action());

                    }

                    Some(_) => unreachable!(),

                    None => {}

                    actions.push(ClientFlags("+h".to_string(), vec![nick])

                        .send_all().in_room(r.id).action());

            server.react(client_id, actions);

        }

        RemoveTeam(name) => {

            let actions = if let (c, Some(r)) = server.client_and_room(client_id) {

                r.remove_team(&name);

                vec![TeamRemove(name).send_all().in_room(r.id).action(),

                     SendRoomUpdate(None)]

            } else {

                Vec::new()

            };

            server.react(client_id, actions);

        },

        RemoveClientTeams => {

            let actions = if let (c, Some(r)) = server.client_and_room(client_id) {

                r.client_teams(c.id).map(|t| RemoveTeam(t.name.clone())).collect()

            } else {

                Vec::new()

            };

            server.react(client_id, actions);

            let actions = if let (c, Some(r)) = server.client_and_room(client_id) {

                let name = old_name.unwrap_or_else(|| r.name.clone());

                vec![RoomUpdated(name, r.info(Some(&c)))

                    .send_all().with_protocol(r.protocol_number).action()]

            } else {

                Vec::new()

            };

            server.react(client_id, actions);

            run_action(server, client_id, Warning(msg).send_self().action());

            run_action(server, client_id, Error(msg).send_self().action())