#

# See LICENCE for detail

# Copyright (c) 2014 IRI

#

import json

from autobahn.twisted.websocket import WebSocketServerFactory, \

                                       WebSocketServerProtocol

from autobahn.websocket import http

from baseserver import BaseProtocol

import utils

class BroadcastServerProtocol(WebSocketServerProtocol):

    def onConnect(self, request):

        if request.params:

            self.factory.registerFilter(self, request.params)

    def onOpen(self):

        self.factory.register(self)

    def onMessage(self, payload, isBinary):

        if not isBinary:

            msg = "{} from {}".format(payload.decode('utf8'), self.peer)

            self.factory.broadcast(msg)

    def connectionLost(self, reason):

        WebSocketServerProtocol.connectionLost(self, reason)

        self.factory.unregister(self)

class BroadcastServerFactory(WebSocketServerFactory):

    """

    Simple broadcast server broadcasting any message it receives to all

    currently connected clients.

    """

    def __init__(self, url, debug = False, debugCodePaths = False):

        WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debugCodePaths)

        self.clients = []

        self.filters = {}

        self.protocol = BroadcastServerProtocol

    def registerFilter(self, client, filter):

        print("registered filter {} for client {}".format(repr(filter),client.peer))

        self.filters[client] = filter

    def register(self, client):

        if not client in self.clients:

             print("registered client {}".format(client.peer))

             self.clients.append(client)

    def unregister(self, client):

        if client in self.clients:

            print("unregistered client {}".format(client.peer))

            self.clients.remove(client)

        if client in self.filters:

            self.filters.pop(client, None)

    def broadcast(self, msg, filter):

        print("broadcasting prepared message '{}' ..".format(msg))

        #preparedMsg = self.prepareMessage(msg)

        for c in self.clients:

            preparedMsg = self.prepareMessage(msg)

            if all([ (k in filter and filter[k] in v) for k,v in self.filters.get(c, {}).items()]):

                c.sendPreparedMessage(preparedMsg)

                print("prepared message sent to {}".format(c.peer))

class AnnotationServerProtocol(WebSocketServerProtocol, BaseProtocol):

    def onConnect(self, request):

        event_ids = request.params.get('event', [])

        if not event_ids or not event_ids[0]:

            raise http.HttpException(400, "The event parameter is missing")

        self.event = event_ids[0]

        self._init_props(self.factory.ws_factory, self.factory.conn)

    #TODO: add error handling

    def onMessage(self, payload, isBinary):

        if isBinary:

            return

        msg = payload.decode('utf8')

        params_annot = json.loads(msg)

        params = {

            'event': self.event,

            'channel' : utils.ANNOTATION_CHANNEL,

            'content' : params_annot

        }

        def error_callback(failure):

            raise http.HttpException(500,"Error when processing message : %r" % failure)

        def annot_callback(res):

            if 'ts' in res:

                res['ts'] = res['ts'].isoformat()+'Z'

            if 'uuid' in res:

                res['uuid'] = str(res['uuid'])

            self.sendMessage(json.dumps(res))

        defer = self.process_annotation(params)

        defer.addErrback(error_callback)

        defer.addCallback(annot_callback)

class AnotationServerFactory(WebSocketServerFactory):

    def __init__(self, url, ws_factory, conn, debug = False, debugCodePaths = False):

        WebSocketServerFactory.__init__(self, url, debug = debug, debugCodePaths = debugCodePaths)

        self.ws_factory = ws_factory

        self.conn = conn

        self.clients = {}

        self.protocol = AnnotationServerProtocol