'''
Created on 13.11.2013

@author: Philipp Rauch
@version: 0.1
'''

from CanMessage import CanMessage
from CanSignal  import CanSignal
from PCan       import PcanAdapter
from datetime   import datetime
from time       import sleep
from threading  import Thread
from Queue      import Queue
from config     import Config
import database

debug = False

class CANFilter(Thread):

    battery_current, battery_voltage = [], []
    battery_soc, battery_timestamp = [], [] #create tmp lists

    ### LOAD CONFIG ###
    c = Config()
    conf = c.readConf()

    cursor = database.setup(conf)

    def __init__(self):
        Thread.__init__(self)

        self.queue = Queue()

        self.pcan = PcanAdapter(PcanAdapter.Baudrate[self.conf['can_baud']],
                                debug = self.conf['config_debug'])
        self.pcan.initialize()

        dc_battery  = CanMessage(0x3A4, 8, 50, 'dc_battery')
        dc_grid     = CanMessage(0x3A5, 8, 50, 'dc_grid')
        dc_pv       = CanMessage(0x3A6, 8, 50, 'dc_pv')
        dc_charging = CanMessage(0x3A7, 8, 50, 'dc_charger')

        self.pcan.addMessage(dc_battery)
        self.pcan.addMessage(dc_grid)
        self.pcan.addMessage(dc_pv)
        self.pcan.addMessage(dc_charging)

        current     = CanSignal(0, 16, 0, 0.001, 0, 'current')
        voltage     = CanSignal(16, 16, 0, 0.01, 0, 'voltage')
        soc         = CanSignal(32, 11, 0, 0.05, 0, 'soc')
        isMaster    = CanSignal(56, 1, 0, 1, 0, 'isMaster')
        isFeed      = CanSignal(57, 1, 0, 1, 0, 'isFeed')
        isCharging  = CanSignal(57, 1, 0, 1, 0, 'isCharging')
        isOn        = CanSignal(58, 1, 0, 1, 0, 'isOn')

        self.pcan.Messages['dc_battery'].addSignal( current )
        self.pcan.Messages['dc_battery'].addSignal( voltage )
        self.pcan.Messages['dc_battery'].addSignal( soc )
        self.pcan.Messages['dc_battery'].addSignal( isMaster )
        self.pcan.Messages['dc_battery'].addSignal( isCharging )

        self.pcan.Messages['dc_grid'].addSignal( current )
        self.pcan.Messages['dc_grid'].addSignal( voltage )
        self.pcan.Messages['dc_grid'].addSignal( isMaster )
        self.pcan.Messages['dc_grid'].addSignal( isFeed )
        self.pcan.Messages['dc_grid'].addSignal( isOn )

        self.pcan.Messages['dc_pv'].addSignal( current )
        self.pcan.Messages['dc_pv'].addSignal( voltage )

        self.pcan.Messages['dc_charging'].addSignal( current )
        self.pcan.Messages['dc_charging'].addSignal( voltage )

    def mean(self, l):
        return float(sum(l))/len(l) if len(l) > 0 else 0

    def run(self):
        while True:
            receiveMessageId = self.pcan.receiveMessage()
            if receiveMessageId == self.pcan.Messages['dc_battery'].Id:

                self.battery_current.append(
                    self.pcan.Messages['dc_battery'].Signals['current'].GetData())
                self.battery_voltage.append(
                    self.pcan.Messages['dc_battery'].Signals['voltage'].GetData())
                self.battery_soc.append(
                    self.pcan.Messages['dc_battery'].Signals['soc'].GetData())
                self.battery_timestamp.append(datetime.now())

                if len(self.battery_timestamp) == 100:
                    if debug:
                        print 'current: ', self.mean(self.battery_current)
                        print 'voltage: ', self.mean(self.battery_voltage)
                        print 'SoC: ', self.mean(self.battery_soc)
                        print 'time: ', self.mean(self.battery_timestamp)

                    tabelle = 'battery'

                    list_daten = [(tabelle, str(self.battery_timestamp[i]),
                                  str(self.battery_current[i]),
                                  str(self.battery_voltage[i]),
                                  str(self.battery_soc[i])) for i in range(100)]

                    mean_daten = (tabelle, str(self.battery_timestamp[50]),
                             str(self.mean(self.battery_current)),
                             str(self.mean(self.battery_voltage)),
                             str(self.mean(self.battery_soc)))

                    sql = "INSERT INTO %s VALUES (\'%s\',%s,%s,%s)"

                    self.queue.put(mean_daten[0])

                    self.cursor.execute(sql % mean_daten)
                    #self.cursor.executemany(sql, daten)

                    ## clear tmp lists ##
                    del self.battery_current[:], self.battery_voltage[:],
                    del self.battery_soc[:], self.battery_timestamp[:]
            sleep(0.01)