# -*- coding: UTF-8 -*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

__author__ = "d01"
__email__ = "jungflor@gmail.com"
__copyright__ = "Copyright (C) 2017, Florian JUNG"
__license__ = "MIT"
__version__ = "0.1.0"
__date__ = "2017-05-01"
# Created: 2017-04-27 23:27

import threading

from SimpleWebSocketServer import SimpleWebSocketServer, WebSocket
from flotils import get_logger
from flotils.runable import SignalStopWrapper
from alexander_fw import ReactorModule
from alexander_fw.dto import InputMessage


logger = get_logger()


class SimpleEcho(WebSocket):

    def handleMessage(self):
        if instance.socket is None:
            instance.socket = self
        instance.on_msg(self.data)

    def handleConnected(self):
        # logger.debug(self.address, "connected")
        print(self.address, "connected")

    def handleClose(self):
        # logger.debug(self.address, "closed")
        print(self.address, "closed")


class WebCommunicator(ReactorModule):

    def __init__(self, settings=None):
        if settings is None:
            settings = {}
        super(WebCommunicator, self).__init__(settings)
        web_sett = settings.get('web', {})
        self._host = web_sett.get("host", "")
        self._port = web_sett.get("port", 8080)
        self.socket = None
        """ :type : SimpleEcho """

    def _thread_wrapper(self, func, args=None):
        """
        Wrap function for exception handling with threaded calls

        :param func: Function to call
        :type func: callable
        :rtype: None
        """
        if args is None:
            args = ()
        try:
            func(*args)
        except:
            self.exception("Threaded execution failed")

    def _setup(self):
        # Setup listeners
        self._register(
            "communicator_web", "say", "WebCommunicator"
        )

    def communicate(self, msg):
        msg.source = "communicator_web"
        self.emit(msg, self.get_exchange("manager_intent"))

    def react_nameko(self, exchange, routing_key, msg):
        pass

    def react(self, exchange, routing_key, msg):
        # self.debug("{}-{}: {}".format(exchange, routing_key, msg))

        if exchange == "communicator_web":
            if routing_key == "say":
                try:
                    self._do_say(msg)
                except:
                    self.exception("Failed to say")

    def on_msg(self, message):
        """
        Receive message

        :param message: Received message
        :type message: unicode
        :rtype: None
        """
        from pprint import pformat
        self.debug(pformat(message))
        im = InputMessage()
        im.data = message
        im.metadata = None
        self.communicate(im)

    def _do_say(self, msg):
        self.socket.sendMessage("{}".format(msg.result))

    def start(self, blocking=False):
        self._setup()
        try:
            self.socket = None
            server = SimpleWebSocketServer(self._host, self._port, SimpleEcho)
            a_thread = threading.Thread(
                target=self._thread_wrapper,
                args=(server.serveforever, (), )
            )
            a_thread.daemon = True
            a_thread.start()
        except:
            self.exception("Failed to run receive loop")
            self.stop()
            return
        super(WebCommunicator, self).start(blocking)

    def stop(self):
        super(WebCommunicator, self).stop()


class Wrapper(WebCommunicator, SignalStopWrapper):

    def __init__(self, settings=None):
        if settings is None:
            settings = {}
        super(Wrapper, self).__init__(settings)


if __name__ == "__main__":
    import argparse
    import logging.config
    from flotils.logable import default_logging_config
    from alexander_fw import setup_kombu

    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--debug", action="store_true",
        help="Use debug level output"
    )
    parser.add_argument(
        "--config", nargs="?", default="settings.yaml",
        help="Config file"
    )
    logging.config.dictConfig(default_logging_config)
    args = parser.parse_args()

    if args.debug:
        logging.getLogger().setLevel(logging.DEBUG)

    setup_kombu()

    instance = Wrapper({
        'settings_file': args.config
    })

    try:
        instance.start(True)
    except KeyboardInterrupt:
        pass
    finally:
        instance.stop()