WaterGen.py

# Grafische Benutzeroberfläche (GUI)
import tkinter as tk
from tkinter import ttk
from tkcalendar import DateEntry
import tksvg
from tkinter import filedialog # NEU: Für Verzeichnisauswahl

# Datenverarbeitung
import pandas as pd
import csv
import numpy as np

# Datums- und Zeitfunktionen
from datetime import datetime, timedelta

# Visualisierung
import matplotlib
from matplotlib.figure import Figure
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg

# Bildverarbeitung
from PIL import Image, ImageTk, ImageDraw, ImageFont, ImageSequence

# Systemfunktionen
import threading
import os
import ctypes
from screeninfo import get_monitors
import webbrowser
import sys

# Mathematik und Zufall
import math
import random




# Verbesserte Farbpalette für konsistenten Darkmode
DISCORD_BG = "#3a393f"
DISCORD_DARK = "#2F3136"
DISCORD_DARKER = "#202225"
DISCORD_TEXT = "#FFFFFF"
DISCORD_GRAY_TEXT = "#96989D"
DISCORD_GREEN = "#4ee56e"
DISCORD_INPUT_BG = "#40444B"
BUTTON_COLOR = "#4ee56e"
BUTTON_HOVER = "#3aff58"

# Angepasste DateEntry-Klasse für Darkmode
class DarkDateEntry(DateEntry):
    """
    Eine angepasste DateEntry-Klasse mit Darkmode-Styling.
    """
    def __init__(self, master=None, **kw):
        # Darkmode-Farbdefinitionen für den Kalender
        dark_colors = {
            'background': DISCORD_DARK,          # Haupthintergrund
            'foreground': DISCORD_TEXT,          # Haupttext
            'bordercolor': DISCORD_DARKER,       # Rahmenfarbe
            'headersbackground': DISCORD_DARKER, # Hintergrund der Kopfzeilen
            'headersforeground': DISCORD_TEXT,   # Text der Kopfzeilen
            'selectbackground': DISCORD_GREEN,   # Auswahlhintergrund
            'selectforeground': 'white',         # Auswahltext
            'normalbackground': DISCORD_DARK,    # Hintergrund normaler Tage
            'normalforeground': DISCORD_TEXT,    # Text normaler Tage
            'weekendbackground': DISCORD_DARKER, # Hintergrund am Wochenende
            'weekendforeground': DISCORD_TEXT,   # Text am Wochenende
            'othermonthbackground': '#2C2F33',   # Hintergrund anderer Monate
            'othermonthforeground': '#72767D'    # Text anderer Monate
        }
        
        # Parameter mit dark_colors erweitern
        for key, value in dark_colors.items():
            if key not in kw:
                kw[key] = value
        
        # Eingabefeld-Farben
        if 'background' not in kw:
            kw['background'] = DISCORD_DARK
        if 'foreground' not in kw:
            kw['foreground'] = DISCORD_TEXT
        if 'insertbackground' not in kw:
            kw['insertbackground'] = DISCORD_TEXT  # Cursor-Farbe
                
        # Super-Konstruktor mit Darkmode-Parametern aufrufen
        super().__init__(master, **kw)
        
        # Dropdown-Button anpassen (dieser wird nach der Initialisierung erstellt)
        for child in self.winfo_children():
            if child.winfo_class() == 'Button':
                child.configure(
                    background=DISCORD_DARK,
                    activebackground=DISCORD_GREEN,
                    foreground=DISCORD_TEXT,
                    activeforeground='white'
                )
        
        # Kalenderfenster konfigurieren, wenn es erstellt wird (bei Drop-down)
        self.bind("<<DateEntryPopup>>", self._style_calendar_popup)
    
    def _style_calendar_popup(self, event=None):
        """Style das Kalenderfenster, wenn es geöffnet wird"""
        if hasattr(self, '_top_cal'):
            self._top_cal.configure(background=DISCORD_DARKER)

            # Untergeordnete Widgets im Kalender anpassen
            for child in self._top_cal.winfo_children():
                if child.winfo_class() == 'Label':
                    child.configure(background=DISCORD_DARKER, foreground=DISCORD_TEXT)
                elif child.winfo_class() == 'Button':
                    child.configure(
                        background=DISCORD_DARK, 
                        foreground=DISCORD_TEXT,
                        activebackground=DISCORD_GREEN, 
                        activeforeground='white'
                    )

# Verbesserte DateEntry-Klasse mit deutscher Datumsanzeige und Autovervollständigung
class AutoDateEntry(DarkDateEntry):
    """
    Erweitert die DarkDateEntry-Klasse um deutsche Datumsanzeige und
    automatische Formatierung im Format dd.mm.yy
    """

    def __init__(self, master=None, **kwargs):
        # Deutsches Datumsformat als Standard setzen
        kwargs['locale'] = 'de_DE'
        kwargs['date_pattern'] = 'dd.mm.yy'
        
        # Darkmode Stile für DateEntry
        style_options = {
            'background': DISCORD_INPUT_BG,
            'foreground': DISCORD_TEXT,
            'borderwidth': 0,
        }
        
        kwargs.update(style_options)
        
        # Super-Konstruktor aufrufen
        super().__init__(master, **kwargs)
        
        # Events binden
        self.bind("<KeyRelease>", self._format_date_entry)
        
        # Überschreibe die ursprüngliche drop_down Methode
        self._original_drop_down = self.drop_down
        self.drop_down = self._safe_drop_down
        
        self.last_value = ""

    def _safe_drop_down(self):
        """Sichere Version der drop_down Methode mit korrekter Positionierung"""
        try:
            # Prüfe ob Kalender bereits existiert und sichtbar ist
            if hasattr(self, '_top_cal') and self._top_cal and self._top_cal.winfo_exists():
                if self._top_cal.winfo_viewable():
                    # Kalender ist bereits offen, schließe ihn
                    self._top_cal.withdraw()
                    return
                else:
                    # Kalender existiert aber ist nicht sichtbar, zeige ihn
                    self._position_calendar()
                    self._top_cal.deiconify()
                    return
            
            # Rufe die ursprüngliche Methode auf
            self._original_drop_down()
            
            # Nach dem Öffnen des Kalenders, positioniere ihn korrekt
            if hasattr(self, '_top_cal') and self._top_cal:
                self._position_calendar()
                self._configure_calendar_popup()
                
        except Exception as e:
            print(f"Fehler beim Öffnen des Kalenders: {e}")
            # Versuche den Kalender zurückzusetzen
            self._reset_calendar()

    def _position_calendar(self):
        """Positioniert das Kalender-Popup korrekt relativ zum DateEntry-Widget, unterstützt mehrere Monitore"""
        try:
            if not hasattr(self, '_top_cal') or not self._top_cal:
                return
                
            # Warte bis das Widget vollständig gerendert ist
            self.update_idletasks()
            
            # Position des DateEntry-Widgets ermitteln
            x = self.winfo_rootx()
            y = self.winfo_rooty()
            
            # Höhe des DateEntry-Widgets
            entry_height = self.winfo_height()
            
            # Kalender unter dem DateEntry positionieren
            calendar_x = x
            calendar_y = y + entry_height + 2  # 2px Abstand
            
            # Monitor ermitteln, auf dem sich das DateEntry-Widget befindet
            monitor_info = self.winfo_toplevel().winfo_screen()
            
            # Hole Informationen über alle verfügbaren Monitore 
            try:
                monitors = get_monitors()
                
                # Bestimme den aktuellen Monitor
                current_monitor = None
                widget_center_x = x + self.winfo_width() / 2
                widget_center_y = y + self.winfo_height() / 2
                
                for m in monitors:
                    if (m.x <= widget_center_x <= m.x + m.width and 
                        m.y <= widget_center_y <= m.y + m.height):
                        current_monitor = m
                        break
                        
                if current_monitor:
                    screen_width = current_monitor.width
                    screen_height = current_monitor.height
                    screen_x = current_monitor.x
                    screen_y = current_monitor.y
                else:
                    # Fallback zu Hauptbildschirm
                    screen_width = self.winfo_screenwidth()
                    screen_height = self.winfo_screenheight()
                    screen_x = 0
                    screen_y = 0
            except:
                # Fallback falls screeninfo nicht verfügbar
                screen_width = self.winfo_screenwidth()
                screen_height = self.winfo_screenheight()
                screen_x = 0
                screen_y = 0
            
            # Kalender-Größe ermitteln
            try:
                self._top_cal.update_idletasks()
                calendar_width = self._top_cal.winfo_reqwidth()
                calendar_height = self._top_cal.winfo_reqheight()
            except:
                calendar_width = 250  # Standardbreite
                calendar_height = 200  # Standardhöhe
            
            # Prüfe ob Kalender rechts über den Monitor hinausragen würde
            if calendar_x + calendar_width > screen_x + screen_width:
                calendar_x = screen_x + screen_width - calendar_width - 10
            
            # Prüfe ob Kalender unten über den Monitor hinausragen würde
            if calendar_y + calendar_height > screen_y + screen_height:
                # Kalender über dem DateEntry positionieren
                calendar_y = y - calendar_height - 2
                
                # Falls auch oben nicht genug Platz ist
                if calendar_y < screen_y:
                    calendar_y = screen_y + 10  # Mindestabstand vom oberen Bildschirmrand
            
            # Stelle sicher, dass die Position innerhalb des Monitors liegt
            calendar_x = max(screen_x, min(calendar_x, screen_x + screen_width - calendar_width))
            calendar_y = max(screen_y, min(calendar_y, screen_y + screen_height - calendar_height))
            
            # Kalender positionieren
            self._top_cal.geometry(f"+{int(calendar_x)}+{int(calendar_y)}")
            
        except Exception as e:
            print(f"Fehler bei Kalender-Positionierung: {e}")

    def _configure_calendar_popup(self):
        """Konfiguriert das Kalender-Popup nach dem Öffnen"""
        try:
            if hasattr(self, '_top_cal') and self._top_cal:
                # Stelle sicher, dass das Popup fokussierbar ist
                self._top_cal.focus_set()
                
                # Bringe das Fenster in den Vordergrund
                self._top_cal.lift()
                self._top_cal.attributes('-topmost', True)
                self._top_cal.attributes('-topmost', False)
                
                # Stelle sicher, dass das Fenster nicht minimiert werden kann
                self._top_cal.resizable(False, False)
                
        except Exception as e:
            print(f"Fehler bei Kalender-Konfiguration: {e}")

    def _reset_calendar(self):
        """Setzt den Kalender zurück bei Problemen"""
        try:
            if hasattr(self, '_top_cal') and self._top_cal:
                self._top_cal.destroy()
                delattr(self, '_top_cal')
        except:
            pass

    def _format_date_entry(self, event):
        """Automatische Formatierung der Datumseingabe"""
        if event.keysym in ('BackSpace', 'Delete', 'Left', 'Right', 'Up', 'Down'):
            self.last_value = self.get()
            return

        current = self.get()

        def format_complete_date():
            filtered = ''.join(c for c in current if c.isdigit() or c == '.')
            parts = filtered.split('.')
            
            if len(parts) != 3:
                return None
                
            day, month, year = parts
            
            # Tag formatieren
            try:
                day_val = max(1, min(31, int(day))) if day else 1
                day = str(day_val).zfill(2)
                
                # Monat formatieren
                month_val = max(1, min(12, int(month))) if month else 1
                month = str(month_val).zfill(2)
                
                # Jahr intelligent formatieren
                current_year = datetime.now().year
                current_century = current_year // 100
                
                if len(year) == 1:
                    year = f"0{year}"  # Immer zweistellig machen
                elif len(year) == 2:
                    # Intelligente Jahrhundertwahl
                    year_num = int(year)
                    if year_num > (current_year % 100) + 20:  # Wenn mehr als 20 Jahre in Zukunft
                        year = f"{current_century-1}{year}"
                    else:
                        year = f"{current_century}{year}"
                elif len(year) == 3:
                    year = f"{current_century}{year[-2:]}"
                elif len(year) > 4:
                    year = year[:4]
                    
                return f"{day}.{month}.{year}"
            except ValueError:
                return None

        if event.type == '10':  # FocusOut event
            formatted = format_complete_date()
            if formatted:
                self.delete(0, tk.END)
                self.insert(0, formatted)
                self.last_value = formatted
                return

        # Normale Eingabe-Formatierung während des Tippens
        filtered = ''.join(c for c in current if c.isdigit() or c == '.')
        parts = filtered.split('.')

        if len(parts) == 1 and parts[0]:
            if len(parts[0]) == 2:
                filtered = parts[0] + '.'
        elif len(parts) == 2:
            day, month = parts
            if len(month) == 2:
                filtered = day + '.' + month + '.'

        self.delete(0, tk.END)
        self.insert(0, filtered)
        self.icursor(len(filtered))
        self.last_value = filtered
        

