#!/usr/bin/python
# -*- coding: latin-1 -*-

import os, sys
import platform
import sqlite3 as lite
import time
import wget
from shutil import copyfile
import pandas as pd
import datetime
import numpy as np
import matplotlib.pyplot as plt
import calendar

# Softwareversion
Version= "0.95"
# 2.6.19 9:00

class Konfiguration_verwalten():
    def __init__(self):
        self.Konfigurationspfad=os.path.join(os.path.dirname(os.path.realpath(sys.argv[0])),"Konfiguration.txt")
        self.Konfiguration=self.Konfiguration_laden()
        self.KeyAnzeigenreihenfolge=['Installierte_PVLeistung', 'Port', 'S0_Pulse_pro_kWh', 'OBIS_Bezug', 'OBIS_Einspeisung', 'USB_PortNr_SML', \
                                     'SML_Faktor', 'Anzeige_Startseite'] #Wegen Anzeigereihenfolge
        for key in self.Konfiguration: 
            if key not in self.KeyAnzeigenreihenfolge:
                self.KeyAnzeigenreihenfolge.append(key)
        
    def Konfiguration_laden(self):
        if not os.path.isfile(self.Konfigurationspfad): #Konfiguration existiert nicht
            Konfiguration={}
            Konfiguration.update({'Port':'80'})
            Konfiguration.update({'S0_Pulse_pro_kWh':'1000'})
            with open(self.Konfigurationspfad, 'w') as File:
                for key in Konfiguration:                
                    print(key+": "+str(Konfiguration[key]), file=File)            
    
        Konfiguration={}
        with open(self.Konfigurationspfad, 'r') as File:
            for line in File:
                if len(line.rstrip().split(": "))==2:
                    (key, val) = line.rstrip().split(": ")
                    Konfiguration[key] = val
                else:
                    key = line.rstrip().rstrip(": ")
                    Konfiguration[key] = ''
                
        if not 'OBIS_Bezug' in Konfiguration or not 'OBIS_Einspeisung' in Konfiguration : # Alte Konfigurationsfileversion
            Konfiguration['OBIS_Bezug']=''
            Konfiguration['OBIS_Einspeisung']=''
            self.Konfiguration=Konfiguration
            self.Konfiguration_speichern()
            
        if not 'USB_PortNr_SML' in Konfiguration: # Alte Konfigurationsfileversion
            Konfiguration['USB_PortNr_SML']='' #Hier steht dann nur die Zahl ohne Vorsilbe
            self.Konfiguration=Konfiguration
            self.Konfiguration_speichern()    
            
        if not 'SML_Faktor' in Konfiguration: # Alte Konfigurationsfileversion
            Konfiguration['SML_Faktor']='1' 
            self.Konfiguration=Konfiguration
            self.Konfiguration_speichern()                
        
        if not 'Anzeige_Startseite' in Konfiguration: # Alte Konfigurationsfileversion
            Konfiguration['Anzeige_Startseite']='' #Bei 1 oder '' wird Zeile angezeigt, bei 0 nicht. Jede Ziffer ist eine Zeile
            self.Konfiguration=Konfiguration
            self.Konfiguration_speichern()                

        if not 'Installierte_PVLeistung' in Konfiguration: # Alte Konfigurationsfileversion
            Konfiguration['Installierte_PVLeistung']='1.0' 
            self.Konfiguration=Konfiguration
            self.Konfiguration_speichern()                

        self.S0_nach_kWh=1000.0/int(Konfiguration['S0_Pulse_pro_kWh'])
        try:
            float(Konfiguration['Installierte_PVLeistung'])==0.0
        except:
            Konfiguration['Installierte_PVLeistung']='1.0' 
            self.Konfiguration=Konfiguration
            self.Konfiguration_speichern()       
        return Konfiguration
    
    def Konfiguration_speichern(self):
        with open(self.Konfigurationspfad, 'w') as File:
            for key in self.Konfiguration:                
                print(key+": "+str(self.Konfiguration[key]), file=File) 
        return     


class Plattform_Konfiguration():
    def __init__(self):
        # Konfigurationsparameter
        db_file_raspi= "/home/pi/FreeSol/FreeSolRaspi.db"
        db_file_windows= "FreeSolRaspi.db"
        
        outputfile_raspi= "/home/pi/FreeSol/Daten.hex"
        outputfile_windows= "Daten.hex"
        
        portprefix_raspi="/dev/"
        portprefix_windows="COM"
        
        bildpfad_raspi="/webserv/"
        bildpfad_windows="./Bilder/"
        
        # Welche Platform?
        if platform.system()=="Windows":
            self.Plattform="Windows"
            self.db_filename = db_file_windows
            self.Outputfile=outputfile_windows
            self.portprefix="COM"
            self.bildpfad=bildpfad_windows
        else:
            self.Plattform="Raspi"
            self.db_filename = db_file_raspi
            self.Outputfile=outputfile_raspi
            self.portprefix="/dev/ttyUSB"
            self.bildpfad=bildpfad_raspi
            
