use std::{

    io, io::{Error, ErrorKind, Write},

    net::{SocketAddr, IpAddr, Ipv4Addr},

    collections::VecDeque

};

use mio::{

    net::{TcpStream, TcpListener},

    Poll, PollOpt, Ready, Token

};

use netbuf;

use utils;

use protocol::{ProtocolDecoder, messages::*};

use super::{

    server::{HWServer, PendingMessage, Destination},

    client::ClientId

};

const MAX_BYTES_PER_READ: usize = 2048;

#[derive(PartialEq, Copy, Clone)]

pub enum NetworkClientState {

    Idle,

    NeedsWrite,

    NeedsRead,

    Closed,

}

type NetworkResult<T> = io::Result<(T, NetworkClientState)>;

    buf_out: netbuf::Buf

            buf_out: netbuf::Buf::new()

    pub fn read_messages(&mut self) -> NetworkResult<Vec<HWProtocolMessage>> {

        let mut bytes_read = 0;

        let result = loop {

            match self.decoder.read_from(&mut self.socket) {

                Ok(bytes) => {

                    debug!("Read {} bytes", bytes);

                    bytes_read += bytes;

                    if bytes == 0 {

                        let result = if bytes_read == 0 {

                            info!("EOF for client {} ({})", self.id, self.peer_addr);

                            (Vec::new(), NetworkClientState::Closed)

                        } else {

                            (self.decoder.extract_messages(), NetworkClientState::NeedsRead)

                        };

                        break Ok(result);

                    }

                    else if bytes_read >= MAX_BYTES_PER_READ {

                        break Ok((self.decoder.extract_messages(), NetworkClientState::NeedsRead))

                    }

                }

                Err(ref error) if error.kind() == ErrorKind::WouldBlock => {

                    let messages =  if bytes_read == 0 {

                        Vec::new()

                    } else {

                        self.decoder.extract_messages()

                    };

                    break Ok((messages, NetworkClientState::Idle));

                }

                Err(error) =>

                    break Err(error)

            }

        };

        self.decoder.sweep();

        result

    }

    pub fn flush(&mut self) -> NetworkResult<()> {

        let result = loop {

            match self.buf_out.write_to(&mut self.socket) {

                Ok(bytes) if self.buf_out.is_empty() || bytes == 0 =>

                    break Ok(((), NetworkClientState::Idle)),

                Ok(bytes) =>

                    (),

                Err(ref error) if error.kind() == ErrorKind::Interrupted

                    || error.kind() == ErrorKind::WouldBlock => {

                    break Ok(((), NetworkClientState::NeedsWrite));

                },

                Err(error) =>

                    break Err(error)

            }

        };

        self.socket.flush()?;

        result

    }

    clients: Slab<NetworkClient>,

    pending: VecDeque<(ClientId, NetworkClientState)>

        let pending = VecDeque::with_capacity(clients_limit);

        NetworkLayer {listener, server, clients, pending}

        if let Some(ref client) = self.clients.get(id) {

    fn flush_server_messages(&mut self) {

        debug!("{} pending server messages", self.server.output.len());

        for PendingMessage(destination, msg) in self.server.output.drain(..) {

            match destination {

                Destination::ToSelf(id)  => {

                    if let Some(ref mut client) = self.clients.get_mut(id) {

                        client.send_msg(msg);

                        self.pending.push_back((id, NetworkClientState::NeedsWrite));

                    }

                }

                Destination::ToOthers(id) => {

                    let msg_string = msg.to_raw_protocol();

                    for (client_id, client) in self.clients.iter_mut() {

                        if client_id != id {

                            client.send_string(&msg_string);

                            self.pending.push_back((client_id, NetworkClientState::NeedsWrite));

                        }

                    }

                }

            }

        }

    }

    fn operation_failed(&mut self, poll: &Poll, client_id: ClientId, error: Error, msg: &str) -> io::Result<()> {

        let addr = if let Some(ref mut client) = self.clients.get_mut(client_id) {

            client.peer_addr

        } else {

            SocketAddr::new(IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)), 0)

        };

        debug!("{}({}): {}", msg, addr, error);

        self.client_error(poll, client_id)

        let messages =

            if let Some(ref mut client) = self.clients.get_mut(client_id) {

                client.read_messages()

            } else {

                warn!("invalid readable client: {}", client_id);

                Ok((Vec::new(), NetworkClientState::Idle))

        match messages {

            Ok((messages, state)) => {

                for message in messages {

                    self.server.handle_msg(client_id, message);

                }

                match state {

                    NetworkClientState::NeedsRead =>

                        self.pending.push_back((client_id, state)),

                    NetworkClientState::Closed =>

                        self.client_error(&poll, client_id)?,

                    _ => {}

                };

            Err(e) => self.operation_failed(

                poll, client_id, e,

                "Error while reading from client socket")?

        self.flush_server_messages();

            let ids: Vec<_> = self.server.removed_clients.drain(..).collect();

        let result =

            if let Some(ref mut client) = self.clients.get_mut(client_id) {

                client.flush()

            } else {

                warn!("invalid writable client: {}", client_id);

                Ok(((), NetworkClientState::Idle))

            };

        match result {

            Ok(((), state)) if state == NetworkClientState::NeedsWrite =>

                self.pending.push_back((client_id, state)),

            Ok(_) =>

                {}

            Err(e) => self.operation_failed(

                poll, client_id, e,

                "Error while writing to client socket")?

    pub fn has_pending_operations(&self) -> bool {

        !self.pending.is_empty()

    }

    pub fn on_idle(&mut self, poll: &Poll) -> io::Result<()> {

        while let Some((id, state)) = self.pending.pop_front() {

            match state {

                NetworkClientState::NeedsRead =>

                    self.client_readable(poll, id)?,

                NetworkClientState::NeedsWrite =>

                    self.client_writable(poll, id)?,

                _ => {}

            }

        }

        Ok(())

    }