# Dunkle Titelleiste für Windows
def set_dark_title_bar(window):
    try:
        window.update()
        DWMWA_USE_IMMERSIVE_DARK_MODE = 20
        set_window_attribute = ctypes.windll.dwmapi.DwmSetWindowAttribute
        get_parent = ctypes.windll.user32.GetParent
        hwnd = get_parent(window.winfo_id())
        value = ctypes.c_int(2)
        set_window_attribute(hwnd, DWMWA_USE_IMMERSIVE_DARK_MODE, ctypes.byref(value), ctypes.sizeof(value))
    except Exception as e:
        print(f"Fehler beim Setzen der dunklen Titelleiste: {e}")

# Funktion für abgerundete Rechtecke
def create_rounded_rect(canvas, x1, y1, x2, y2, radius=15, **kwargs):
    points = [x1+radius, y1,
            x2-radius, y1,
            x2, y1,
            x2, y1+radius,
            x2, y2-radius,
            x2, y2,
            x2-radius, y2,
            x1+radius, y2,
            x1, y2,
            x1, y2-radius,
            x1, y1+radius,
            x1, y1]
    return canvas.create_polygon(points, **kwargs, smooth=True)


# Die Formel-Parameter-Klasse (nur mit Grundwasser-Parametern)
class FormelParameter:
    def __init__(self):
        # Bestehende Parameter beibehalten
        self.GW0 = 10.0  # Grundniveau in Meter unter GOK
        self.A = 0.5     # Saisonale Amplitude
        self.T = 365     # Periodendauer in Tagen
        self.freq = 1.0  # Sinusfrequenz pro Periodendauer
        self.Da = 45     # Anstiegsdauer in Tagen
        self.Dd = 120    # Abklingdauer in Tagen
        self.R_scale = 0.05  # Skalierung für zufällige Schwankungen
        self.phase = 60      # Phasenverschiebung in Tagen
        self.trend = 0.0     # Langzeittrend pro Jahr in Meter
        
        # Neue Parameter für die gewünschten Funktionen
        self.curve_randomness = 0.2  # Variabilität der Wellenform (0-1)
        self.secondary_freq = 3.0    # Frequenz der überlagerten kleineren Wellen


    def generiere_formel(self):
        return (f"\n\t\t               Ganglinien Layout bearbeiten\n")




# Funktion zur Berechnung der Grundwasserganglinie
def calculate_gw_series(t_array, GW0, A, T, freq, Da, Dd, R_scale, phase=60, trend=0.0, curve_randomness=0.2, secondary_freq=3.0):
    # Seed setzen für reproduzierbare Ergebnisse
    np.random.seed(42)
    
    # R_base analog zur Vorschau erstellen
    R_base = np.random.normal(0, 1, size=len(t_array))
    
    # Stellen Sie sicher, dass T nicht Null ist, um Division durch Null zu vermeiden
    if T == 0: T = 365 # Fallback-Wert
    
    # Amplitudenvariationen für jeden Wellenzyklus
    if curve_randomness > 0:
        amplitude_variation = 1.0 + curve_randomness * np.random.normal(0, 1, size=len(t_array))
        seasonal = A * np.sin(2 * np.pi * freq * (t_array - phase) / T) * amplitude_variation
    else:
        seasonal = A * np.sin(2 * np.pi * freq * (t_array - phase) / T)
    
    # Sekundäre kleinere Wellen hinzufügen
    if secondary_freq > 0:
        small_waves = A * 0.3 * np.sin(2 * np.pi * secondary_freq * freq * t_array / T)
        seasonal += small_waves
    
    # Trend-Komponente hinzufügen
    trend_component = trend * t_array / 365
    base_level = GW0 + seasonal + trend_component
    
    # Grundwasserstand initialisieren
    GW = np.zeros_like(t_array, dtype=float)
    if len(t_array) > 0:
        GW[0] = GW0 + seasonal[0]
        
        for i in range(1, len(t_array)):
            disturbance = R_scale * R_base[i]
            diff_from_GW0 = GW[i-1] - GW0
            daily_change = 0
            
            if disturbance > 0 and Da > 0:
                daily_change = (disturbance - diff_from_GW0) / Da
            elif Dd > 0:
                daily_change = -diff_from_GW0 / Dd
                
            GW[i] = GW[i-1] + daily_change
            GW[i] += seasonal[i] - seasonal[i-1]
    
    return GW


