use crate::{
    core::{
        client::HwClient,
        room::HwRoom,
        room::{GameInfo, RoomFlags},
        server::HwServer,
        types::{ClientId, GameCfg, RoomId, VoteType},
    },
    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};

#[derive(Clone)]
pub enum DestinationGroup {
    All,
    Lobby,
    Room(RoomId),
    Protocol(u16),
}

#[derive(Clone)]
pub enum Destination {
    ToId(ClientId),
    ToIds(Vec<ClientId>),
    ToSelf,
    ToAll {
        group: DestinationGroup,
        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_many(message: HwServerMessage, client_ids: Vec<ClientId>) -> PendingMessage {
        PendingMessage {
            destination: Destination::ToIds(client_ids),
            message,
        }
    }

    pub fn send_self(message: HwServerMessage) -> PendingMessage {
        PendingMessage {
            destination: Destination::ToSelf,
            message,
        }
    }

    pub fn send_all(message: HwServerMessage) -> PendingMessage {
        let destination = Destination::ToAll {
            group: DestinationGroup::All,
            skip_self: false,
        };
        PendingMessage {
            destination,
            message,
        }
    }

    pub fn in_room(mut self, clients_room_id: RoomId) -> PendingMessage {
        if let Destination::ToAll { ref mut group, .. } = self.destination {
            *group = DestinationGroup::Room(clients_room_id)
        }
        self
    }

    pub fn in_lobby(mut self) -> PendingMessage {
        if let Destination::ToAll { ref mut group, .. } = self.destination {
            *group = DestinationGroup::Lobby
        }
        self
    }

    pub fn with_protocol(mut self, protocol_number: u16) -> PendingMessage {
        if let Destination::ToAll { ref mut group, .. } = self.destination {
            *group = DestinationGroup::Protocol(protocol_number)
        }
        self
    }

    pub fn but_self(mut self) -> PendingMessage {
        if let Destination::ToAll {
            ref mut skip_self, ..
        } = self.destination
        {
            *skip_self = true
        }
        self
    }
}

impl HwServerMessage {
    pub fn send(self, client_id: ClientId) -> PendingMessage {
        PendingMessage::send(self, client_id)
    }
    pub fn send_many(self, client_ids: Vec<ClientId>) -> PendingMessage {
        PendingMessage::send_many(self, client_ids)
    }
    pub fn send_self(self) -> PendingMessage {
        PendingMessage::send_self(self)
    }
    pub fn send_all(self) -> PendingMessage {
        PendingMessage::send_all(self)
    }
    pub fn send_to_destination(self, destination: Destination) -> PendingMessage {
        PendingMessage {
            destination,
            message: self,
        }
    }
}