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

import sqlite3

def read_data_from_db(db_name):
    """
    Liest alle gespeicherten Temperatur- und Zeitstempeldaten aus der SQLite-Datenbank.

    :param db_name: Name der SQLite-Datenbankdatei
    :return: Liste von Tupeln mit (timestamp, temperature)
    """
    try:
        # Verbindung zur Datenbank herstellen
        conn = sqlite3.connect(db_name)
        cursor = conn.cursor()

        # Abfrage zum Abrufen aller Daten aus der Tabelle
        cursor.execute("SELECT timestamp, temperature FROM cpu_temperature")
        data = cursor.fetchall()  # Alle Ergebnisse abrufen

        conn.close()  # Verbindung schließen
        return data
    except sqlite3.Error as e:
        print(f"Fehler beim Lesen aus der Datenbank: {e}")
        return []



# Funktion zum Erstellen des Temperaturdiagramms mit Achsenbeschriftungen und Transparenz
def create_temperature_plot_with_labels(output_filename):
    db_name = "/var/www/html/cpu_temperature.db"
    records = read_data_from_db(db_name)

    if records:
        for timestamp, temperature in records:
            print(f"Zeit: {timestamp}, Temperatur: {temperature}°C")
    else:
        print("Keine Daten gefunden.")

    # 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)
        for timestamp, temperature 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 und Temperaturen aus den gefilterten Datensätzen
    times = [timestamp for timestamp, _ in filtered_records]
    temperatures = [temperature for _, temperature in filtered_records]

    # Grenzen für die y-Achse basierend auf den Temperaturdaten
    min_temp = np.floor(min(temperatures) / 5) * 5  # Abrunden auf das nächste Vielfache von 5
    max_temp = np.ceil(max(temperatures) / 5) * 5   # Aufrunden auf das nächste Vielfache von 5

    # Temperaturdiagramm zeichnen
    plt.figure(figsize=(8, 2), dpi=100)  # Größe des Diagramms: 800x100 Pixel
    plt.plot(times, temperatures, color='yellow', linewidth=2, label='Temperatur')
    plt.ylim(min_temp, max_temp)  # Y-Achse auf den Bereich der Daten begrenzen
    plt.xlabel('Uhrzeit', color='white')  # X-Achsenbeschriftung
    plt.ylabel('CPU Temp in °C', color='white')  # Y-Achsenbeschriftung
    plt.xticks(color='white')  # X-Achse beschriften (automatisch), gedreht für bessere Lesbarkeit
    plt.yticks(np.arange(min_temp, max_temp + 1, 5), color='white')  # Y-Achse in Schritten von 5 beschriften
    plt.grid(color='white', linestyle='--', linewidth=0.5, alpha=0.7)
    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
    plt.tight_layout()

    # Diagramm mit transparentem Hintergrund speichern
    plt.savefig(output_filename, transparent=True, bbox_inches='tight')
    plt.close()

# Funktion zum Laden und Überprüfen des Basisbildes
def load_and_check_base_image(image_path):
    try:
        base_image = Image.open(image_path)
        if base_image.size != (1024, 768):
            raise ValueError("Das Basisbild muss eine Größe von 1024x768 Pixeln haben.")
        return base_image
    except Exception as e:
        print(f"Fehler beim Laden des Basisbildes: {e}")
        return None

# 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)
        
        # Ü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():
    parser = argparse.ArgumentParser(description="Overlay transparentes Temperaturdiagramm auf ein Bild.")
    parser.add_argument("image", help="Pfad zum Basisbild (1024x768 Pixel)")
    parser.add_argument("output", help="Pfad zum kombinierten Ausgabebild")
    args = parser.parse_args()

    base_image_path = args.image
    output_image_path = args.output

    # Temporäre Datei für das transparente Temperaturdiagramm
    plot_filename = "temperature_plot_with_labels.png"

    # Schritte ausführen: Diagramm erstellen und überlagern
    create_temperature_plot_with_labels(plot_filename)
    overlay_plot_on_image(base_image_path, plot_filename, output_image_path)

if __name__ == "__main__":
    main()