""" Georide socket-io implementation """
import logging
import socketio

from georideapilib.api import GEORIDE_API_HOST

_LOGGER = logging.getLogger(__name__)
_LOGGER.setLevel(logging.DEBUG)
# create console handler and set level to debug
CH = logging.StreamHandler()
CH.setLevel(logging.DEBUG)

sio = socketio.Client(reconnection=True)

@sio.on('connect')
def on_connect():
    """ event: connected """
    _LOGGER.debug('GeoRide socket connected')

@sio.on('disconnect')
def on_disconnect():
    """ event: disconnected """
    _LOGGER.debug('GeoRide socket disconnected')


class GeorideSocket():
    """docstring for GeorideSocket"""
    def __init__(self):
        self._on_message_callback = None
        self._on_device_callback = None
        self._on_position_callback = None
        self._on_alarm_callback = None
        self._on_refresh_tracker_callback = None
        self._on_locked_callback = None
        self._initialised = False


    def subscribe_on_message(self, callback_function):
        """event: tells you authentication informations."""
        self._on_message_callback = callback_function

    def subscribe_device(self, callback_function):
        """event: tells you when a device is added to the account."""
        self._on_device_callback = callback_function

    def subscribe_position(self, callback_function):
        """event: tells you when a device sent a position."""
        self._on_position_callback = callback_function

    def subscribe_alarm(self, callback_function):
        """event: tells you when a device trigger an alarm."""
        self._on_alarm_callback = callback_function

    def subscribe_refresh_tracker(self, callback_function):
        """event: tells you when you need to refresh your list of trackers"""
        self._on_refresh_tracker_callback = callback_function

    def subscribe_locked(self, callback_function):
        """event: tells you when a device has been locked or unlocked."""
        self._on_locked_callback = callback_function


    def init(self):
        """init the context"""
        @sio.on('message')
        def on_message(data):
            """ on_message """
            _LOGGER.debug('Message recieved: %s', data)
            if self._on_message_callback is not None:
                self._on_message_callback()
        
        @sio.on('device')
        def on_device(data):
            """ on_device """
            _LOGGER.debug('Device recieved: %s', data)
            if self._on_device_callback is not None:
                self._on_device_callback()
        
        @sio.on('position')
        def on_position(data):
            """ on_position """
            _LOGGER.debug('Position recieved:%s', data)
            if self._on_position_callback is not None:
                self._on_position_callback()

        @sio.on('alarm')
        def on_alarm(data):
            """ on_alarm """
            _LOGGER.debug('Alarm recieved: %s', data)
            if self._on_alarm_callback is not None:
                self._on_alarm_callback(data)
            
        @sio.on('refreshTrackersInstruction')
        def on_refresh_tracker():
            """ on_refresh_tracker """
            _LOGGER.debug('Refresh tracker recieved')
            if self._on_refresh_tracker_callback is not None:
                self._on_refresh_tracker_callback()

        @sio.on('lockedPosition')
        def on_locked(data):
            """ on_locked """
            _LOGGER.debug('Locked recieved: %s', data)
            if self._on_locked_callback is not None:
                self._on_locked_callback()

        self._initialised = True

    def connect(self, auth_token):
        """ connect to the georide socket"""
        _LOGGER.info("Start conection")
        if self._initialised is not False:
            sio.connect(GEORIDE_API_HOST, headers={'token': auth_token})
            sio.wait()
        else:
            _LOGGER.error("Please call init() before")
        
    def disconnect(self):
        """disconnect from the georide socket"""
        sio.disconnect()