class Softwareversionen_verwalten():
    def __init__(self):
        self.Software_Files = ['CherryPy-Zaehler.py', 'S0_Solar.py', 'S0_Solar_Test.py', \
                          'hexdump.py', 'FreeSolRaspi_Helper.py' , 'SMLParser.py', 'FreeSol-SML-Schnittstellentest.py', \
                          'SML_Bezug_Einspeisung.py']
        self.Startfilepfad=os.path.dirname(os.path.realpath(sys.argv[0]))
        
        self.InstVer=self.Installierte_Versionen()
        self.VerfVer=self.Verfuegbare_Versionen()
        
        Updateliste=[]
        for File in self.Software_Files:
            print(self.InstVer[File], self.VerfVer[File])
            try:
                inst=self.InstVer[File].split(".")
                verf=self.VerfVer[File].split(".")
                inst=[int(i) for i in inst]
                verf=[int(i) for i in verf]
                if verf[0]>inst[0] or (verf[0]==inst[0] and verf[1]>inst[1]): # Verfügbare Software ist neuer, installieren
                    Updateliste.append(File)
            except:
                pass
            if inst[0]=="":
                Updateliste.append(File)
                    
        self.Updateliste=Updateliste
        
        if len(self.Updateliste)==0:
            self.Updatetext ="Keine"
        else:
            self.Updatetext=", ".join(str(x) for x in self.Updateliste)  
            
        self.InstVer=self.Versionen_Zu_Output(self.InstVer)
        self.VerfVer=self.Versionen_Zu_Output(self.VerfVer)
        
    def Installierte_Versionen(self):
        Ergebnis={}
        for File in self.Software_Files:
            Version=""
            try:
                with open(os.path.join(self.Startfilepfad,File), 'rb') as search:
                    for line in search:
                        if "Version=" in str(line):
                            Version= str(line).split(" ")[1][1:-4]
                            break
                Ergebnis.update({File : Version})
            except:
                Ergebnis.update({File : ""})
            
        print(Ergebnis)
        return Ergebnis
    
    def Verfuegbare_Versionen(self):
        # bisherige aktuelle versionen aus Downloadverzeichnis löschen
        Pfad=os.path.join(self.Startfilepfad,"aktuelle_Version")
        if not os.path.isdir(Pfad):
            os.mkdir(Pfad)
        else:
            for Datei in self.Software_Files:
                Dateipfad=os.path.join(Pfad, Datei)
                if os.path.isfile(Dateipfad):
                    os.remove(Dateipfad)    
                
        # neue aktuelle Versionen herunterladen
        for File in self.Software_Files:
            Dateipfad=os.path.join(Pfad,File)    
            url = 'https://www.freesol.de/download/' 
            wget.download(url+File, Dateipfad)
        
        # Dict mit Filenamen und Versionen erstellen
        Ergebnis={}
        for File in self.Software_Files:
            Version=""
            Dateipfad=os.path.join(Pfad, File)
            with open(Dateipfad, 'rb') as search:
                for line in search:
                    if "Version=" in str(line):
                        Version= str(line).split(" ")[1][1:-4]
                        break
            Ergebnis.update({File : Version})
        print(Ergebnis)
        return Ergebnis
    
    def Versionen_Zu_Output(self, Versionsdict):
        Ergebnis=""
        for key in  Versionsdict:
            Ergebnis +=key +": "+Versionsdict[key]+"<br>"
        return Ergebnis        

            
def InitialisiereDB(db_filename):
    #Prüfen ob DB existiert
    if not os.path.isfile(db_filename): #Erste Einrichtung der Datenbank
        con = lite.connect(db_filename)          
        try:
            with con:    
                cur = con.cursor()    
                cur.execute("CREATE TABLE SolarS0 (date text, S0 integer)")
                con.commit()          
        except:
            print("Fehler beim Datenbank Anlegen")
            sys.exit(1)  
        con.close() 

    # Prüfe, ob BezEinsp-Tabelle existiert
    con = lite.connect(db_filename)      
    with con:    
        query = "SELECT count(*) FROM sqlite_master WHERE type='table' AND name='BezEinsp'" 
        df00 = pd.read_sql(query, con)        
    con.close()          
    
    if df00.values[0][0]==0:
        # Tabelle existiert nicht, anlegen
        con = lite.connect(db_filename)          
        try:
            with con:    
                cur = con.cursor()    
                cur.execute("CREATE TABLE BezEinsp (date text, Bezug real, Einspeis real)")
                con.commit()        
        except:
            print("Fehler beim Anlegen der Tabelle BezEinsp")
            sys.exit(1)       
        con.close()
            
        
