'''
@author: Juan C. Espinoza
'''

import time
import json
import numpy
import paho.mqtt.client as mqtt

from schainpy.model.proc.jroproc_base import Operation

class PrettyFloat(float):
    def __repr__(self):
        return '%.2f' % self

def roundFloats(obj):
    if isinstance(obj, list):
        return map(roundFloats, obj)
    elif isinstance(obj, float):
        return round(obj, 2)

def pretty_floats(obj):
    if isinstance(obj, float):
        return PrettyFloat(obj)
    elif isinstance(obj, dict):
        return dict((k, pretty_floats(v)) for k, v in obj.items())
    elif isinstance(obj, (list, tuple)):
        return map(pretty_floats, obj)
    return obj


class PublishData(Operation):
    """Clase publish."""

    __MAXNUMX = 80
    __MAXNUMY = 80

    def __init__(self):
        """Inicio."""
        Operation.__init__(self)
        self.isConfig = False
        self.client = None

    def on_disconnect(self, client, userdata, rc):
        if rc != 0:
            print("Unexpected disconnection.")
        self.connect()

    def connect(self):
        print 'trying to connect'
        try:
            self.client.connect(
                host=self.host,
                port=self.port,
                keepalive=60*10,
                bind_address='')
            print "connected"
            self.client.loop_start()
            # self.client.publish(
            #     self.topic + 'SETUP',
            #     json.dumps(setup),
            #     retain=True
            #     )
        except:
            print "MQTT Conection error."
            self.client = False

    def setup(self, host, port=1883, username=None, password=None, clientId="user", **kwargs):

        self.topic = kwargs.get('topic', 'schain')
        self.delay = kwargs.get('delay', 0)
        self.plottype = kwargs.get('plottype', 'spectra')
        self.host = host
        self.port = port
        self.clientId = clientId
        self.cnt = 0
        setup = []
        for plot in self.plottype:
            setup.append({
                'plot': plot,
                'topic': self.topic + plot,
                'title': getattr(self, plot + '_' + 'title', False),
                'xlabel': getattr(self, plot + '_' + 'xlabel', False),
                'ylabel': getattr(self, plot + '_' + 'ylabel', False),
                'xrange': getattr(self, plot + '_' + 'xrange', False),
                'yrange': getattr(self, plot + '_' + 'yrange', False),
                'zrange': getattr(self, plot + '_' + 'zrange', False),
            })
        self.client = mqtt.Client(
            client_id=self.clientId + self.topic + 'SCHAIN',
            clean_session=True)
        self.client.on_disconnect = self.on_disconnect
        self.connect()

    def publish_data(self, plottype):
        data = getattr(self.dataOut, 'data_spc')
        yData = self.dataOut.heightList[:2].tolist()
        if plottype == 'spectra':
            z = data/self.dataOut.normFactor
            zdB = 10*numpy.log10(z)
            xlen, ylen = zdB[0].shape
            dx = numpy.floor(xlen/self.__MAXNUMX) + 1
            dy = numpy.floor(ylen/self.__MAXNUMY) + 1
            Z = [0 for i in self.dataOut.channelList]
            for i in self.dataOut.channelList:
                Z[i] = zdB[i][::dx, ::dy].tolist()
            payload = {
                'timestamp': self.dataOut.utctime,
                'data': roundFloats(Z),
                'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                'interval': self.dataOut.getTimeInterval(),
                'xRange': [0, 80],
                'type': plottype,
                'yData': yData
            }
            # print payload

        elif plottype in ('rti', 'power'):
            z = data/self.dataOut.normFactor
            avg = numpy.average(z, axis=1)
            avgdB = 10*numpy.log10(avg)
            xlen, ylen = z[0].shape
            dy = numpy.floor(ylen/self.__MAXNUMY) + 1
            AVG = [0 for i in self.dataOut.channelList]
            for i in self.dataOut.channelList:
                AVG[i] = avgdB[i][::dy].tolist()
            payload = {
                'timestamp': self.dataOut.utctime,
                'data': roundFloats(AVG),
                'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                'interval': self.dataOut.getTimeInterval(),
                'xRange': [0, 80],
                'type': plottype,
                'yData': yData
            }
        elif plottype == 'noise':
            noise = self.dataOut.getNoise()/self.dataOut.normFactor
            noisedB = 10*numpy.log10(noise)
            payload = {
                'timestamp': self.dataOut.utctime,
                'data': roundFloats(noisedB.reshape(-1, 1).tolist()),
                'channels': ['Ch %s' % ch for ch in self.dataOut.channelList],
                'interval': self.dataOut.getTimeInterval(),
                'xRange': [0, 80],
                'type': plottype,
                'yData': yData
            }
        else:
            print "Tipo de grafico invalido"
            payload = {
                'data': 'None',
                'timestamp': 'None',
                'type': None
            }
        print 'Publishing data to {}'.format(self.host)
        print '*************************'
        self.client.publish(self.topic + plottype, json.dumps(payload), qos=0)


    def run(self, dataOut, host, **kwargs):
        self.dataOut = dataOut
        if not self.isConfig:
            self.setup(host, **kwargs)
            self.isConfig = True

        map(self.publish_data, self.plottype)
        time.sleep(self.delay)

    def close(self):
        if self.client:
            self.client.loop_stop()
            self.client.disconnect()