#!/usr/bin/env python

"""
A visualization tool for time-series data stored in GDP logs
"""

from twisted.internet import reactor
from twisted.web.resource import Resource, NoResource
from twisted.web.server import Site
from twisted.web import static
from threading import Lock

from gdp import GDPcache
import argparse
import json
import gviz_api
from datetime import datetime
import time

class DataResource(Resource):

    isLeaf = True
    def __init__(self):
        Resource.__init__(self)
        self.GDPcaches = {}
        self.lock = Lock()


    def __handleQuery(self, request):

        args = request.args

        # get query parameters
        logname = args['logname'][0]
        startTime = float(args['startTime'][0])
        endTime = float(args['endTime'][0])

        # reqId processing
        reqId = 0
        tqx = args['tqx'][0].split(';')
        for t in tqx:
            _t = t.split(':')
            if _t[0] == "reqId":
                reqId = _t[1]
                break

        self.lock.acquire()
        gdpcache = self.GDPcaches.get(logname, None)
        if gdpcache is None:
            gdpcache = GDPcache(logname)
            self.GDPcaches[logname] = gdpcache
        self.lock.release()

        sampleRecord = gdpcache.mostRecent()
        sampleData = json.loads(sampleRecord['data'])
        if sampleData.get('device') == "BLEES":
            keys = ['pressure_pascals', 'humidity_percent',
                    'temperature_celcius', 'light_lux',
                    'acceleration_advertisement', 'acceleration_interval']
        elif sampleData.get('device') == "Blink":
            keys = ['current_motion', 'motion_since_last_adv',
                    'motion_last_minute']
        elif sampleData.get('device') == 'PowerBlade':
            keys = ['rms_voltage', 'power', 'apparent_power', 'energy',
                    'power_factor']
        elif (('msp432_active' in sampleData.keys()) and
                ('cc2650_active' in sampleData.keys())):
            keys = ['rhum', 'tamb', 'press', 'bat', 'lux']
        else:
            keys = []

        # create data
        data = []
        for datum in gdpcache.getRange(startTime, endTime):

            _time = datetime.fromtimestamp(datum['ts']['tv_sec'] + \
                                (datum['ts']['tv_nsec']*1.0/10**9))
            __xxx = [_time]
            for key in keys:
                _raw_data = json.loads(datum['data'])[key]
                if _raw_data == "true":
                    _data = 1.0
                elif _raw_data == "false":
                    _data = 0.0
                else:
                    _data = float(_raw_data)
                __xxx.append(_data)
            data.append(tuple(__xxx))

        desc = [('time', 'datetime')]
        for key in keys:
            desc.append((key, 'number'))
        data_table = gviz_api.DataTable(desc)
        data_table.LoadData(data)

        response = data_table.ToJSonResponse(order_by='time', req_id = reqId)

        return response


    def render_GET(self, request):

        resp = ""
        respCode = 200

        try:
            resp = self.__handleQuery(request)
        except Exception as e:
            print e
            request.setResponseCode(500)
            respCode = 500
            resp = str(e)

        return resp


class MainResource(Resource):

    def __init__(self):
        Resource.__init__(self)
        self.staticresource = static.File("./static")
        self.dataresource = DataResource()
        self.putChild('static', self.staticresource)
        self.putChild('datasource', self.dataresource)

    def getChild(self, name, request):
        if name == "":
            return self
        else:
            return NoResource()

    def render_GET(self, request):
        with open('index.html') as fh:
            return fh.read()

if __name__ == '__main__': 

    parser = argparse.ArgumentParser()
    parser.add_argument("-p", "--port", type=int, default=8888,
                        help="TCP port to serve requests on")
    parser.add_argument("-l", "--logfile", default="visServer.log",
                        help="Logfile to log requests to")

    args = parser.parse_args()
    site = Site(MainResource(), logPath=args.logfile)
    reactor.listenTCP(args.port, site)

    print "Starting web-server on port", args.port
    reactor.run()