def AktuelleSolarleistung():
    Plattform=Plattform_Konfiguration()
    InitialisiereDB(Plattform.db_filename)
    Konfiguration=Konfiguration_verwalten()
        
    # DB Lesen 
    #gestern = (datetime.date.today() - datetime.timedelta(days=1)).strftime('%y%m%d')
    heute = datetime.date.today().strftime('%Y-%m-%d')
    #print(heute)
    con = lite.connect(Plattform.db_filename)          
    
    with con:    
        query = '''SELECT *
                   FROM SolarS0
                   WHERE SUBSTR(date,0,11) = ''' 
        query =query+ "'" + heute + "'"
        
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    df00=df00.dropna(how='all') 
    
    df00=df00.replace('', np.nan, regex=True)
    #print(df00)
    
    
    #Gesamtenergie Tag
    if df00["S0"].count() >0:
        PGesamtHeute=  int(df00["S0"].sum()*Konfiguration.S0_nach_kWh)
    else:
        PGesamtHeute=  0*Konfiguration.S0_nach_kWh
    #print(PGesamtHeute)
         
    #Maximalleistung
    if df00["S0"].count() >0:
        ColMax=df00.ix[df00['S0'].idxmax()]
        ZeitpunktMax=ColMax['date']
        PMax= str(int(ColMax['S0']*60*Konfiguration.S0_nach_kWh))
    else:
        ZeitpunktMax="-"
        PMax= "0.0"  #*Konfiguration.S0_nach_kWh
    #print(ZeitpunktMax, PMax)
    
    #Letzte Leistung
    con = lite.connect(Plattform.db_filename)          
    with con:    
        query = "SELECT * FROM SolarS0 ORDER BY date DESC LIMIT 1"
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    df00=df00.dropna(how='all') 
    df00=df00.replace('', np.nan, regex=True)    
    if df00["S0"].count() >0:
        ZeitpunktLetztes=df00.iloc[-1]['date']
        PGesamtLetzes= str(int(df00.iloc[-1]['S0']*60*Konfiguration.S0_nach_kWh))
    else:
        ZeitpunktLetztes="-"
        PGesamtLetzes= "0.0" #*Konfiguration.S0_nach_kWh
    #print(ZeitpunktLetztes, PGesamtLetzes)    
    
    
    ### Vortag
    gestern = (datetime.date.today() - datetime.timedelta(days=1)).strftime('%Y-%m-%d')
    con = lite.connect(Plattform.db_filename)          
    
    with con:    
        query = '''SELECT *
                   FROM SolarS0
                   WHERE SUBSTR(date,0,11) = ''' 
        query =query+ "'" + gestern + "'"
    
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    df00=df00.dropna(how='all') 
    
    df00=df00.replace('', np.nan, regex=True)
    #print(df00)
    
    #Gesamtenergie Tag gestern
    if df00["S0"].count() >0:
        PGesamtGestern=  int(df00["S0"].sum()*Konfiguration.S0_nach_kWh)
    else:
        PGesamtGestern=  0 #*Konfiguration.S0_nach_kWh
    #print(PGesamtGestern)  
    
    #Maximalleistung gestern
    if df00["S0"].count() >0:
        ColMax=df00.ix[df00['S0'].idxmax()]
        ZeitpunktMaxGestern=ColMax['date']
        PMaxGestern= str(int(ColMax['S0']*60*Konfiguration.S0_nach_kWh))
    else:
        ZeitpunktMaxGestern="-"
        PMaxGestern= "0.0" #*Konfiguration.S0_nach_kWh

    #print(ZeitpunktMaxGestern, PMaxGestern)
    
    ### Letzter Messwert
    con = lite.connect(Plattform.db_filename)          
    
    with con:    
        query = '''SELECT *
                   FROM SolarS0
                   ORDER BY date DESC LIMIT 1''' 
    
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    if len(df00)>0:
        LetzterZeitpunkt=df00.iloc[0]['date']
        LetzterMesswert=df00.iloc[0]['S0']  # hier ohne *Konfiguration.S0_nach_kWh
    else:
        LetzterZeitpunkt="----------"
        LetzterMesswert=0
    #print(LetzterZeitpunkt)
    #print(LetzterMesswert)
    
    
    return ZeitpunktLetztes, PGesamtLetzes, PGesamtHeute, ZeitpunktMax, PMax, PGesamtGestern, ZeitpunktMaxGestern, PMaxGestern, LetzterZeitpunkt, LetzterMesswert