def create_csv_files(root, start_date, end_date, messstellen_ids, interval_hours, formel_params, progress, progress_info, output_directory):
    hourly_interval = timedelta(hours=interval_hours)
    delta = end_date - start_date
    total_days = delta.days + 1
    total_hours = total_days * 24
    if interval_hours == 0: interval_hours = 1
    # Correct calculation for total_measurements_per_station
    _temp_current_time = start_date
    _num_measurements = 0
    while _temp_current_time <= end_date:
        _num_measurements += 1
        _temp_current_time += hourly_interval
    total_measurements_per_station = _num_measurements
    
    total_values = total_measurements_per_station * len(messstellen_ids)

    t_days_array = np.arange(0, total_days, 1)

    try:
        grundwasser_series_daily = calculate_gw_series(
            t_days_array,
            formel_params.GW0,
            formel_params.A,
            formel_params.T,
            formel_params.freq,
            formel_params.Da,
            formel_params.Dd,
            formel_params.R_scale,
            formel_params.phase,
            formel_params.trend,
            formel_params.curve_randomness,
            formel_params.secondary_freq
        )
    except Exception as e:
        print(f"Fehler bei Grundwasserreihen-Berechnung: {e}")
        grundwasser_series_daily = np.full(total_days, formel_params.GW0)

    values_created = 0

    if not os.path.isdir(output_directory):
        try:
            os.makedirs(output_directory, exist_ok=True)
            print(f"Ausgabeverzeichnis '{output_directory}' erstellt.")
        except OSError as e:
            print(f"Warnung: Ausgabeverzeichnis '{output_directory}' konnte nicht erstellt werden: {e}. Speichere im aktuellen Verzeichnis.")
            progress_info.config(text="Warnung: Ausgabepfad ungültig/nicht erstellbar. Nutze aktuelles Verzeichnis.")
            root.update_idletasks()
            output_directory = "."

    excel_file_created = False 

    if hasattr(root, 'output_format') and root.output_format == "excel":
        all_data = {}
        excel_filename = 'wasserstände_alle_messstellen.xlsx'
        excel_filepath = os.path.join(output_directory, excel_filename)
        root.partial_files_to_delete.append(excel_filepath)

        for idx, messstelle_id in enumerate(messstellen_ids):
            if root.cancel_generation_flag.is_set():
                progress_info.config(text="Excel-Generierung wird abgebrochen...")
                root.update_idletasks()
                return

            data = []
            current_time = start_date
            while current_time <= end_date:
                if root.cancel_generation_flag.is_set():
                    progress_info.config(text="Excel-Generierung wird abgebrochen...")
                    root.update_idletasks()
                    return

                # --- START: CALCULATION FOR messwert (copied and adapted from CSV part) ---
                days_since_start = (current_time.date() - start_date.date()).days
                tage_index = days_since_start
                if 0 <= tage_index < len(grundwasser_series_daily):
                    basis_value = grundwasser_series_daily[tage_index]
                else:
                    basis_value = formel_params.GW0
                
                messstellen_offset = (idx - len(messstellen_ids) / 2) * 1.02 # Use idx from enumerate
                messwert = basis_value + messstellen_offset
                messwert += random.uniform(-formel_params.R_scale * 1.02, formel_params.R_scale * 1.02)
                # --- END: CALCULATION FOR messwert ---

                data.append([messstelle_id, current_time, float(f'{messwert:.2f}')]) # Use calculated messwert
                
                current_time += hourly_interval
                values_created += 1
                if values_created % 100 == 0: 
                    if total_values > 0 : progress['value'] = int((values_created / total_values) * 100)
                    else: progress['value'] = 0
                    progress_info.config(text=f"Werte generiert ({progress['value']}%)".replace(',', '.'))
                    root.update_idletasks()
                    if root.cancel_generation_flag.is_set(): return 
            all_data[messstelle_id] = data

        if root.cancel_generation_flag.is_set(): return

        try:
            abs_output_dir = os.path.abspath(output_directory)
            base_name_of_output_dir = os.path.basename(abs_output_dir)
            display_folder_name = base_name_of_output_dir
            if not display_folder_name: 
                if len(abs_output_dir) <= 3: display_folder_name = abs_output_dir
                else: display_folder_name = "gewählten Ordner"

            with pd.ExcelWriter(excel_filepath,
                            engine='xlsxwriter',
                            datetime_format='DD/MM/YYYY HH:MM') as writer: # Corrected datetime_format for Excel
                for sheet_idx, (messstelle_id, data_list) in enumerate(all_data.items()):
                    if root.cancel_generation_flag.is_set(): return 
                    df = pd.DataFrame(data_list, columns=['GWMST Name', 'Datum/Uhrzeit', 'Messwert'])
                    sheet_name = messstelle_id[:31] if len(messstelle_id) > 31 else messstelle_id
                    sheet_name = "".join([c for c in sheet_name if c.isalnum() or c in (' ', '_', '-')])
                    if not sheet_name or sheet_name[0] in ("'", "=") or any(char in sheet_name for char in ':\\/?*[]'):
                        sheet_name = f"Messstelle_{sheet_idx+1}" 
                    df.to_excel(writer, sheet_name=sheet_name, index=False, header=False) # Header=False to match CSV
                    workbook = writer.book
                    worksheet = writer.sheets[sheet_name]
                    # Set column widths (optional, adjust as needed)
                    worksheet.set_column('A:A', len(messstelle_id) + 2 if len(messstelle_id) > 10 else 12) # GWMST Name
                    worksheet.set_column('B:B', 20)  # Datum/Uhrzeit
                    worksheet.set_column('C:C', 12)  # Messwert

            if root.cancel_generation_flag.is_set(): return 
            
            excel_file_created = True 
            progress['value'] = 100
            progress_info.config(text=f"Excel-Datei in Ordner '{display_folder_name}' gespeichert.")
            root.update_idletasks()
        except Exception as e:
            if not root.cancel_generation_flag.is_set():
                progress_info.config(text=f"Fehler beim Excel-Export: {str(e)}")
                print(f"Excel Export Error: {e}")
        finally:
            if not excel_file_created and excel_filepath in root.partial_files_to_delete:
                pass
            elif excel_file_created and excel_filepath in root.partial_files_to_delete:
                root.partial_files_to_delete.remove(excel_filepath)


    else: # CSV-Export
        num_messstellen_processed = len(messstellen_ids) # This was an error, should be len(messstellen_ids)
        created_csv_files_successfully = []

        for idx, messstelle_id in enumerate(messstellen_ids):
            if root.cancel_generation_flag.is_set():
                progress_info.config(text="CSV-Generierung wird abgebrochen...")
                root.update_idletasks()
                return

            base_filename = f'wasserstände_{messstelle_id.replace(" ", "_")}.csv'
            filepath = os.path.join(output_directory, base_filename)
            root.partial_files_to_delete.append(filepath) 

            file_successfully_written = False
            try:
                with open(filepath, 'w', newline='', encoding='utf-8') as csvfile:
                    csvwriter = csv.writer(csvfile, delimiter=';')
                    csvwriter.writerow(['GWMST Name', 'Datum/Zeit', 'Messwert']) # Header for CSV
                    current_time = start_date
                    while current_time <= end_date:
                        if root.cancel_generation_flag.is_set():
                            csvfile.close() 
                            progress_info.config(text="CSV-Generierung wird abgebrochen...")
                            root.update_idletasks()
                            return
                        
                        formatted_date = current_time.strftime("%d.%m.%Y %H:%M:%S")
                        days_since_start = (current_time.date() - start_date.date()).days
                        tage_index = days_since_start
                        if 0 <= tage_index < len(grundwasser_series_daily):
                            basis_value = grundwasser_series_daily[tage_index]
                        else:
                            basis_value = formel_params.GW0
                        
                        messstellen_offset = (idx - len(messstellen_ids) / 2) * 1.02
                        messwert = basis_value + messstellen_offset
                        messwert += random.uniform(-formel_params.R_scale * 1.02, formel_params.R_scale * 1.02)
                        
                        csvwriter.writerow([messstelle_id, formatted_date, f'{messwert:.2f}'.replace('.', ',')])
                        
                        current_time += hourly_interval
                        values_created += 1
                        if values_created % 100 == 0:
                            if total_values > 0 : progress['value'] = int((values_created / total_values) * 100)
                            else: progress['value'] = 0
                            progress_info.config(text=f"Werte generiert ({progress['value']}%)".replace(',', '.'))
                            root.update_idletasks()
                            if root.cancel_generation_flag.is_set():
                                csvfile.close()
                                return
                file_successfully_written = True 
                created_csv_files_successfully.append(filepath)

            except Exception as e:
                if not root.cancel_generation_flag.is_set():
                    print(f"Fehler beim Schreiben der CSV {filepath}: {e}")
            finally:
                if file_successfully_written and filepath in root.partial_files_to_delete:
                    root.partial_files_to_delete.remove(filepath)

        if root.cancel_generation_flag.is_set(): return

        if not root.cancel_generation_flag.is_set() and created_csv_files_successfully:
            progress['value'] = 100
            abs_output_dir = os.path.abspath(output_directory)
            base_name_of_output_dir = os.path.basename(abs_output_dir)
            display_folder_name = base_name_of_output_dir
            if not display_folder_name: 
                if len(abs_output_dir) <= 3: display_folder_name = abs_output_dir
                else: display_folder_name = "gewählten Ordner"
            
            # Use 'len(messstellen_ids)' for this check
            if len(messstellen_ids) == 1:
                progress_info.config(text=f"CSV-Datei unter '{display_folder_name}' gespeichert.")
            else:
                progress_info.config(text=f"CSV-Dateien unter '{display_folder_name}' gespeichert.")
            root.update_idletasks()
        elif not root.cancel_generation_flag.is_set() and not created_csv_files_successfully:
            progress_info.config(text="Fehler: Keine CSV-Dateien erstellt.")


# Ladescreen-Funktion
def show_loading_screen():
    global logo_img_global
    loading_window = tk.Tk()
    loading_window.overrideredirect(True)
    window_width = 400
    window_height = 300
    screen_width = loading_window.winfo_screenwidth()
    screen_height = loading_window.winfo_screenheight()
    x_pos = int((screen_width/2) - (window_width/2))
    y_pos = int((screen_height/2) - (window_height/2))
    loading_window.geometry(f"{window_width}x{window_height}+{x_pos}+{y_pos}")
    loading_window.configure(bg=DISCORD_DARKER)

    try:
        logo_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "ribeka_Logo.png")
        original_logo = Image.open(logo_path)
        logo_width = 200
        aspect_ratio = original_logo.height / original_logo.width
        logo_height = int(logo_width * aspect_ratio)
        resized_logo = original_logo.resize((logo_width, logo_height), Image.LANCZOS)
        logo_img = ImageTk.PhotoImage(resized_logo)
        logo_img_global = logo_img
        logo_label = tk.Label(loading_window, image=logo_img, bg=DISCORD_DARKER)
        logo_label.image = logo_img
        logo_label.pack(pady=(60, 20))
    except Exception as e:
        print(f"Fehler beim Laden des Logos: {e}")
        tk.Label(loading_window, text="WaterGen", font=("Arial", 24, "bold"),
                fg=DISCORD_TEXT, bg=DISCORD_DARKER).pack(pady=(60, 20))

    loading_label = tk.Label(loading_window, text="Anwendung wird geladen...",
    fg=DISCORD_TEXT, bg=DISCORD_DARKER, font=("Arial", 12))
    loading_label.pack(pady=10)

    progress = ttk.Progressbar(loading_window, orient="horizontal", length=300, mode="indeterminate")
    style = ttk.Style(loading_window)
    style.configure("TProgressbar", troughcolor=DISCORD_BG, background=DISCORD_GREEN)
    progress.pack(pady=20)
    progress.start(15)

    def close_loading():
        progress.stop()
        loading_window.destroy()

    loading_window.after(2000, close_loading)
    loading_window.mainloop()

def resource_path(relative_path):
    """Ermittelt den korrekten Pfad zu Ressourcen für PyInstaller und normale Python-Ausführung"""
    try:
        base_path = sys._MEIPASS
    except Exception:
        base_path = os.path.abspath(os.path.dirname(__file__))
    return os.path.join(base_path, relative_path)


