from tornado.web import Application
from collections import defaultdict

from tfw.networking.server.controller_responder import ControllerResponder
from tfw.networking.server.zmq_websocket_handler import ZMQWebSocketProxy
from tfw.networking.event_handlers.server_connector import ServerUplinkConnector
from tfw.config.logs import logging
log = logging.getLogger(__name__)


class TFWServer:
    def __init__(self, fsm_type):
        self._fsm = fsm_type()
        self.fsm_updater = FSMUpdater(self._fsm)
        self._fsm.subscribe(self.fsm_updater.update)

        self.application = Application(
            [(r'/ws', ZMQWebSocketProxy, {'make_response': self.make_response,
                                          'proxy_filter': self.proxy_filter})]
        )
        self.controller_responder = ControllerResponder(self.fsm)

    @property
    def fsm(self):
        return self._fsm

    def make_response(self, message):
        trigger = message.get('trigger', '')
        try: self.fsm.trigger(trigger, message=message)
        except AttributeError: log.debug('FSM failed to execute nonexistent trigger: "{}"'.format(trigger))
        return message

    def proxy_filter(self, message):
        return True

    def listen(self, port):
        self.application.listen(port)


class FSMManager:
    def __init__(self, fsm_type):
        self.fsm = fsm_type()
        self.trigger_handlers = defaultdict(list)

    def trigger(self, trigger, message):
        if all((handler() for handler in self.trigger_handlers[trigger])):
            try: self.fsm.trigger(trigger, message=message)
            except AttributeError: log.debug('FSM failed to execute nonexistent trigger: "{}"'.format(trigger))

    def subscribe_handler(self, trigger, handler):
        self.trigger_handlers[trigger].append(handler)

    def unsubscribe_handler(self, trigger, handler):
        self.trigger_handlers[trigger].append(handler)


class FSMUpdater:
    def __init__(self, fsm):
        self.fsm = fsm
        self.uplink = ServerUplinkConnector()

    def update(self, kwargs_dict):
        self.uplink.send(*self.generate_fsm_update())

    def generate_fsm_update(self):
        key = 'FSMUpdate'
        response = {'key': key,
                    'data': {'current_state': self.fsm.state,
                             'valid_transitions':
                                 [{'trigger': trigger} for trigger in self.fsm.machine.get_triggers(self.fsm.state)]}}
        return key, response