def AktuellerBezugEinspeisung():
    Plattform=Plattform_Konfiguration()
    InitialisiereDB(Plattform.db_filename)
    Konfiguration=Konfiguration_verwalten()
    KorrFakt=float(Konfiguration.Konfiguration['SML_Faktor'])
    
    #Gesamtenergie Tag
    heute = (datetime.date.today()).strftime('%Y-%m-%d')
    con = lite.connect(Plattform.db_filename)          
    with con:    
        query = '''SELECT *
                   FROM BezEinsp
                   WHERE SUBSTR(date,0,11) = ''' 
        query =query+ "'" + heute + "'"
        
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    
    df00=df00.dropna(how='all') 
    df00=df00.replace('', np.nan, regex=True)
    
    if len(df00) >=2:
        df00=df00.sort_values(by='date')
        Bezugheute=(df00.tail(1)['Bezug'].values[0]-df00.head(1)['Bezug'].values[0])*KorrFakt
        Einspeisheute=(df00.tail(1)['Einspeis'].values[0]-df00.head(1)['Einspeis'].values[0])*KorrFakt
    else:
        Bezugheute=0.0
        Einspeisheute=0.0
        
    
    # Zeitpunkt und letzte Leistung Bezug Einspeisung
    con = lite.connect(Plattform.db_filename)          
    with con:    
        query = "SELECT * FROM BezEinsp ORDER BY date DESC LIMIT 2"
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    if len(df00)==2:
        mult=60.0*KorrFakt
        LetzterBezug=round(mult*df00.head(1)['Bezug'].values[0],2)-round(mult*df00.tail(1)['Bezug'].values[0], 2)
        LetzteEinspeis=round(mult*df00.head(1)['Einspeis'].values[0],2)-round(mult*df00.tail(1)['Einspeis'].values[0], 2)
        ZeitpunktLetzterBezEinsp=df00.head(1)['date'].values[0]
    else:
        LetzterBezug=0.0
        LetzteEinspeis=0.0    
        ZeitpunktLetzterBezEinsp="----------"
    
    
    #Gesamtenergie Vortag
    gestern = (datetime.date.today() - datetime.timedelta(days=1)).strftime('%Y-%m-%d')
    con = lite.connect(Plattform.db_filename)          
    with con:    
        query = '''SELECT *
                   FROM BezEinsp
                   WHERE SUBSTR(date,0,11) = ''' 
        query =query+ "'" + gestern + "'"
        
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    df00=df00.dropna(how='all') 
    df00=df00.replace('', np.nan, regex=True)
    if len(df00) >=2:
        df00=df00.sort_values(by='date')
        Bezuggestern=(df00.tail(1)['Bezug'].values[0]-df00.head(1)['Bezug'].values[0])*KorrFakt
        Einspeisgestern=(df00.tail(1)['Einspeis'].values[0]-df00.head(1)['Einspeis'].values[0])*KorrFakt
    else:
        Bezuggestern=0.0
        Einspeisgestern=0.0

    return Bezugheute, Einspeisheute, Bezuggestern, Einspeisgestern, LetzterBezug, LetzteEinspeis, ZeitpunktLetzterBezEinsp

def AktuelleZählerständeSML():
    Plattform=Plattform_Konfiguration()
    InitialisiereDB(Plattform.db_filename)
    
    # Zeitpunkt und letzte Leistung Bezug Einspeisung
    con = lite.connect(Plattform.db_filename)          
    with con:    
        query = "SELECT * FROM BezEinsp ORDER BY date DESC LIMIT 1"
        df00 = pd.read_sql(query, con)        
    con.close()  
    
    #print(df00)
    
    if len(df00)==1:
        BezugStand=round(df00.head(1)['Bezug'].values[0],2)
        EinspeisStand=round(df00.head(1)['Einspeis'].values[0],2)
        ZeitpunktLetzterBezEinsp=df00.head(1)['date'].values[0]
    else:
        BezugStand=0.0
        EinspeisStand=0.0    
        ZeitpunktLetzterBezEinsp="----------"

    return BezugStand, EinspeisStand, ZeitpunktLetzterBezEinsp


