"""Routers that connect WebSockets to ZMQ sockets."""

#-----------------------------------------------------------------------------
#  Copyright (C) 2011  The IPython Development Team
#
#  Distributed under the terms of the BSD License.  The full license is in
#  the file COPYING.txt, distributed as part of this software.
#-----------------------------------------------------------------------------

#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------

import uuid
from Queue import Queue
import json

from IPython.config.configurable import Configurable
from IPython.utils.traitlets import Instance, Int, Dict

#-----------------------------------------------------------------------------
# Classes
#-----------------------------------------------------------------------------

class ZMQStreamRouter(Configurable):

    zmq_stream = Instance('zmq.eventloop.zmqstream.ZMQStream')
    session = Instance('IPython.zmq.session.Session')
    max_msg_size = Int(2048, config=True, help="""
        The max raw message size accepted from the browser
        over a WebSocket connection.
    """)

    _clients = Dict()

    def __init__(self, **kwargs):
        super(ZMQStreamRouter,self).__init__(**kwargs)
        self.zmq_stream.on_recv(self._on_zmq_reply)

    def register_client(self, client):
        """Register a client, returning a client uuid."""
        client_id = uuid.uuid4()
        self._clients[client_id] = client
        return client_id

    def unregister_client(self, client_id):
        """Unregister a client by its client uuid."""
        del self._clients[client_id]

    def copy_clients(self, router):
        """Copy the clients of another router to this one.

        This is used to enable the backend zeromq stream to disconnect
        and reconnect while the WebSocket connections to browsers
        remain, such as when a kernel is restarted.
        """
        for client_id, client in router._clients.items():
            client.router = self
            self._clients[client_id] = client

    def forward_msg(self, client_id, msg):
        """Forward a msg to a client by its id.

        The default implementation of this will fail silently if a message
        arrives on a socket that doesn't support it. This method should
        use max_msg_size to check and silently discard message that are too
        long."""
        pass

    def _on_zmq_reply(self, msg_list):
        """Handle a message the ZMQ stream sends to the router.

        Usually, this is where the return message will be written to
        clients that need it using client.write_message().
        """
        pass

    def _reserialize_reply(self, msg_list):
        """Reserialize a reply message using JSON.

        This takes the msg list from the ZMQ socket, unserializes it using
        self.session and then serializes the result using JSON. This method
        should be used by self._on_zmq_reply to build messages that can
        be sent back to the browser.
        """
        idents, msg_list = self.session.feed_identities(msg_list)
        msg = self.session.unserialize(msg_list)
        msg['header'].pop('date')
        msg.pop('buffers')
        return json.dumps(msg)


class IOPubStreamRouter(ZMQStreamRouter):

    def _on_zmq_reply(self, msg_list):
        msg = self._reserialize_reply(msg_list)
        for client_id, client in self._clients.items():
            client.write_message(msg)


class ShellStreamRouter(ZMQStreamRouter):

    _request_queue = Instance(Queue,(),{})

    def _on_zmq_reply(self, msg_list):
        msg = self._reserialize_reply(msg_list)
        client_id = self._request_queue.get(block=False)
        client = self._clients.get(client_id)
        if client is not None:
            client.write_message(msg)

    def forward_msg(self, client_id, msg):
        if len(msg) < self.max_msg_size:
            msg = json.loads(msg)
            # to_send = self.session.serialize(msg)
            self._request_queue.put(client_id)        
            self.session.send(self.zmq_stream, msg)