# Copyright (C) 2018 Avatao.com Innovative Learning Kft.
# All Rights Reserved. See LICENSE file for details.

from tfw.event_handler_base import FrontendEventHandlerBase
from tfw.crypto import KeyManager, sign_message, verify_message
from tfw.config.logs import logging
from tfw.networking.event_handlers.server_connector import Scope

LOG = logging.getLogger(__name__)


class FSMManagingEventHandler(FrontendEventHandlerBase):
    """
    EventHandler responsible for managing the state machine of
    the framework (TFW FSM).

    tfw.networking.TFWServer instances automatically send 'trigger'
    commands to the event handler listening on the 'fsm' key,
    which should be an instance of this event handler.

    This event handler accepts messages that have a
    data['command'] key specifying a command to be executed.

    An 'fsm_update' message is broadcasted after every successful
    command.
    """
    def __init__(self, key, fsm_type, require_signature=False):
        super().__init__(key)
        self.fsm = fsm_type()
        self._fsm_updater = FSMUpdater(self.fsm)
        self.auth_key = KeyManager().auth_key
        self._require_signature = require_signature

        self.command_handlers = {
            'trigger': self.handle_trigger,
            'update':  self.handle_update
        }

    def handle_event(self, message):
        try:
            message = self.command_handlers[message['data']['command']](message)
            if message:
                fsm_update_message = self._fsm_updater.fsm_update
                sign_message(self.auth_key, message)
                sign_message(self.auth_key, fsm_update_message)
                self.server_connector.send_message(fsm_update_message, Scope.BROADCAST)
            return message
        except KeyError:
            LOG.error('IGNORING MESSAGE: Invalid message received: %s', message)

    def handle_trigger(self, message):
        """
        Attempts to step the FSM with the supplied trigger.

        :param message: TFW message with a data field containing
                        the action to try triggering in data['value']
        """
        trigger = message['data']['value']
        if self._require_signature:
            if not verify_message(self.auth_key, message):
                LOG.error('Ignoring unsigned trigger command: %s', message)
                return None
        if self.fsm.step(trigger):
            return message
        return None

    def handle_update(self, message):
        """
        Does nothing, but triggers an 'fsm_update' message.
        """
        # pylint: disable=no-self-use
        return message


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

    @property
    def fsm_update(self):
        return {
            'key': 'fsm_update',
            'data': self.fsm_update_data
        }

    @property
    def fsm_update_data(self):
        valid_transitions = [
            {'trigger': trigger}
            for trigger in self.fsm.get_triggers(self.fsm.state)
        ]
        last_fsm_event = self.fsm.event_log[-1]
        last_fsm_event['timestamp'] = last_fsm_event['timestamp'].isoformat()
        return {
            'current_state': self.fsm.state,
            'valid_transitions': valid_transitions,
            'in_accepted_state': self.fsm.in_accepted_state,
            'last_event': last_fsm_event
        }