def create_csv_files_thread_wrapper(root, start_date, end_date, messstellen_ids, interval_hours,
                                    formel_params, progress, progress_info, output_directory,
                                    button_canvas, button_text_item, button_bg_item): # Button Elemente empfangen
    try:
        create_csv_files(root, start_date, end_date, messstellen_ids, interval_hours,
                         formel_params, progress, progress_info, output_directory)
        if root.cancel_generation_flag.is_set():
             progress_info.config(text="Generierung abgebrochen.")
             # Cleanup-Logik hier, da der Thread hier die Kontrolle hat
             for f_path in root.partial_files_to_delete:
                 try:
                     if os.path.exists(f_path):
                         os.remove(f_path)
                         print(f"Gelöscht (Abbruch): {f_path}")
                 except Exception as e_del:
                     print(f"Fehler beim Löschen (Abbruch) von {f_path}: {e_del}")
             root.partial_files_to_delete = [] # Liste leeren
        # elif: Kein Fehler und nicht abgebrochen -> Erfolgsmeldung wird von create_csv_files gesetzt.
            
    except Exception as e:
        if not root.cancel_generation_flag.is_set(): # Nur Fehler anzeigen, wenn nicht aktiv abgebrochen
            progress_info.config(text=f"Fehler im Thread: {str(e)}")
            print(f"Thread Error: {e}")
        # Cleanup auch bei Fehler (außer es wurde aktiv abgebrochen und dort schon bereinigt)
        if not root.cancel_generation_flag.is_set():
            for f_path in root.partial_files_to_delete:
                try:
                    if os.path.exists(f_path):
                        os.remove(f_path)
                        print(f"Gelöscht (Fehler): {f_path}")
                except Exception as e_del:
                    print(f"Fehler beim Löschen (Fehler) von {f_path}: {e_del}")
            root.partial_files_to_delete = []

    finally:
        # Button immer zurücksetzen, egal ob Erfolg, Fehler oder Abbruch
        # Dies muss über root.after geschehen, da es aus einem anderen Thread kommt
        def reset_button_ui():
            button_canvas.itemconfig(button_text_item, text="Start")
            button_canvas.itemconfig(button_bg_item, fill=BUTTON_COLOR) # BUTTON_COLOR verwenden
            button_canvas.unbind("<Button-1>") # Eventuell gebundenes cancel_process entfernen
            # WICHTIG: Hier muss start_process korrekt referenziert werden.
            # Da start_process innerhalb von create_gui definiert ist, muss es entweder
            # an diese Funktion übergeben werden oder wir müssen die Lambda-Funktion anpassen,
            # um die in create_gui definierte start_process zu verwenden.
            # Die aktuelle Übergabe der Button-Elemente ist gut.
            # Wir gehen davon aus, dass start_process im Scope von create_gui bekannt ist,
            # und das lambda wird zum Zeitpunkt der Ausführung von root.after im korrekten Kontext sein.
            button_canvas.bind("<Button-1>", lambda event: root.start_process_method(event)) # Verwende eine Methode von root

            if not root.cancel_generation_flag.is_set() and progress['value'] != 100: 
                if "Fehler" not in progress_info.cget("text") and "Abbruch" not in progress_info.cget("text") and "Warnung" not in progress_info.cget("text"):
                     progress_info.config(text="Bereit.") 
            elif progress['value'] == 100 and "Fehler" not in progress_info.cget("text") and not root.cancel_generation_flag.is_set():
                pass # Erfolgsmeldung bleibt
            elif root.cancel_generation_flag.is_set():
                progress_info.config(text="Abgebrochen. Dateien gelöscht.")
                progress['value'] = 0


        root.after(0, reset_button_ui)
        root.generation_thread = None 
        root.cancel_generation_flag.clear()
        
        
