import hassapi as hass
import datetime
import statistics

class AveragePowerUsageAdvanced(hass.Hass):
    def initialize(self):
        self.listen_state(self.calculate_average, "sensor.daily_total_consumed_energy") #Angepasst
        self.listen_state(self.calculate_average, "input_number.anzahl_wochen")
        self.run_daily(self.calculate_average, datetime.time(0, 0, 0))
        self.calculate_average(None, None, None, None, None)

    def calculate_average(self, entity, attribute, old, new, kwargs):
        try:
            anzahl_wochen = int(self.get_state("input_number.anzahl_wochen"))
        except (ValueError, TypeError):
            anzahl_wochen = 5
            self.log("Variable input_number.anzahl_wochen nicht gefunden oder ungültig. Verwende Standardwert 5 Wochen.")

        heute = datetime.date.today()
        wochentage = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"]
        modi = wochentage + ["Wochentag (Mo-Fr)", "Wochenende (Sa-So)", "Letzte Ferien daheim Wochentags", "Nicht Daheim"]
        attributes = {}

        for modus in modi:
            attributes[modus] = {}
            for wochentag_num in range(7):
                wochentag_name = wochentage[wochentag_num]
                attributes[modus][wochentag_name] = {}
                for stunde in range(24):
                    attributes[modus][wochentag_name][f"{stunde:02d}-{stunde+1:02d}"] = {"durchschnitt": None, "letzte_woche": None} #Angepasst
                    data_durchschnitt = []
                    data_letzte_woche = []

                    for woche in range(anzahl_wochen):
                        current_date = heute - datetime.timedelta(weeks=woche)
                        start_time = current_date.replace(hour=stunde, minute=0, second=0, microsecond=0)
                        end_time = current_date.replace(hour=stunde + 1, minute=0, second=0, microsecond=0)
                        bedingung_erfuellt = False

                        # Modus-spezifische Filterung (bleibt gleich)
                        if modus == "Letzte Ferien daheim Wochentags":
                            letzte_ferien = self.get_state('calendar.ferien', attribute='start_time')
                            if letzte_ferien:
                                letzte_ferien_date = datetime.datetime.fromisoformat(letzte_ferien[:-1])
                            else:
                                letzte_ferien_date = datetime.datetime.now()
                            if start_time.date() >= letzte_ferien_date.date() and 0 < current_date.weekday() < 6:
                                bedingung_erfuellt = True
                        elif modus == "Nicht Daheim":
                            bedingung_erfuellt = True
                        elif modus == "Wochentag (Mo-Fr)" and 0 < current_date.weekday() < 6:
                            bedingung_erfuellt = True
                        elif modus == "Wochenende (Sa-So)" and current_date.weekday() in (5, 6):
                            bedingung_erfuellt = True
                        elif wochentage[current_date.weekday()] == modus:
                            bedingung_erfuellt = True

                        if bedingung_erfuellt and current_date.weekday() == wochentag_num:
                            history = self.get_history(entity_id="sensor.daily_total_consumed_energy", start_time=start_time, end_time=end_time) #Angepasst
                            if history and history[0] and history[0][0] and 'state' in history[0][0]:
                                try:
                                    verbrauch = float(history[0][0]['state'])
                                    #Differenz zum Vortag berechnen (für stündlichen Verbrauch)
                                    start_time_vortag = start_time - datetime.timedelta(days=1)
                                    end_time_vortag = end_time - datetime.timedelta(days=1)
                                    history_vortag = self.get_history(entity_id="sensor.daily_total_consumed_energy", start_time=start_time_vortag, end_time=end_time_vortag)
                                    if history_vortag and history_vortag[0] and history_vortag[0][0] and 'state' in history_vortag[0][0]:
                                        verbrauch_vortag = float(history_vortag[0][0]['state'])
                                        stuendlicher_verbrauch = verbrauch - verbrauch_vortag
                                        if woche == 0:
                                            data_letzte_woche.append(stuendlicher_verbrauch)
                                        data_durchschnitt.append(stuendlicher_verbrauch)
                                    else:
                                        self.log(f"Keine Daten für den Vortag gefunden für {start_time}")
                                except ValueError:
                                    self.log(f"Ungültiger Wert in der Historie: {history[0][0]['state']}")
                            else:
                                self.log(f"Keine Daten gefunden für {start_time}")

                    if data_durchschnitt:
                        attributes[modus][wochentag_name][f"{stunde:02d}-{stunde+1:02d}"]["durchschnitt"] = round(statistics.mean(data_durchschnitt), 2)
                    if data_letzte_woche:
                        attributes[modus][wochentag_name][f"{stunde:02d}-{stunde+1:02d}"]["letzte_woche"] = round(statistics.mean(data_letzte_woche), 2)

        self.set_state("sensor.durchschnittlicher_stromverbrauch_advanced", state="Berechnet", attributes=attributes)