def Abfrage(Art = 'Stunden', Tag='000000', Monat='0000', Jahr='00'):
    # Art aus 
    #    'Tag': Zusätzlich Tag = '160115' 
    
    Plattform=Plattform_Konfiguration()

    # Für Raspi die Grafikausgabe umleiten
    if Plattform.Plattform=="Raspi":
        print('No display found. Using non-interactive Agg backend')
        plt.switch_backend('Agg')
    
    InitialisiereDB(Plattform.db_filename)
    
    # Gibt es Bezugs-Einspeisezähler?
    Konfiguration=Konfiguration_verwalten()
    if Konfiguration.Konfiguration['OBIS_Bezug']!="" and Konfiguration.Konfiguration['OBIS_Bezug']!="": #ja
        ##################### Solarzähler 
        # DB Lesen  
        con = lite.connect(Plattform.db_filename)   
        
        with con:    
            query = '''SELECT *
                       FROM SolarS0'''
            df = pd.read_sql(query, con)        
        
        # Heraussuchen des Zeitraums
        if Art == 'Tag':
            df2=df[df['date'].str[2:10]==Tag[0:2]+"-"+Tag[2:4]+"-"+Tag[4:6]]
            df2['date']=df2['date'].str[11:13]
            for i in range(24):
                df2 = df2.append({'date': "{0:02d}".format(i), 'S0': 0, }, ignore_index=True)            
            df3=pd.pivot_table(df2,index=["date"],aggfunc=np.sum)     
        elif Art == 'Monat':
            df2=df[df['date'].str[2:7]==Monat[0:2]+"-"+Monat[2:4]]
            df2['date']=df2['date'].str[8:10]
            _, TageimMonat = calendar.monthrange(2000+int(Monat[0:2]), int(Monat[2:4]))
            for i in range(1,TageimMonat+1):
                df2 = df2.append({'date': "{0:02d}".format(i), 'S0': 0, }, ignore_index=True)            
            df3=pd.pivot_table(df2,index=["date"],aggfunc=np.sum)     
        elif Art == 'Jahr':
            df2=df[df['date'].str[2:4]==Jahr[0:2]]
            df2['date']=df2['date'].str[5:7]
            for i in range(1,13):
                df2 = df2.append({'date': "{0:02d}".format(i), 'S0': 0, }, ignore_index=True)            
            df3=pd.pivot_table(df2,index=["date"],aggfunc=np.sum)     
    
        df3=df3.rename(columns = {'S0':'Solar'})
        try: 
            Konfiguration=Konfiguration_verwalten()
            df3["Solar"]=df3["Solar"]/1000.0*Konfiguration.S0_nach_kWh
        except:
            print("Fehler in S0-Daten")
            return -1   
        
        print(df3)
        df3=df3.reset_index()
        
        
        ###################### Bezugs- Einspeisezähler
        # DB Lesen  
        con = lite.connect(Plattform.db_filename)   
        
        with con:    
            query = '''SELECT *
                       FROM BezEinsp'''
            df = pd.read_sql(query, con)  
            
        # Heraussuchen des Zeitraums
        LetztenWertErgaenzen=False
        if Art == 'Tag':
            df2=df[df['date'].str[2:10]==Tag[0:2]+"-"+Tag[2:4]+"-"+Tag[4:6]]
            df2=df2[df2['date'].str[14:16].isin(['00'])]
            df2['date']=df2['date'].str[11:13]
            if datetime.date.today().strftime('%y%m%d')==Tag:
                LetztenWertErgaenzen=True        
        elif Art == 'Monat':
            df2=df[df['date'].str[2:7]==Monat[0:2]+"-"+Monat[2:4]]
            df2=df2[df2['date'].str[11:16].isin(['00:00'])]
            df2['date']=df2['date'].str[8:10]
            if datetime.date.today().strftime('%y%m')==Monat:
                LetztenWertErgaenzen=True        
        elif Art == 'Jahr':
            df2=df[df['date'].str[2:4]==Jahr[0:2]]
            df2=df2[df2['date'].str[8:16].isin(['01 00:00'])]
            df2['date']=df2['date'].str[5:7]
            if datetime.date.today().strftime('%y')==Jahr:
                LetztenWertErgaenzen=True               
            
        if len(df2)==0:        
            print("Leere Daten")
            return -1
    
        # DF Sortiern (falls Werte eingefügt wurden)
        df2=df2.sort_values(by=['date'], ascending=[1])
    
        #print "Selektierte Werte"
        comparison_array = df2.tail(1).reset_index(drop=True) == df.tail(1).reset_index(drop=True)
        #print comparison_array.values
            
        if (False in comparison_array.values) and LetztenWertErgaenzen==True: #        Es gibt einen Wert zum Anhängen
            df2=pd.concat([df2, df.tail(1)])   
            
        KorrFakt=float(Konfiguration.Konfiguration['SML_Faktor'])
        df2["Bezug"]=df2["Bezug"]*KorrFakt
        df2["Einspeis"]=df2["Einspeis"]*KorrFakt
        df4=df2
        
        df4['EinspeisDelta']=(df4['Einspeis'].shift(-1)-df4['Einspeis'])
        df4=df4.drop('Einspeis',1)
        df4=df4.rename(columns = {'EinspeisDelta':'Einspeis'})
        df4['BezugDelta']=(df4['Bezug'].shift(-1)-df4['Bezug'])
        df4=df4.drop('Bezug',1)
        df4= df4.dropna(how='any')
        df4=df4.rename(columns = {'BezugDelta':'Bezug'})
        df4=df4.reset_index()
    
    
        ##################### Zusammenfügen der Dataframes
        df5= pd.merge(df3,df4,on='date',how='outer')
        
        df6= df5.dropna(how='any')
        df6['Verbrauch']=df6['Bezug']+df6['Solar']-df6['Einspeis']
        df6['Eigenverbrauch']=df6['Solar']-df6['Einspeis']
        df6=df6.drop('Bezug',1).drop('Einspeis',1).drop('Solar',1)
        df5= pd.merge(df5,df6,on='date',how='outer')
        df5['Solar']=-df5['Solar']
        #df5['Einspeis']=-df5['Einspeis']
        df5['Solarverbrauch']=-df5['Eigenverbrauch']
        #df5['Eigenverbrauch']=-df5['Eigenverbrauch']
        df5['Bezug']=-df5['Bezug']
        df5.reset_index( level=0, inplace=True ) #Index als Column
        df5=df5.rename(columns = {'date':'Zeitpunkt'})
        df5=df5.rename(columns = {'Einspeis':'Einspeisung'})
        df5=df5[['Zeitpunkt', 'Solarverbrauch', 'Bezug', 'Eigenverbrauch', 'Einspeisung']]
        
        #print("Zusammengefuegt:")
        #print(df5)
            
        ##################### Ausgabe in Mathplotlib
        Einspeisung = round(df5['Einspeisung'].sum(),1)
        Eigenverbrauch = round(df5['Eigenverbrauch'].sum(),1)
        Solarerzeugung=round(Eigenverbrauch+Einspeisung,1)
        Bezug = -round(df5['Bezug'].sum(),1)
        Solarverbrauch = -round(df5['Solarverbrauch'].sum(),1)
        Eigenverbrauchsquote=round(Eigenverbrauch/Solarerzeugung *100.0, 1)
        Verbrauch=round(Bezug+Solarverbrauch,1)
        Solarquote=round(Solarverbrauch/Verbrauch*100.0, 1)
        kWhProkWp= round(Solarerzeugung/float(Konfiguration.Konfiguration['Installierte_PVLeistung']), 1)
        #print("ES:  " + str(Einspeisung)+ " kWh")
        #print("EV:  " + str(Eigenverbrauch)+ " kWh")
        #print("Sol: "+ str( Solarerzeugung)+ " kWh")
        #print
        #print("Bez: "+ str( Bezug)+ " kWh")
        #print("Bez: "+ str( Solarverbrauch)+ " kWh")
        #print("Ver: "+ str( Verbrauch)+ " kWh")
        #print("EVQ: " + str(Eigenverbrauchsquote) + " %")
        #print("SoQ: " + str(Solarquote) + " %")
        #print("kWh/kWp: " + str(kWhProkWp) + " kWh")
        
        if Art == 'Tag':
            if Art == 'Tag':
                df5['Zeitpunkt']=df5['Zeitpunkt'].str[:6]
        
            if len(df5)>0:
                df5=df5.set_index('Zeitpunkt')
                ax= df5.plot(kind='bar',stacked=True, color=['r', 'b', 'y', 'g'])
                ax.grid(color='gray', linestyle='dashed')
                ax.set_axisbelow(True)
                ax.set_xlabel("Zeitpunkt",fontsize=12)
                ax.set_ylabel("kWh",fontsize=12)           
                ax.set_title("Energie pro h in kWh am "+Tag)
                
                # nur jede n-ten Tick beschriften
                n=2
                labels = [item.get_text() for item in ax.get_xticklabels()]
                for i in range(len(labels)):
                    if i/n!=i//n:
                        labels[i] = ''
                #print labels        
                ax.set_xticklabels(labels)
                plt.axhline(y = 0)
                plt.tight_layout() 
                
                # Shrink current axis by 30%
                box = ax.get_position()
                ax.set_position([box.x0, box.y0 +box.height*0.13, box.width, box.height*0.65])
                
                # Put a legend to the right of the current axis
                ax.legend(loc='upper left', bbox_to_anchor=(0.1,1.36), ncol=2)
                
                #Kennzahlen zufügen:
                plt.figtext(.11, .02, "Verbrauch: "+ str( Verbrauch)+ " kWh\n"\
                                      "Solarverbrauch: "+ str( Solarverbrauch)+ " kWh\n"\
                                      "Solarquote: " + str(Solarquote) + " %",  fontsize=10)   
                                   
                                      
                plt.figtext(.40, .02,  "Solarerzeugung: "+ str( Solarerzeugung)+ " kWh\n"\
                                "Eigenverbrauch:  " + str(Eigenverbrauch)+ " kWh \n"
                                "Eigenverbrauchsquote: " + str(Eigenverbrauchsquote) + " %",  fontsize=10)                   
                                                     
                plt.figtext(.75, .02, "Bezug: "+ str( Bezug)+ " kWh\n"\
                            "Einspeisung: " + str(Einspeisung)+ " kWh\n"\
                           "kWh / kWp: "+str(kWhProkWp)+ " kWh",  fontsize=10)                   
    
                plt.savefig(Plattform.bildpfad+"Stundenwerte "+Tag)
                
                return 0
            else:
                print("Leere Daten")
                return -1
    
        elif Art =="Monat":
            if len(df5)>0:
                print(df5)
                f = lambda x: x[:2]+"-"+x[2:4]+"-"+x[4:6]
                df5['Zeitpunkt']=df5['Zeitpunkt'].apply(f)
                df5=df5.set_index('Zeitpunkt')
                ax= df5.plot(kind='bar',stacked=True, color=['r', 'b', 'y', 'g'])
                ax.grid(color='gray', linestyle='dashed')
                ax.set_axisbelow(True)
                ax.set_xlabel("Zeitpunkt",fontsize=12)
                ax.set_ylabel("kWh",fontsize=12)    
                
                ax.set_title("Energie pro Tag in kWh: "+Monat)
                plt.axhline(y = 0)
                plt.tight_layout() 
        
                # Shrink current axis by 30%
                box = ax.get_position()
                ax.set_position([box.x0, box.y0 +box.height*0.13, box.width, box.height*0.65])
                
                # Put a legend to the right of the current axis
                ax.legend(loc='upper left', bbox_to_anchor=(0.1,1.36), ncol=2)
                
                #Kennzahlen zufügen:
                plt.figtext(.11, .02, "Verbrauch: "+ str( Verbrauch)+ " kWh\n"\
                                      "Solarverbrauch: "+ str( Solarverbrauch)+ " kWh\n"\
                                      "Solarquote: " + str(Solarquote) + " %",  fontsize=10)   
                                   
                                      
                plt.figtext(.40, .02,  "Solarerzeugung: "+ str( Solarerzeugung)+ " kWh\n"\
                                "Eigenverbrauch:  " + str(Eigenverbrauch)+ " kWh \n"
                                "Eigenverbrauchsquote: " + str(Eigenverbrauchsquote) + " %",  fontsize=10)                   
                                                     
                plt.figtext(.75, .02, "Bezug: "+ str( Bezug)+ " kWh\n"\
                            "Einspeisung: " + str(Einspeisung)+ " kWh\n"\
                            "kWh / kWp: "+str(kWhProkWp)+ " kWh",  fontsize=10)                   
                 
         
                plt.savefig(Plattform.bildpfad+ "Monatswerte " +Monat)        
                return 0
            else:
                return -1
    
        elif Art =="Jahr":
            if len(df5)>0:
                f = lambda x: x[:2]+"-"+x[2:4]
                df5['Zeitpunkt']=df5['Zeitpunkt'].apply(f)
                df5=df5.set_index('Zeitpunkt')
                ax= df5.plot(kind='bar',stacked=True, color=['r', 'b', 'y', 'g'])
                ax.grid(color='gray', linestyle='dashed')
                ax.set_axisbelow(True)
                ax.set_xlabel("Zeitpunkt",fontsize=12)
                ax.set_ylabel("kWh",fontsize=12)    
                
                ax.set_title("Energie pro Monat in kWh: "+Jahr)
    
                plt.axhline(y = 0)
                plt.tight_layout() 
        
                # Shrink current axis by 30%
                box = ax.get_position()
                ax.set_position([box.x0, box.y0 +box.height*0.13, box.width, box.height*0.65])
                
                # Put a legend to the right of the current axis
                ax.legend(loc='upper left', bbox_to_anchor=(0.1,1.36), ncol=2)
                
                #Kennzahlen zufügen:
                plt.figtext(.11, .02, "Verbrauch: "+ str( Verbrauch)+ " kWh\n"\
                                      "Solarverbrauch: "+ str( Solarverbrauch)+ " kWh\n"\
                                      "Solarquote: " + str(Solarquote) + " %",  fontsize=10)   
                                   
                                      
                plt.figtext(.40, .02,  "Solarerzeugung: "+ str( Solarerzeugung)+ " kWh\n"\
                                "Eigenverbrauch:  " + str(Eigenverbrauch)+ " kWh \n"
                                "Eigenverbrauchsquote: " + str(Eigenverbrauchsquote) + " %",  fontsize=10)                   
                                                     
                plt.figtext(.75, .02, "Bezug: "+ str( Bezug)+ " kWh\n"\
                            "Einspeisung: " + str(Einspeisung)+ " kWh\n"\
                            "kWh / kWp: "+str(kWhProkWp)+ " kWh",  fontsize=10)                   
                 
         
                plt.savefig(Plattform.bildpfad+ "Jahreswerte " +Jahr)        
                return 0
            else:
                return -1
       
            
        plt.draw()    
        plt.show()
        return 0
    
    else: #gibt nur S0 Zähler
        ##################### Bezugs- Einspeisezähler
        # DB Lesen  
        con = lite.connect(Plattform.db_filename)   
        
        with con:    
            query = '''SELECT *
                       FROM SolarS0'''
        
            df = pd.read_sql(query, con)        
        
        # Heraussuchen des Zeitraums
        if Art == 'Tag':
            df2=df[df['date'].str[2:10]==Tag[0:2]+"-"+Tag[2:4]+"-"+Tag[4:6]]
            df2['date']=df2['date'].str[11:13]
            for i in range(24):
                df2 = df2.append({'date': "{0:02d}".format(i), 'S0': 0, }, ignore_index=True)            
            df3=pd.pivot_table(df2,index=["date"],aggfunc=np.sum)     
        elif Art == 'Monat':
            df2=df[df['date'].str[2:7]==Monat[0:2]+"-"+Monat[2:4]]
            df2['date']=df2['date'].str[8:10]
            _, TageimMonat = calendar.monthrange(2000+int(Monat[0:2]), int(Monat[2:4]))
            for i in range(1,TageimMonat+1):
                df2 = df2.append({'date': "{0:02d}".format(i), 'S0': 0, }, ignore_index=True)            
            df3=pd.pivot_table(df2,index=["date"],aggfunc=np.sum)     
        elif Art == 'Jahr':
            df2=df[df['date'].str[2:4]==Jahr[0:2]]
            df2['date']=df2['date'].str[5:7]
            for i in range(1,13):
                df2 = df2.append({'date': "{0:02d}".format(i), 'S0': 0, }, ignore_index=True)            
            df3=pd.pivot_table(df2,index=["date"],aggfunc=np.sum)     
    
        try: 
            df3["S0"]=df3["S0"]/1000.0
        except:
            print("Leere Daten")
            return -1        
        
        print(df3)
        
        ##################### Ausgabe in Mathplotlib
        Solarerzeugung = round(df3['S0'].sum(),2)
        kWhProkWp= round(Solarerzeugung/float(Konfiguration.Konfiguration['Installierte_PVLeistung']), 2)
        print("Sol: "+ str( Solarerzeugung)+ " kWh")
        print("kWh/kWp: " + str(kWhProkWp) + " kWh")
        
        if Art == 'Tag':
            if len(df3)>0:
                ax= df3.plot(kind='bar',stacked=True, color=['y'])
                ax.set_xlabel("Zeitpunkt",fontsize=12)
                ax.set_ylabel("kWh",fontsize=12)           
                ax.set_title("Energie pro h in kWh am "+Tag)
                
                # nur jede n-ten Tick beschriften
                n=2
                labels = [item.get_text() for item in ax.get_xticklabels()]
                for i in range(len(labels)):
                    if i/n!=i//n:
                        labels[i] = ''
                ax.set_xticklabels(labels)
                plt.tight_layout() 
                
                # Shrink current axis by 30%
                box = ax.get_position()
                ax.set_position([box.x0, box.y0 +box.height*0.13, box.width, box.height*0.65])
                
                # Put a legend to the right of the current axis
                ax.legend(loc='upper left', bbox_to_anchor=(0.0,-0.21), ncol=2) #1.36
                
                #Kennzahlen zufügen:
                plt.figtext(.35, .07,  "Solarerzeugung: "+ str( Solarerzeugung)+ " kWh",  fontsize=10)                   
                plt.figtext(.7, .07, "kWh / kWp: "+str(kWhProkWp)+ " kWh",  fontsize=10)                   
                      
                if Art == 'Tag':
                    plt.savefig(Plattform.bildpfad+"Stundenwerte "+Tag)

                return 0
            else:
                print("Leere Daten")
                return -1
        
        elif Art =="Monat":
            print(df3)
            if len(df3)>0:
                ax= df3.plot(kind='bar',stacked=True, color=['y'])
                ax.set_xlabel("Zeitpunkt",fontsize=12)
                ax.set_ylabel("kWh",fontsize=12)    
                
                ax.set_title("Energie pro Tag in kWh: "+Monat)
                
                plt.tight_layout() 
        
                # Shrink current axis by 30%
                box = ax.get_position()
                ax.set_position([box.x0, box.y0 +box.height*0.13, box.width, box.height*0.65])
                
                # Put a legend to the right of the current axis
                ax.legend(loc='upper left', bbox_to_anchor=(0.0,-0.21), ncol=2) #1.36
                
                #Kennzahlen zufügen:
                plt.figtext(.35, .07,  "Solarerzeugung: "+ str( Solarerzeugung)+ " kWh",  fontsize=10)                   
                plt.figtext(.7, .07, "kWh / kWp: "+str(kWhProkWp)+ " kWh",  fontsize=10)                   
    
                plt.savefig(Plattform.bildpfad+ "Monatswerte " +Monat)        
                return 0
            else:
                return -1
        
        elif Art =="Jahr":
            if len(df3)>0:
                ax= df3.plot(kind='bar',stacked=True, color=['y'])
                ax.set_xlabel("Zeitpunkt",fontsize=12)
                ax.set_ylabel("kWh",fontsize=12)    
                
                ax.set_title("Energie pro Monat in kWh: "+Jahr)
                
                plt.tight_layout() 
        
                # Shrink current axis by 30%
                box = ax.get_position()
                ax.set_position([box.x0, box.y0 +box.height*0.13, box.width, box.height*0.65])
                
                # Put a legend to the right of the current axis
                ax.legend(loc='upper left', bbox_to_anchor=(0.0,-0.21), ncol=2) #1.36
                
                #Kennzahlen zufügen:
                plt.figtext(.35, .07,  "Solarerzeugung: "+ str( Solarerzeugung)+ " kWh",  fontsize=10)                   
                plt.figtext(.7, .07, "kWh / kWp: "+str(kWhProkWp)+ " kWh",  fontsize=10)                   
         
                plt.savefig(Plattform.bildpfad+ "Jahreswerte " +Jahr)        
                return 0
            else:
                return -1
        
        ##plt.draw()    
        ##plt.show()
        return 0        

if __name__ == '__main__':
    pass