#!/usr/bin/python3
import sys
import sqlite3
import matplotlib.pyplot as plt
import numpy as np
from datetime import datetime, timedelta
import matplotlib.dates as mdates
from PIL import Image

# Funktion zum Lesen von Temperatur-, Luftfeuchtigkeits- und Zeitstempeldaten aus der SQLite-Datenbank
def read_data_from_db(db_name):
    try:
        conn = sqlite3.connect(db_name)
        cursor = conn.cursor()
        cursor.execute("SELECT timestamp, temperature, humidity, moisture FROM sensor_data")
        data = cursor.fetchall()
        conn.close()
        return data
    except sqlite3.Error as e:
        print(f"Fehler beim Lesen aus der Datenbank: {e}")
        return []

# Funktion zum Erstellen eines Diagramms für Temperatur und Luftfeuchtigkeit (800x200 Pixel)
def create_temperature_humidity_plot(records, output_filename):
    if not records:
        print("Keine Daten gefunden.")
        return

    # Aktuelle Zeit und Filterzeitraum (letzte 24 Stunden)
    now = datetime.now()
    last_24_hours = now - timedelta(hours=24)

    # Filtern der Datensätze nach den letzten 24 Stunden
    filtered_records = [
        (datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"), temperature, humidity, moisture)
        for timestamp, temperature, humidity, moisture in records
        if datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S") >= last_24_hours
    ]
    if not filtered_records:
        print("Keine Daten in den letzten 24 Stunden gefunden.")
        return

    # Extrahieren von Zeitstempeln, Temperaturen, Luftfeuchtigkeit und Feuchtigkeit
    times = [timestamp for timestamp, _, _, _ in filtered_records]
    temperatures = [temperature for _, temperature, _, _ in filtered_records]
    humidities = [humidity for _, _, humidity, _ in filtered_records]
    moistures = [moisture for _, _, _, moisture in filtered_records]

    # Grenzen für die y-Achsen basierend auf den Daten
    min_temp = np.floor(min(temperatures) / 5) * 5
    max_temp = np.ceil(max(temperatures) / 5) * 5
    min_humidity = np.floor(min(humidities) / 10) * 10
    max_humidity = np.ceil(max(humidities) / 10) * 10
    min_moisture = np.floor(min(moistures) / 10) * 10
    max_moisture = np.ceil(max(moistures) / 10) * 10

    # Diagramm zeichnen (800x200 Pixel)
    fig, ax1 = plt.subplots(figsize=(8, 2), dpi=100)

    # Temperaturplot (linke Y-Achse)
    ax1.set_xlabel('Uhrzeit', color='white')
    ax1.set_ylabel('Temperatur (°C)', color='tab:red')
    ax1.plot(times, temperatures, color='tab:red', label='Temperatur')
    ax1.tick_params(axis='y', labelcolor='tab:red')
    ax1.tick_params(axis='x', colors='white')
    ax1.set_ylim(min_temp, max_temp)
    ax1.spines['top'].set_color('white')
    ax1.spines['bottom'].set_color('white')
    ax1.spines['left'].set_color('white')
    ax1.spines['right'].set_color('white')


    # Luftfeuchtigkeitsplot (rechte Y-Achse)
    ax2 = ax1.twinx()
    ax2.set_ylabel('Luftfeuchtigkeit (%)', color='tab:blue')
    ax2.plot(times, humidities, color='tab:blue', label='Luftfeuchtigkeit')
    ax2.tick_params(axis='y', labelcolor='tab:blue')
    ax2.set_ylim(min_humidity, max_humidity)
    ax2.tick_params(axis='x', colors='white')
    ax2.spines['top'].set_color('white')
    ax2.spines['bottom'].set_color('white')
    ax2.spines['left'].set_color('white')
    ax2.spines['right'].set_color('white')
    
    # Feuchtigkeitsplot (dritte Y-Achse)
    ax3 = ax1.twinx()
    ax3.spines['right'].set_position(('outward', 60))  # Platz für die dritte Achse schaffen
    ax3.set_ylabel('Feuchtigkeit (16-32k)', color='tab:green')
    ax3.plot(times, moistures, color='tab:green', label='Feuchtigkeit')
    ax3.tick_params(axis='y', labelcolor='tab:green')
    ax3.set_ylim(min_moisture, max_moisture)
    ax3.tick_params(axis='x', colors='white')
    ax3.spines['top'].set_color('white')
    ax3.spines['bottom'].set_color('white')
    ax3.spines['left'].set_color('white')
    ax3.spines['right'].set_color('white')

    # X-Achse formatieren
    ax1.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
    
    # Layout anpassen und Diagramm speichern
    fig.tight_layout()
    plt.savefig(output_filename, transparent=True, bbox_inches='tight')
    plt.close()


# Funktion zum Überlagern des Diagramms auf das Basisbild
def overlay_plot_on_image(base_image_path, plot_image_path, output_image_path):
    try:
        base_image = Image.open(base_image_path)
        plot_image = Image.open(plot_image_path).resize((800, 200))  # Größe des Plots anpassen
        
        # Überlagern des Diagramms auf das Basisbild (mit Transparenz)
        base_image.paste(plot_image, (112, 0), plot_image)  # Zentrieren: (1024 - 800) / 2 = 112

        # Kombiniertes Bild speichern
        base_image.save(output_image_path)
        print(f"Kombiniertes Bild gespeichert als {output_image_path}")
    except Exception as e:
        print(f"Fehler beim Überlagern des Diagramms: {e}")

# Hauptfunktion
def main():
    if len(sys.argv) != 3:
        print("Bitte geben Sie den Pfad zum Basisbild und den Pfad zum Ausgabebild an.")
        sys.exit(1)

    base_image_path = sys.argv[1]
    output_image_path = sys.argv[2]

    db_name = "/var/www/html/sensor_data.db"
    
    # Daten aus der Datenbank lesen
    records = read_data_from_db(db_name)

    # Temporäre Datei für das transparente Temperatur- und Feuchtigkeitsdiagramm
    plot_filename = "temperature_humidity_plot.png"
    
    # Diagramm erstellen und speichern
    create_temperature_humidity_plot(records, plot_filename)

    # Basisbild laden und Diagramm überlagern
    overlay_plot_on_image(base_image_path, plot_filename, output_image_path)

if __name__ == "__main__":
     main()