# GUI erstellen
def create_gui():
    show_loading_screen()
    root = tk.Tk()
    root.title("WaterGen")
    root.generation_thread = None # Zum Speichern des laufenden Threads
    root.cancel_generation_flag = threading.Event() # Für sicheres Abbrechen
    root.partial_files_to_delete = [] # Liste der Dateien, die bei Abbruch gelöscht werden sollen
    
    logo_path_icon = resource_path("icon.ico") # Korrigierter Variablenname
    try:
        root.iconbitmap(logo_path_icon) # Korrigierten Variablennamen verwenden
    except tk.TclError as e:
        print(f"Fehler beim Setzen des Icons (möglicherweise nicht im richtigen Format oder Pfad): {e}")
        # Versuche SVG als Fallback, falls tk.Image vorhanden ist (Python 3.9+ mit Tk 8.6+)
        try:
            svg_icon_path = resource_path("icon.svg") # Annahme: Du hast auch ein SVG Icon
            img = tksvg.SvgImage(file=svg_icon_path)
            root.iconphoto(True, img)
            print("SVG Icon als Fallback verwendet.")
        except Exception as svg_e:
            print(f"Konnte auch SVG Icon nicht laden: {svg_e}")
    except Exception as e: # Fange allgemeinere Fehler ab
        print(f"Allgemeiner Fehler beim Setzen des Icons: {e}")


    window_width = 620
    # window_height = 700 # Alte Höhe
    window_height = 780 # NEU: Höhe angepasst für neuen Bereich
    screen_width = root.winfo_screenwidth()
    screen_height = root.winfo_screenheight()
    x_pos = int((screen_width/2) - (window_width/2))
    y_pos = int((screen_height/2) - (window_height/2))
    root.geometry(f"{window_width}x{window_height}+{x_pos}+{y_pos}")
    set_dark_title_bar(root)
    root.configure(bg=DISCORD_BG)

    try:
        # Für Windows: Taskleisten-Icon konfigurieren
        try:
            from ctypes import windll
            app_id = "ribeka.watergen.app.1.0"
            windll.shell32.SetCurrentProcessExplicitAppUserModelID(app_id)
        except ImportError:
            pass
    except Exception as e:
        print(f"Fehler beim Setzen der App-ID: {e}")

    formel_params = FormelParameter()

    # NEU: StringVar für den Ausgabepfad initialisieren
    root.output_directory_path = tk.StringVar()
    root.output_directory_path.set(os.getcwd()) # Standard: Aktuelles Arbeitsverzeichnis


    # root.minsize(620, 720) # Alte Mindestgröße
    root.minsize(620, 780) # NEU: Mindesthöhe angepasst
    root.grid_rowconfigure(0, weight=1)
    root.grid_columnconfigure(0, weight=1)

    container_frame = tk.Frame(root, bg=DISCORD_BG)
    container_frame.grid(row=0, column=0, sticky="nsew", padx=10, pady=10)
    container_frame.grid_rowconfigure(0, weight=1)
    container_frame.grid_columnconfigure(0, weight=1)

    content_frame = tk.Frame(container_frame, bg=DISCORD_BG)

    def center_content(event=None):
        width = container_frame.winfo_width()
        if width > 600:
            padding = (width - 600) // 2
            content_frame.grid_configure(padx=padding)
        else:
            content_frame.grid_configure(padx=0)

    content_frame.grid(row=0, column=0)
    container_frame.bind("<Configure>", center_content)

    main_frame = tk.Frame(content_frame, bg=DISCORD_BG, padx=15, pady=15)
    main_frame.pack(fill=tk.BOTH, expand=True)

    style = ttk.Style(root)
    style.configure("TProgressbar",
                troughcolor=DISCORD_DARKER,
                background=BUTTON_COLOR,
                borderwidth=0)

    label_style = {"bg": DISCORD_DARK, "fg": DISCORD_TEXT, "font": ('Arial', 11)}
    entry_style = {"bg": DISCORD_INPUT_BG, "fg": DISCORD_TEXT, "insertbackground": DISCORD_TEXT,
                "font": ('Arial', 11), "bd": 0, "relief": "flat"}


    header_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    header_frame.pack(fill=tk.X, pady=(0, 20))
    header_canvas = tk.Canvas(header_frame, bg=DISCORD_BG, height=100,
                            highlightthickness=0, width=580)
    header_canvas.pack(fill=tk.X)
    create_rounded_rect(header_canvas, 0, 0, 580, 100, radius=15,
                        fill=DISCORD_DARK, outline="")
    
    # WaterGen Logo (statisch und animiert)
    logo_path_WaterGen_png = resource_path("WaterGen_Logo.png")
    logo_path_WaterGen_gif = resource_path("WaterGen_Animation.gif") # Pfad zum GIF
    watergen_logo_width = 150
    watergen_logo_height = 0 
    root.static_watergen_logo_tk = None
    root.watergen_gif_frames = []
    root.watergen_gif_frame_duration = 100 
    root.is_watergen_animating = False
    try:
        original_png = Image.open(logo_path_WaterGen_png)
        aspect_ratio = original_png.height / original_png.width
        watergen_logo_height = int(watergen_logo_width * aspect_ratio)
        resized_png = original_png.resize((watergen_logo_width, watergen_logo_height), Image.LANCZOS)
        root.static_watergen_logo_tk = ImageTk.PhotoImage(resized_png)
        try:
            gif_image = Image.open(logo_path_WaterGen_gif)
            root.watergen_gif_frame_duration = gif_image.info.get('duration', 100)
            for frame in ImageSequence.Iterator(gif_image):
                frame_rgba = frame.convert("RGBA") 
                resized_frame_img = frame_rgba.resize((watergen_logo_width, watergen_logo_height), Image.LANCZOS)
                root.watergen_gif_frames.append(ImageTk.PhotoImage(resized_frame_img))
        except Exception as e:
            print(f"Fehler beim Laden des WaterGen GIF: {e}. Animation nicht verfügbar.")
            root.watergen_gif_frames = []
    except Exception as e:
        print(f"Fehler beim Laden des statischen WaterGen-Logos: {e}")
        fallback_label = tk.Label(header_canvas, text="WaterGen",
                                bg=DISCORD_DARK, fg=DISCORD_TEXT,
                                font=('Arial', 24, 'bold'))
        header_canvas.create_window(120, 50, window=fallback_label)
        root.watergen_logo_widget = fallback_label
    if root.static_watergen_logo_tk:
        watergen_logo_label = tk.Label(header_canvas, image=root.static_watergen_logo_tk, bg=DISCORD_DARK, cursor="hand2")
        watergen_logo_label.image = root.static_watergen_logo_tk 
        root.watergen_logo_widget = watergen_logo_label 
        header_canvas.create_window(120, 50, window=watergen_logo_label)
        def _animate_watergen_gif(frame_index):
            if not root.watergen_gif_frames: 
                root.is_watergen_animating = False
                if root.static_watergen_logo_tk:
                    root.watergen_logo_widget.config(image=root.static_watergen_logo_tk)
                    root.watergen_logo_widget.image = root.static_watergen_logo_tk
                return
            if frame_index < len(root.watergen_gif_frames):
                frame_image = root.watergen_gif_frames[frame_index]
                root.watergen_logo_widget.config(image=frame_image)
                root.watergen_logo_widget.image = frame_image 
                root.after(root.watergen_gif_frame_duration, _animate_watergen_gif, frame_index + 1)
            else:
                root.watergen_logo_widget.config(image=root.static_watergen_logo_tk)
                root.watergen_logo_widget.image = root.static_watergen_logo_tk 
                root.is_watergen_animating = False
        def play_watergen_gif_once(event=None):
            if root.is_watergen_animating or not root.watergen_gif_frames:
                return 
            if not hasattr(root, 'watergen_logo_widget') or not root.static_watergen_logo_tk:
                return 
            root.is_watergen_animating = True
            _animate_watergen_gif(0)
        if hasattr(root, 'watergen_logo_widget'):
            root.watergen_logo_widget.bind("<Button-1>", play_watergen_gif_once)
    
    logo_path_ribeka_png = resource_path("ribeka_Logo.png")
    logo_path_ribeka_gif = resource_path("ribeka_Animation.gif")
    ribeka_logo_width = 200
    ribeka_logo_height = 0 
    root.static_ribeka_logo_tk = None 
    root.ribeka_gif_frames = []
    root.ribeka_gif_frame_duration = 100
    root.is_ribeka_animating = False
    try:
        original_ribeka = Image.open(logo_path_ribeka_png)
        aspect_ratio = original_ribeka.height / original_ribeka.width
        ribeka_logo_height = int(ribeka_logo_width * aspect_ratio)
        resized_ribeka = original_ribeka.resize((ribeka_logo_width, ribeka_logo_height), Image.LANCZOS)
        root.static_ribeka_logo_tk = ImageTk.PhotoImage(resized_ribeka)
        try:
            gif_image = Image.open(logo_path_ribeka_gif)
            root.ribeka_gif_frame_duration = gif_image.info.get('duration', 100)
            for frame in ImageSequence.Iterator(gif_image):
                frame_rgba = frame.convert("RGBA") 
                resized_frame_img = frame_rgba.resize((ribeka_logo_width, ribeka_logo_height), Image.LANCZOS)
                root.ribeka_gif_frames.append(ImageTk.PhotoImage(resized_frame_img))
        except Exception as e:
            print(f"Fehler beim Laden des Ribeka GIF: {e}. Animation nicht verfügbar.")
            root.ribeka_gif_frames = []
    except Exception as e:
        print(f"Fehler beim Laden des statischen Ribeka-Logos: {e}")
        fallback_label = tk.Label(header_canvas, text="ribeka",
                                bg=DISCORD_DARK, fg=DISCORD_TEXT,
                                font=('Arial', 24, 'bold'))
        header_canvas.create_window(420, 50, window=fallback_label)
        root.ribeka_logo_widget = fallback_label
    if root.static_ribeka_logo_tk:
        ribeka_logo_label = tk.Label(header_canvas, image=root.static_ribeka_logo_tk, 
                                   bg=DISCORD_DARK, cursor="hand2")
        ribeka_logo_label.image = root.static_ribeka_logo_tk
        root.ribeka_logo_widget = ribeka_logo_label
        header_canvas.create_window(420, 50, window=ribeka_logo_label)
        def _animate_ribeka_gif(frame_index):
            if not root.ribeka_gif_frames:
                root.is_ribeka_animating = False
                if root.static_ribeka_logo_tk:
                    root.ribeka_logo_widget.config(image=root.static_ribeka_logo_tk)
                    root.ribeka_logo_widget.image = root.static_ribeka_logo_tk
                return
            if frame_index < len(root.ribeka_gif_frames):
                frame_image = root.ribeka_gif_frames[frame_index]
                root.ribeka_logo_widget.config(image=frame_image)
                root.ribeka_logo_widget.image = frame_image
                root.after(root.ribeka_gif_frame_duration, _animate_ribeka_gif, frame_index + 1)
            else:
                root.ribeka_logo_widget.config(image=root.static_ribeka_logo_tk)
                root.ribeka_logo_widget.image = root.static_ribeka_logo_tk
                root.is_ribeka_animating = False
        def play_ribeka_gif_once(event=None):
            if root.is_ribeka_animating or not root.ribeka_gif_frames:
                return
            if not hasattr(root, 'ribeka_logo_widget') or not root.static_ribeka_logo_tk:
                return
            root.is_ribeka_animating = True
            _animate_ribeka_gif(0)
        if hasattr(root, 'ribeka_logo_widget'):
            root.ribeka_logo_widget.bind("<Button-1>", play_ribeka_gif_once)


    # 1. Zeitspanne und Intervall
    zeitspan_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    zeitspan_frame.pack(fill=tk.X, pady=(0, 10))
    zeitspan_canvas = tk.Canvas(zeitspan_frame, bg=DISCORD_BG, height=100, highlightthickness=0, width=580)
    zeitspan_canvas.pack(fill=tk.X)
    create_rounded_rect(zeitspan_canvas, 0, 0, 580, 100, radius=15, fill=DISCORD_DARK, outline="")
    zeitspanne_label = tk.Label(zeitspan_canvas, text="Zeitspanne", **label_style)
    zeitspan_canvas.create_window(20, 30, window=zeitspanne_label, anchor="w")
    style = ttk.Style(root)
    style.theme_use('clam')
    style.configure('Custom.DateEntry',
                    fieldbackground=DISCORD_INPUT_BG,
                    foreground=DISCORD_TEXT,
                    borderwidth=0,
                    relief="flat")
    startdatum = AutoDateEntry(zeitspan_canvas, width=12, style='Custom.DateEntry')
    zeitspan_canvas.create_window(170, 30, window=startdatum)
    zeitspanne_anzeige = tk.Label(zeitspan_canvas, text="0 Jahre, 0 Monate, 0 Tage",
                                **label_style, width=25)
    zeitspan_canvas.create_window(340, 30, window=zeitspanne_anzeige)
    enddatum = AutoDateEntry(zeitspan_canvas, width=12, style='Custom.DateEntry')
    zeitspan_canvas.create_window(500, 30, window=enddatum)
    intervall_label = tk.Label(zeitspan_canvas, text="Intervall [Std.]", **label_style)
    zeitspan_canvas.create_window(20, 70, window=intervall_label, anchor="w")
    intervall_entry = tk.Entry(zeitspan_canvas, width=11, **entry_style)
    intervall_entry.insert(0, "1")
    zeitspan_canvas.create_window(170, 70, window=intervall_entry)
    
    switch_label = tk.Label(zeitspan_canvas, text="Ausgabeformat", **label_style)
    zeitspan_canvas.create_window(255, 70, window=switch_label, anchor="w")
    format_switch_canvas = tk.Canvas(zeitspan_canvas, width=100, height=30,
                                bg=DISCORD_DARK, highlightthickness=0)
    zeitspan_canvas.create_window(497, 70, window=format_switch_canvas)
    root.output_format = "csv"
    switch_bg = create_rounded_rect(format_switch_canvas, 0, 0, 100, 30,
                            radius=15, fill="#4b5ae4")
    button_size_toggle = 20 # Variable umbenannt, um Konflikt zu vermeiden
    switch_button = format_switch_canvas.create_oval(5, 5, 5 + button_size_toggle, 5 + button_size_toggle,
                                            fill="white", outline="")
    switch_text = format_switch_canvas.create_text(50, 15, text="CSV",
                                            fill="white", font=("Arial", 10, "bold"))
    def toggle_format(event=None):
        if root.output_format == "csv":
            root.output_format = "excel"
            format_switch_canvas.itemconfig(switch_bg, fill="#b356ff")  
            format_switch_canvas.coords(switch_button, 75, 5, 75 + button_size_toggle, 5 + button_size_toggle)
            format_switch_canvas.itemconfig(switch_text, text="Excel")
        else:
            root.output_format = "csv"
            format_switch_canvas.itemconfig(switch_bg, fill="#4b5ae4")
            format_switch_canvas.coords(switch_button, 5, 5, 5 + button_size_toggle, 5 + button_size_toggle)
            format_switch_canvas.itemconfig(switch_text, text="CSV")
    format_switch_canvas.bind("<Button-1>", toggle_format)
    
    def parse_flexible_date(date_string):
        try:
            return datetime.strptime(date_string, '%d.%m.%y')
        except ValueError:
            try:
                return datetime.strptime(date_string, '%d.%m.%Y')
            except ValueError:
                raise ValueError("Ungültiges Datumsformat. Bitte TT.MM.JJ oder TT.MM.JJJJ verwenden.")

    def berechne_zeitspanne():
        try:
            start = parse_flexible_date(startdatum.get())
            end = parse_flexible_date(enddatum.get())
            delta = end - start
            jahre = delta.days // 365
            monate = (delta.days % 365) // 30
            tage = (delta.days % 365) % 30
            zeitspanne_anzeige.config(text=f"{jahre} Jahre, {monate} Monate, {tage} Tage")
            berechne_werte_anzahl() # Aufruf hier, um Werteinfo zu aktualisieren
        except:
            zeitspanne_anzeige.config(text="Ungültiges Datum")
            werte_info.config(text="Zu generierende Werte: -") # Werteinfo zurücksetzen

    def berechne_werte_anzahl():
        try:
            start_str = startdatum.get()
            end_str = enddatum.get()
            
            # parse_flexible_date gibt datetime.datetime Objekte zurück (Zeit ist 00:00:00)
            start = parse_flexible_date(start_str) 
            end = parse_flexible_date(end_str)     
            
            if start > end: # Sicherstellen, dass Start nicht nach Ende liegt
                werte_info.config(text="Fehler: Start > Ende")
                return 0

            # delta = end - start # Nicht direkt für die Endberechnung der Werteanzahl verwendet

            stunden_intervall_str = intervall_entry.get().replace(',', '.')
            if not stunden_intervall_str:
                # Diese Ausnahme wird vom nachfolgenden except-Block gefangen
                raise ValueError("Intervall darf nicht leer sein.")
            try:
                stunden_intervall = float(stunden_intervall_str)
            except ValueError:
                # Diese Ausnahme wird vom nachfolgenden except-Block gefangen
                raise ValueError("Intervall muss eine Zahl sein.")
            
            if stunden_intervall <= 0:
                werte_info.config(text="Fehler: Intervall > 0")
                return 0
            
            num_messstellen_text = messstellen_text.get("1.0", tk.END)
            num_messstellen = len([m.strip() for m in num_messstellen_text.strip().split(';') if m.strip()])
            if num_messstellen == 0: num_messstellen = 1 # Mindestens für eine Messstelle berechnen für die Anzeige
            
            messwerte_pro_messstelle = 0
            # _temp_start_date ist ein datetime.datetime Objekt (Mitternacht des Starttages)
            _temp_start_date = datetime.combine(start.date(), datetime.min.time()) 
            _hourly_interval_sim = timedelta(hours=stunden_intervall)
            
            _sim_count = 0
            _ct_sim = _temp_start_date # _ct_sim ist ein datetime.datetime
            
            # Die Schleife in create_csv_files ist `while current_time <= end_date`
            # wobei current_time und end_date datetime.datetime Objekte sind.
            # 'start' und 'end' sind hier ebenfalls datetime.datetime Objekte.
            # Wir müssen datetime mit datetime vergleichen.
            while _ct_sim <= end: # KORRIGIERTE ZEILE
                _sim_count +=1
                _ct_sim += _hourly_interval_sim
            messwerte_pro_messstelle = _sim_count
            
            gesamt_werte = messwerte_pro_messstelle * num_messstellen
            werte_info.config(text=f"Zu generierende Werte gesamt: {gesamt_werte:,}".replace(',', '.'))
            return gesamt_werte
        except Exception as e:
            print(f"Fehler bei Werteanzahl-Berechnung: {e}") 
            werte_info.config(text="Zu generierende Werte: Berechnung nicht möglich")
            return 0


    def berechne_alles(event=None):
        berechne_zeitspanne() # Dies ruft auch berechne_werte_anzahl auf

    zeitspan_frame.bind("<Motion>", berechne_alles)
    # Timer für sekündliche Aktualisierung entfernt, da <Motion> und FocusOut ausreichen sollten
    # def update_berechnungen():
    #     berechne_alles()
    #     root.after(1000, update_berechnungen)
    # root.after(1000, update_berechnungen)

    startdatum.bind("<FocusOut>", lambda e: berechne_alles())
    enddatum.bind("<FocusOut>", lambda e: berechne_alles())
    intervall_entry.bind("<FocusOut>", lambda e: berechne_alles())
    startdatum.bind("<FocusIn>", lambda e: berechne_alles()) # Optional, kann zu häufigem Neuzeichnen führen
    enddatum.bind("<FocusIn>", lambda e: berechne_alles())   # Optional
    intervall_entry.bind("<FocusIn>", lambda e: berechne_alles()) # Optional
    
    # Binden an Datumsänderung über Kalender
    startdatum.bind("<<DateEntrySelected>>", lambda e: berechne_alles())
    enddatum.bind("<<DateEntrySelected>>", lambda e: berechne_alles())


    # 2. Messstellen
    messstellen_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    messstellen_frame.pack(fill=tk.X, pady=(0, 10))
    messstellen_canvas = tk.Canvas(messstellen_frame, bg=DISCORD_BG, height=120,
                                 highlightthickness=0, width=580)
    messstellen_canvas.pack(fill=tk.X)
    create_rounded_rect(messstellen_canvas, 0, 0, 580, 120, radius=15,
                       fill=DISCORD_DARK, outline="")
    messstellen_label = tk.Label(messstellen_canvas, text="Messstellen:",
                               **label_style)
    messstellen_canvas.create_window(20, 30, window=messstellen_label, anchor="w")
    messstellen_text = tk.Text(messstellen_canvas, height=3, width=45, **entry_style)
    messstellen_canvas.create_window(290, 50, window=messstellen_text)
    help_label = tk.Label(messstellen_canvas, text="Namen mit einem Semikolon trennen",
                        fg=DISCORD_GRAY_TEXT, bg=DISCORD_DARK, font=('Arial', 9))
    messstellen_canvas.create_window(290, 100, window=help_label)
    messstellen_text.bind("<FocusOut>", lambda e: berechne_werte_anzahl())
    messstellen_text.bind("<KeyRelease>", lambda e: berechne_werte_anzahl()) # Auch bei Eingabe aktualisieren

    def validiere_messstellen(messstellen_text_str): # Parameter umbenannt
        if not messstellen_text_str.strip(): # .strip() auf String anwenden
            return False, "Keine Messstellen angegeben"
        messstellen = [m.strip() for m in messstellen_text_str.split(';') if m.strip()]
        if not messstellen:
            return False, "Keine gültigen Messstellen angegeben"
        duplicates = set()
        seen = set()
        for m in messstellen:
            if m in seen:
                duplicates.add(m)
            else:
                seen.add(m)
        if duplicates:
            return False, f"Doppelte Messstellennamen gefunden: {', '.join(duplicates)}"
        return True, messstellen

    # 3. Formel (anzeige der verwendeten Parameter)
    formel_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    formel_frame.pack(fill=tk.X, pady=(0, 10))
    formel_canvas = tk.Canvas(formel_frame, bg=DISCORD_BG, height=60,
                            highlightthickness=0, width=580)
    formel_canvas.pack(fill=tk.X)
    create_rounded_rect(formel_canvas, 0, 0, 580, 60, radius=15,
                       fill=DISCORD_DARK, outline="")
    formel_label = tk.Label(formel_canvas, text=formel_params.generiere_formel(),
                          **label_style, width=65, anchor="w")
    formel_canvas.create_window(270, 30, window=formel_label)

    def open_formel_submenu():
        if hasattr(root, 'submenu_open') and root.submenu_open:
            return
        root.submenu_open = True
        submenu = tk.Toplevel(root)
        submenu.title("Formel-Einstellungen")
        submenu_width = 1250
        submenu_height = 600
        sub_x_pos = int((screen_width/2) - (submenu_width/2))
        sub_y_pos = int((screen_height/2) - (submenu_height/2))
        submenu.geometry(f"{submenu_width}x{submenu_height}+{sub_x_pos}+{sub_y_pos}")
        submenu.minsize(submenu_width, submenu_height)
        submenu.configure(bg=DISCORD_BG)
        set_dark_title_bar(submenu)
        main_submenu_frame = tk.Frame(submenu, bg=DISCORD_BG, padx=20, pady=20)
        main_submenu_frame.pack(fill=tk.BOTH, expand=True)
        parameter_frame = tk.Frame(main_submenu_frame, bg=DISCORD_BG)
        parameter_frame.grid(row=0, column=0, sticky="nw", padx=(0, 20))
        graph_frame = tk.Frame(main_submenu_frame, bg=DISCORD_BG)
        graph_frame.grid(row=0, column=1, sticky="ne")
        title_label = tk.Label(parameter_frame, text="Grundwasserganglinie anpassen",
                            bg=DISCORD_BG, fg=DISCORD_TEXT, font=('Arial', 16, 'bold'))
        title_label.grid(row=0, column=0, columnspan=3, pady=(0, 20), sticky="w")
        np.random.seed(42)
        t_preview = np.arange(0, 365, 1)
        R_base_preview = np.random.normal(0, 1, size=len(t_preview))
        def calculate_gw_preview(t_array, GW0, A, T, freq, Da, Dd, R_scale, curve_randomness=0.2, secondary_freq=3.0):
             if T == 0: T = 365
             if curve_randomness > 0:
                 amplitude_variation = 1.0 + curve_randomness * np.random.normal(0, 1, size=len(t_array))
                 seasonal = A * np.sin(2 * np.pi * freq * t_array / T) * amplitude_variation
             else:
                 seasonal = A * np.sin(2 * np.pi * freq * t_array / T)
             if secondary_freq > 0:
                 small_waves = A * 0.3 * np.sin(2 * np.pi * secondary_freq * freq * t_array / T)
                 seasonal += small_waves
             GW = np.zeros_like(t_array, dtype=float)
             if len(t_array) > 0:
                 GW[0] = GW0 + seasonal[0]
             for i in range(1, len(t_array)):
                 disturbance = R_scale * R_base_preview[i]
                 diff_from_GW0 = GW[i-1] - GW0
                 daily_change = 0
                 if disturbance > 0 and Da > 0:
                     daily_change = (disturbance - diff_from_GW0) / Da
                 elif Dd > 0:
                     daily_change = -diff_from_GW0 / Dd
                 GW[i] = GW[i-1] + daily_change
                 GW[i] += seasonal[i] - seasonal[i-1]
             return GW
        fig = Figure(figsize=(7, 5), dpi=100, facecolor=DISCORD_DARKER)
        ax = fig.add_subplot(111)
        ax.set_facecolor(DISCORD_DARKER)
        ax.spines['bottom'].set_color(DISCORD_TEXT)
        ax.spines['top'].set_color(DISCORD_TEXT)
        ax.spines['left'].set_color(DISCORD_TEXT)
        ax.spines['right'].set_color(DISCORD_TEXT)
        ax.tick_params(axis='both', colors=DISCORD_TEXT)
        ax.yaxis.label.set_color(DISCORD_TEXT)
        ax.xaxis.label.set_color(DISCORD_TEXT)
        ax.title.set_color(DISCORD_TEXT)
        ax.set_xlabel('Zeit (Tage)', color=DISCORD_TEXT)
        ax.set_ylabel('Grundwasserstand [m]', color=DISCORD_TEXT)
        ax.set_title('Grundwasserganglinie (Vorschau)', color=DISCORD_TEXT)
        canvas_plot = FigureCanvasTkAgg(fig, master=graph_frame) # Variable umbenannt
        canvas_plot.draw()
        canvas_plot.get_tk_widget().pack()
        def update_graph():
            ax.clear()
            ax.set_facecolor(DISCORD_DARKER)
            # ... (Rest der Achsenkonfiguration wie oben) ...
            ax.spines['bottom'].set_color(DISCORD_TEXT)
            ax.spines['top'].set_color(DISCORD_TEXT)
            ax.spines['left'].set_color(DISCORD_TEXT)
            ax.spines['right'].set_color(DISCORD_TEXT)
            ax.tick_params(axis='both', colors=DISCORD_TEXT)
            ax.yaxis.label.set_color(DISCORD_TEXT)
            ax.xaxis.label.set_color(DISCORD_TEXT)
            ax.title.set_color(DISCORD_TEXT)
            ax.set_xlabel('Zeit (Tage)', color=DISCORD_TEXT)
            ax.set_ylabel('Grundwasserstand [m]', color=DISCORD_TEXT)
            ax.set_title('Grundwasserganglinie (Vorschau)', color=DISCORD_TEXT)

            GW0 = var_GW0.get()
            A = var_A.get()
            T = var_T.get()
            freq = var_freq.get()
            Da = var_Da.get()
            Dd = var_Dd.get()
            R_scale_val = var_R.get() # Variable umbenannt, da R_scale eine Funktion ist
            curve_randomness = var_randomness.get()
            secondary_freq = var_secondary.get()
            GW_preview = calculate_gw_preview(t_preview, GW0, A, T, freq, Da, Dd, R_scale_val, 
                                    curve_randomness, secondary_freq)
            ax.plot(t_preview, GW_preview, color=DISCORD_GREEN, linewidth=1.5)
            ax.grid(True, color=DISCORD_GRAY_TEXT, alpha=0.3, linestyle='--')
            GW_min, GW_max = GW_preview.min(), GW_preview.max()
            margin = (GW_max - GW_min) * 0.1 
            if margin == 0 and GW_min == GW_max:
                 margin = 0.5 
            elif margin == 0:
                 margin = 0.1 * abs(GW_min) 
            ax.set_ylim(GW_min - margin, GW_max + margin)
            canvas_plot.draw()
        style_submenu = ttk.Style(submenu) # Style für Submenu
        style_submenu.configure("TScale", background=DISCORD_BG, troughcolor=DISCORD_DARK)
        def create_parameter_slider(parent, row, text, from_, to_, default, precision=1):
            frame = tk.Frame(parent, bg=DISCORD_BG)
            frame.grid(row=row, column=0, columnspan=3, pady=5, sticky="ew")
            label = tk.Label(frame, text=text, bg=DISCORD_BG, fg=DISCORD_TEXT, width=30, anchor="w")
            label.grid(row=0, column=0, padx=(0, 10))
            value_var = tk.DoubleVar(value=default)
            last_value = [default] 
            def on_slider_change(event):
                current_value = round(value_var.get(), precision)
                if current_value != last_value[0]:
                    last_value[0] = current_value
                    value_label.config(text=f"{current_value:.{precision}f}")
                    update_graph()
            slider = ttk.Scale(frame, from_=from_, to=to_, variable=value_var,
                            command=on_slider_change, length=200, style="TScale") # style="TScale" hier anwenden
            slider.grid(row=0, column=1)
            value_label = tk.Label(frame, text=f"{default:.{precision}f}",
                                bg=DISCORD_BG, fg=DISCORD_TEXT, width=5)
            value_label.grid(row=0, column=2, padx=(10, 0))
            return slider, value_var
        s_GW0, var_GW0 = create_parameter_slider(parameter_frame, 1, "Grundniveau [m]:", 10, 14, formel_params.GW0, precision=2)
        s_A, var_A = create_parameter_slider(parameter_frame, 2, "Saisonale Amplitude [m]:", 0.1, 20.0, formel_params.A, precision=2)
        s_T, var_T = create_parameter_slider(parameter_frame, 3, "Periodendauer (Tage):", 100, 500, formel_params.T, precision=0)
        s_freq, var_freq = create_parameter_slider(parameter_frame, 4, "Sinusfrequenz/Periode:", 0.5, 3.0, formel_params.freq, precision=1)
        s_Da, var_Da = create_parameter_slider(parameter_frame, 5, "Anstiegsdauer (Tage):", 1, 200, formel_params.Da, precision=0)
        s_Dd, var_Dd = create_parameter_slider(parameter_frame, 6, "Abklingdauer (Tage):", 1, 200, formel_params.Dd, precision=0)
        s_R, var_R = create_parameter_slider(parameter_frame, 7, "Zufällige Schwankungen (Skala):", 0.0, 1.0, formel_params.R_scale, precision=2)
        s_randomness, var_randomness = create_parameter_slider(parameter_frame, 8, "Wellenform-Variabilität:", 0.0, 1.0, formel_params.curve_randomness, precision=2)
        s_secondary, var_secondary = create_parameter_slider(parameter_frame, 9, "Häufigkeit kleiner Wellen:", 0.0, 10.0, formel_params.secondary_freq, precision=1)
        btn_frame = tk.Frame(parameter_frame, bg=DISCORD_BG)
        btn_frame.grid(row=10, column=0, columnspan=3, pady=20, sticky="ew")
        cancel_btn = tk.Button(btn_frame, text="Abbrechen", bg=DISCORD_DARK, fg=DISCORD_TEXT,
                            activebackground=DISCORD_DARKER, activeforeground=DISCORD_TEXT,
                            relief="flat", padx=15, pady=5,
                            command=lambda: close_submenu(False))
        cancel_btn.pack(side=tk.LEFT, padx=(0, 10))
        apply_btn = tk.Button(btn_frame, text="Übernehmen", bg=BUTTON_COLOR, fg=DISCORD_TEXT,
                            activebackground=BUTTON_HOVER, activeforeground=DISCORD_TEXT,
                            relief="flat", padx=15, pady=5,
                            command=lambda: close_submenu(True))
        apply_btn.pack(side=tk.LEFT)
        def close_submenu(apply_changes):
            if apply_changes:
                try:
                    formel_params.GW0 = var_GW0.get()
                    formel_params.A = var_A.get()
                    formel_params.T = var_T.get()
                    formel_params.freq = var_freq.get()
                    formel_params.Da = var_Da.get()
                    formel_params.Dd = var_Dd.get()
                    formel_params.R_scale = var_R.get()
                    formel_params.curve_randomness = var_randomness.get()
                    formel_params.secondary_freq = var_secondary.get()
                    formel_label.config(text=formel_params.generiere_formel())
                except Exception as e:
                    print(f"Fehler beim Übernehmen der Parameter: {e}")
            try:
                submenu.destroy()
            except: pass
            root.submenu_open = False
        def on_submenu_close():
            root.submenu_open = False
            submenu.destroy()
        update_graph()
        submenu.protocol("WM_DELETE_WINDOW", on_submenu_close)
        submenu.focus_set()
        submenu.transient(root)
        submenu.grab_set()

    def emoji_img(size, text):
        im = Image.new("RGBA", (size*2, size*2), (255, 255, 255, 0))
        draw = ImageDraw.Draw(im)
        # Versuche Segoe UI Emoji zuerst, dann Segoe UI Symbol als Fallback
        try:
            font = ImageFont.truetype("seguiemj.ttf", size=int(round(size*72/96, 0)))
        except IOError:
            try:
                font = ImageFont.truetype("seguisym.ttf", size=int(round(size*72/96, 0)))
            except IOError: # Fallback zu einem generischen Font, falls beide nicht da sind
                font = ImageFont.load_default()
                print("Warnung: Segoe UI Emoji/Symbol Font nicht gefunden. Emoji-Darstellung könnte abweichen.")

        draw.text((size, size), text, embedded_color=True, font=font, anchor="mm")
        return ImageTk.PhotoImage(im)

    pencil_emoji = emoji_img(20, "✏️")
    button_size_pencil = 30
    button_canvas2 = tk.Canvas(formel_canvas, width=button_size_pencil, height=button_size_pencil,
                            bg=DISCORD_DARK, highlightthickness=0)
    formel_canvas.create_window(400, 30, window=button_canvas2)
    bg_rect_pencil = create_rounded_rect(button_canvas2, 0, 0, button_size_pencil, button_size_pencil,
                    radius=10, fill=DISCORD_INPUT_BG, outline="")
    button_canvas2.create_image(button_size_pencil/2+11, button_size_pencil/2+2, image=pencil_emoji, anchor="center")
    button_canvas2.image = pencil_emoji
    button_canvas2.bind("<Button-1>", lambda e: open_formel_submenu())
    def on_pencil_hover(event):
        button_canvas2.itemconfig(bg_rect_pencil, fill=DISCORD_DARKER)
    def on_pencil_leave(event):
        button_canvas2.itemconfig(bg_rect_pencil, fill=DISCORD_INPUT_BG)
    button_canvas2.bind("<Enter>", on_pencil_hover)
    button_canvas2.bind("<Leave>", on_pencil_leave)


    output_dir_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    output_dir_frame.pack(fill=tk.X, pady=(0, 10))

    output_dir_canvas = tk.Canvas(output_dir_frame, bg=DISCORD_BG, height=80,
                                highlightthickness=0, width=580)
    output_dir_canvas.pack(fill=tk.X)

    create_rounded_rect(output_dir_canvas, 0, 0, 580, 80, radius=15,
                    fill=DISCORD_DARK, outline="")

    output_dir_label = tk.Label(output_dir_canvas, text="Speicherort:", **label_style)
    output_dir_canvas.create_window(20, 25, window=output_dir_label, anchor="w")

    
    path_button_y_center = 55
    path_element_height = 30
    folder_button_width = 30
    
    # Calculate width for the path entry's background canvas
    # Total canvas width (580) - left padding (20) - right padding (20) - folder button width (30) - gap (10)
    path_entry_bg_width = 565 - 20 - 20 - folder_button_width - 10 # Results in 500

    # 1. Create a canvas for the path entry's rounded background
    path_entry_bg_canvas = tk.Canvas(output_dir_canvas,
                                    width=path_entry_bg_width,
                                    height=path_element_height,
                                    bg=DISCORD_DARK,  # Match section background, the rounded rect will cover this
                                    highlightthickness=0)
    
    # Draw the rounded rectangle on this canvas
    create_rounded_rect(path_entry_bg_canvas, 0, 0,
                        path_entry_bg_width, path_element_height,
                        radius=8, fill=DISCORD_INPUT_BG, outline="")

    # 2. The actual Entry widget for the path
    output_dir_entry = tk.Entry(path_entry_bg_canvas,  # Parent is now path_entry_bg_canvas
                                textvariable=root.output_directory_path,
                                width=45,  # Character width hint, pixel width is controlled by create_window
                                **entry_style)  # Includes bg, fg, bd=0, relief="flat"
    
    # Place the Entry widget inside its background canvas, centered with padding
    path_entry_bg_canvas.create_window(path_entry_bg_width / 2,
                                    path_element_height / 2,
                                    width=path_entry_bg_width - 12,  # Pixel width for entry (6px padding each side)
                                    height=path_element_height - 8, # Pixel height for entry (4px padding top/bottom)
                                    window=output_dir_entry)

    # Place the path_entry_bg_canvas (containing the Entry) onto the main output_dir_canvas
    output_dir_canvas.create_window(25, path_button_y_center,
                                    window=path_entry_bg_canvas,
                                    anchor="w")  # Anchor "w" (west/left-middle)
    

    # Button für Verzeichnisauswahl
    folder_emoji = emoji_img(20, "📂") # Kleinere Emoji-Größe für den Button
    
    select_dir_button_canvas = tk.Canvas(output_dir_canvas,
                                        width=folder_button_width,
                                        height=path_element_height, # Use consistent height
                                        bg=DISCORD_DARK, # Match section background
                                        highlightthickness=0, cursor="hand2")
    
    # Position the folder button canvas to the right of the path entry, with a gap
    folder_button_x_start = 20 + path_entry_bg_width + 10  # Left_pad + width_of_path_bg + gap
    output_dir_canvas.create_window(folder_button_x_start, path_button_y_center,
                                    window=select_dir_button_canvas,
                                    anchor="w") # Anchor "w" (west/left-middle)

    bg_rect_folder = create_rounded_rect(select_dir_button_canvas, 0, 0,
                                        folder_button_width, path_element_height, # Use consistent height
                                        radius=8, fill=DISCORD_INPUT_BG, outline="")
    
    select_dir_button_canvas.create_image(folder_button_width / 2 + 1,
                                        path_element_height / 2 + 1, # Centered in the new height
                                        image=folder_emoji, anchor="center")
    select_dir_button_canvas.image = folder_emoji

    # Function to open directory dialog (assuming it's defined elsewhere or keep it here)
    def select_directory():
        directory = filedialog.askdirectory(
            title="Speicherort auswählen",
            initialdir=root.output_directory_path.get()
        )
        if directory:
            root.output_directory_path.set(directory)

    select_dir_button_canvas.bind("<Button-1>", lambda e: select_directory())

    def on_folder_button_hover(event):
        select_dir_button_canvas.itemconfig(bg_rect_folder, fill=DISCORD_DARKER)
    def on_folder_button_leave(event):
        select_dir_button_canvas.itemconfig(bg_rect_folder, fill=DISCORD_INPUT_BG)

    select_dir_button_canvas.bind("<Enter>", on_folder_button_hover)
    select_dir_button_canvas.bind("<Leave>", on_folder_button_leave)


    # 4. Fortschrittsbalken
    progress_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    progress_frame.pack(fill=tk.X, pady=(0, 10))
    progress_canvas = tk.Canvas(progress_frame, bg=DISCORD_BG, height=80,
                             highlightthickness=0, width=580)
    progress_canvas.pack(fill=tk.X)
    create_rounded_rect(progress_canvas, 0, 0, 580, 80, radius=15,
                       fill=DISCORD_DARK, outline="")
    style.configure("Custom.Horizontal.TProgressbar",
                    troughcolor=DISCORD_INPUT_BG,
                    background=DISCORD_GREEN,
                    troughrelief="flat",
                    borderwidth=0,
                    thickness=15,
                    pbarrelief="flat")
    progress = ttk.Progressbar(progress_canvas, 
                            orient="horizontal", 
                            length=520,
                            mode="determinate", 
                            style="Custom.Horizontal.TProgressbar")
    progress_canvas.create_window(285, 30, window=progress)
    progress_info = tk.Label(progress_canvas, text="Werte generiert (0%)", **label_style)
    progress_canvas.create_window(285, 60, window=progress_info)

    # 5. Start Button
    button_frame = tk.Frame(main_frame, bg=DISCORD_BG)
    button_frame.pack(fill=tk.X, pady=(0, 10))
    button_canvas = tk.Canvas(button_frame, bg=DISCORD_BG, height=100,
                            highlightthickness=0, width=580)
    button_canvas.pack(fill=tk.X)
    create_rounded_rect(button_canvas, 0, 0, 580, 100, radius=15,
                       fill=DISCORD_DARK, outline="")
    start_button_canvas = tk.Canvas(button_canvas, width=160, height=40,
                                  bg=DISCORD_DARK, highlightthickness=0, cursor="hand2") # Added cursor
    button_canvas.create_window(290, 40, window=start_button_canvas)
    start_button_bg = create_rounded_rect(start_button_canvas, 0, 0, 160, 40,
                                       radius=15, fill=BUTTON_COLOR, outline="")
    start_button_text = start_button_canvas.create_text(80, 20, text="Start",
                                                     fill=DISCORD_TEXT,
                                                     font=("Arial", 14, "bold"))
    werte_info = tk.Label(button_canvas, text="Zu generierende Werte gesamt: -", # Text angepasst
                        bg=DISCORD_DARK, fg=DISCORD_TEXT, font=('Arial', 11))
    button_canvas.create_window(290, 80, window=werte_info)

    def cancel_process(event=None):
        if root.generation_thread and root.generation_thread.is_alive():
            progress_info.config(text="Abbruch wird eingeleitet...")
            root.cancel_generation_flag.set() # Signal zum Abbrechen an den Thread senden
            
            # Button zurück zu "Start" und ursprüngliche Farbe
            start_button_canvas.itemconfig(start_button_text, text="Start")
            start_button_canvas.itemconfig(start_button_bg, fill=BUTTON_COLOR)
            start_button_canvas.unbind("<Button-1>") # Unbind cancel
            # Rebind start_process (which is root.start_process_method by this point)
            start_button_canvas.bind("<Button-1>", root.start_process_method) 

    def start_process(event=None):
        # Button-Zustand zu "Abbrechen" ändern
        start_button_canvas.itemconfig(start_button_text, text="Abbrechen")
        start_button_canvas.itemconfig(start_button_bg, fill="#FF5555") # Rote Farbe für Abbruch
        start_button_canvas.unbind("<Button-1>") # Unbind start
        start_button_canvas.bind("<Button-1>", cancel_process) # Bind cancel

        root.update_idletasks()
        progress['value'] = 0
        progress_info.config(text="Vorbereitung...")
        root.update_idletasks()

        root.cancel_generation_flag.clear() 
        root.partial_files_to_delete = [] 

        try:
            start_date_str = startdatum.get()
            end_date_str = enddatum.get()
            start_date_obj = parse_flexible_date(start_date_str)
            end_date_obj = parse_flexible_date(end_date_str)

            if start_date_obj > end_date_obj:
                raise ValueError("Startdatum muss vor Enddatum liegen")

            interval_hours_str = intervall_entry.get()
            if not interval_hours_str:
                raise ValueError("Intervall darf nicht leer sein.")
            try:
                interval_hours_val = float(interval_hours_str.replace(',', '.')) # Handle comma as decimal
            except ValueError:
                raise ValueError("Intervall muss eine Zahl sein.")
            if interval_hours_val <= 0:
                raise ValueError("Intervall muss größer als 0 sein")

            messstellen_text_inhalt = messstellen_text.get("1.0", tk.END).strip()
            valid, messstellen_ids_list = validiere_messstellen(messstellen_text_inhalt)
            if not valid:
                raise ValueError(messstellen_ids_list) # messstellen_ids_list is the error message here

            output_dir = root.output_directory_path.get()
            if not output_dir:
                output_dir = "." 
            if not os.path.isdir(output_dir):
                # Try to create directory if it doesn't exist
                try:
                    os.makedirs(output_dir, exist_ok=True)
                    print(f"Ausgabeverzeichnis '{output_dir}' erstellt.")
                except OSError as e:
                    progress_info.config(text=f"Fehler: Ausgabepfad '{output_dir}' ungültig/nicht erstellbar: {e}")
                    # Button zurücksetzen bei Fehler
                    start_button_canvas.itemconfig(start_button_text, text="Start")
                    start_button_canvas.itemconfig(start_button_bg, fill=BUTTON_COLOR)
                    start_button_canvas.unbind("<Button-1>")
                    start_button_canvas.bind("<Button-1>", root.start_process_method) # Use root.start_process_method
                    return

            root.generation_thread = threading.Thread(target=create_csv_files_thread_wrapper,
                                        args=(root, start_date_obj, end_date_obj, messstellen_ids_list,
                                            interval_hours_val, formel_params, progress, progress_info, output_dir,
                                            start_button_canvas, start_button_text, start_button_bg)) 
            root.generation_thread.daemon = True
            root.generation_thread.start()
        except Exception as e:
            progress_info.config(text=f"Fehler: {str(e)}")
            progress['value'] = 0
            start_button_canvas.itemconfig(start_button_text, text="Start")
            start_button_canvas.itemconfig(start_button_bg, fill=BUTTON_COLOR)
            start_button_canvas.unbind("<Button-1>") 
            start_button_canvas.bind("<Button-1>", root.start_process_method) # Use root.start_process_method
            
    # MODIFICATION 1: Assign start_process to root so it can be called via root.start_process_method
    # This should be done after start_process is defined.
    root.start_process_method = start_process

    # MODIFICATION 2: Initial binding for the start button
    # This should be done after start_button_canvas and start_process (now root.start_process_method) are defined.
    start_button_canvas.bind("<Button-1>", root.start_process_method)
            

    def open_website(event):
        webbrowser.open("https://www.ribeka.com")
    copyright_label = tk.Label(root,
                            text=f" © Copyright ribeka GmbH 2025",
                            bg=DISCORD_BG,
                            fg=DISCORD_GRAY_TEXT,
                            font=('Arial', 9, 'normal'),
                            cursor="hand2") 
    copyright_label.place(relx=0.5, rely=1.0, anchor='s', y=-5)
    copyright_label.bind("<Button-1>", open_website)

    today = datetime.now()
    next_week = today + timedelta(days=7)
    startdatum.set_date(today)
    enddatum.set_date(next_week)
    berechne_alles() # Initialberechnung

    return root

if __name__ == "__main__":
    matplotlib.use('TkAgg') # Sicherstellen, dass der richtige Backend für Matplotlib verwendet wird
    app = create_gui()
    app.mainloop()