sap.py

import os
import csv
import zipfile
import shutil
import datetime
import re # Für die Extraktion der Personalnummer
import tkinter as tk
from tkinter import filedialog, messagebox, scrolledtext, ttk # ttk importiert
import tempfile # Für robustere temporäre Verzeichnisse
import io # For stringIO operations for preview
import json # Zum Speichern und Laden der Konfiguration
import calendar # Für die Berechnung des letzten Monatstags
import sys # Für sys.executable und sys._MEIPASS bei .exe Erstellung
import subprocess # Zum Aufrufen externer Programme wie PCSCMD.exe
import threading # Für nicht-blockierende Operationen (SFTP, Progressbar)

# Versuche, tkcalendar und paramiko zu importieren.
# Try to import tkcalendar and paramiko.
try:
    from tkcalendar import DateEntry
except ImportError:
    root_temp = tk.Tk()
    root_temp.withdraw() 
    messagebox.showerror(
        "Fehlende Bibliothek",
        "Die Bibliothek 'tkcalendar' wird für die Datumsauswahl benötigt.\n"
        "Bitte installieren Sie diese über 'pip install tkcalendar' in Ihrer Kommandozeile/Terminal."
    )
    root_temp.destroy()
    sys.exit(1)

try:
    import paramiko
except ImportError:
    root_temp = tk.Tk()
    root_temp.withdraw()
    messagebox.showerror(
        "Fehlende Bibliothek",
        "Die Bibliothek 'paramiko' wird für SFTP-Uploads benötigt.\n"
        "Bitte installieren Sie diese über 'pip install paramiko' in Ihrer Kommandozeile/Terminal."
    )
    root_temp.destroy()
    sys.exit(1)


# Konfiguration für Monatsnamen (Abkürzung zu Vollname)
# Configuration for month names (abbreviation to full name)
MONTH_MAP_EN = { 
    "Jan": "January", "Feb": "February", "Mar": "March", "Apr": "April",
    "May": "May", "Jun": "June", "Jul": "July", "Aug": "August",
    "Sep": "September", "Oct": "October", "Nov": "November", "Dec": "December"
}

# Deutsche Monatsnamen für die Datumsextraktion
GERMAN_MONTH_TO_NUM = {
    "januar": 1, "februar": 2, "märz": 3, "maerz": 3, "april": 4,
    "mai": 5, "juni": 6, "juli": 7, "august": 8, "september": 9,
    "oktober": 10, "november": 11, "dezember": 12
}

# Name der Konfigurationsdatei und Icon-Datei
# Name of the configuration file and icon file
CONFIG_FILE_BASENAME = "sftp_zip_generator_config.json"
ICON_FILE_BASENAME = "sap.png" 

last_created_zip_filepath = None # Globale Variable für den Pfad der letzten ZIP-Datei
                                 # Global variable for the path of the last ZIP file
progress_bar = None # Globale Variable für den Fortschrittsbalken
                    # Global variable for the progress bar
root_window_ref = None # Globale Referenz auf das Hauptfenster für Threading-Callbacks
                       # Global reference to the main window for threading callbacks
main_process_button_ref = None # Referenz auf den Haupt-Prozess-Button für Progressbar-Platzierung


def get_application_path():
    # Returns the path to the application's directory.
    # Works for both .py scripts and .exe files created with PyInstaller.
    """Gibt den Pfad zum Verzeichnis der Anwendung zurück.
    Funktioniert sowohl für .py Skripte als auch für mit PyInstaller erstellte .exe Dateien."""
    if getattr(sys, 'frozen', False):
        # Wenn die Anwendung "eingefroren" ist (z.B. durch PyInstaller)
        # If the application is "frozen" (e.g., by PyInstaller)
        application_path = os.path.dirname(sys.executable)
    else:
        # Normale Ausführung als .py Skript
        # Normal execution as a .py script
        application_path = os.path.dirname(os.path.abspath(__file__))
    return application_path

def resource_path(relative_path):
    # Gets the absolute path to a resource, works for development and PyInstaller.
    """Holt den absoluten Pfad zu einer Ressource, funktioniert für Entwicklung und PyInstaller."""
    try:
        # PyInstaller erstellt einen temporären Ordner und speichert den Pfad in _MEIPASS
        # PyInstaller creates a temporary folder and stores the path in _MEIPASS
        base_path = sys._MEIPASS
    except Exception:
        # Nicht in einem PyInstaller-Bundle ausgeführt
        # Not running in a PyInstaller bundle
        base_path = get_application_path()
    return os.path.join(base_path, relative_path)

def get_config_file_path():
    # Returns the full path to the configuration file (in the application directory).
    """Gibt den vollständigen Pfad zur Konfigurationsdatei zurück (im Anwendungsverzeichnis)."""
    return os.path.join(get_application_path(), CONFIG_FILE_BASENAME)

def get_icon_file_path():
    # Returns the full path to the icon file (possibly from the bundle).
    """Gibt den vollständigen Pfad zur Icon-Datei zurück (ggf. aus dem Bundle)."""
    return resource_path(ICON_FILE_BASENAME)


# --- Konfigurationsfunktionen (Configuration functions) ---
def load_config():
    # Loads the configuration from a file in the script directory.
    """Lädt die Konfiguration aus einer Datei im Skriptverzeichnis."""
    config_path = get_config_file_path()
    defaults = {
        "input_folder": "", 
        "output_folder": "",
        "pcscmd_path": "",
        "split_rule_path": "",
        "split_source_pdf_path": "", 
        "split_pdf_active": True,
        "sftp_server": "sftp74.sapsf.eu", 
        "sftp_user": "sefarag-stage",    
        "sftp_password": "",             
        "sftp_remote_folder": "/incoming/PaySlips_MonosuisseAG", 
        "upload_after_zip_creation": True 
    }
    try:
        if os.path.exists(config_path):
            with open(config_path, 'r', encoding='utf-8') as f:
                config = json.load(f)
                for key, default_value in defaults.items():
                    if key not in config:
                        config[key] = default_value
                return config
    except Exception as e:
        print(f"Fehler beim Laden der Konfiguration von '{config_path}': {e}") 
    return defaults

def save_config(config_data_to_save): 
    # Saves the current configuration to a file in the script directory.
    """Speichert die aktuelle Konfiguration in einer Datei im Skriptverzeichnis."""
    config_path = get_config_file_path()
    try:
        with open(config_path, 'w', encoding='utf-8') as f:
            json.dump(config_data_to_save, f, indent=4) 
        if log_text_area: 
            log_message(f"Konfiguration gespeichert in: {config_path}")
    except Exception as e:
        if log_text_area: 
            log_message(f"Fehler beim Speichern der Konfiguration in '{config_path}': {e}", is_error=True)
        else:
            print(f"Fehler beim Speichern der Konfiguration in '{config_path}': {e}")


# --- Kernlogik (Core logic) ---
def extract_payslip_info(pdf_filename):
    # Extracts personnel ID, document name base, and a specific effective date (if "Februar" is in the name).
    # Returns: (person_id, doc_name_base, specific_effective_date_str or None)
    """Extrahiert Personal-ID, Dokumentname-Basis und ein spezifisches Gültigkeitsdatum (falls ein Monat/Jahr im Namen)."""
    person_id = None
    base_name_part = None
    specific_effective_date_str = None

    match_id_middle = re.search(r'_(\d+)_', pdf_filename) 
    if match_id_middle:
        person_id = match_id_middle.group(1)
        base_name_part = pdf_filename[:-4] if pdf_filename.lower().endswith(".pdf") else pdf_filename
    else:
        match_id_end = re.search(r'_(\d+)\.pdf$', pdf_filename, re.IGNORECASE) 
        if match_id_end:
            person_id = match_id_end.group(1)
            base_name_part = re.split(r'_' + re.escape(person_id) + r'\.pdf$', pdf_filename, flags=re.IGNORECASE)[0]
        else:
            match_id_start = re.search(r'^(\d+)_', pdf_filename) 
            if match_id_start:
                person_id = match_id_start.group(1)
                base_name_part = pdf_filename[:-4] if pdf_filename.lower().endswith(".pdf") else pdf_filename
            else:
                log_message(f"Warnung: Personal-ID konnte nicht aus '{pdf_filename}' extrahiert werden (Muster: _ID_, _ID.pdf, ID_). Überspringe.")
                return None, None, None
    
    if base_name_part is None:
        log_message(f"Warnung: Basisname für Dokument konnte nicht für '{pdf_filename}' ermittelt werden. Überspringe.", is_error=True)
        return None, None, None

    doc_name_base = base_name_part
    for short_month, long_month in MONTH_MAP_EN.items():
        if re.search(r'\b' + re.escape(short_month) + r'\b', base_name_part, re.IGNORECASE):
            doc_name_base = re.sub(r'\b' + re.escape(short_month) + r'\b', long_month, base_name_part, 1, flags=re.IGNORECASE)
            break
    
    # Spezifisches Datum für erkannten Monat/Jahr extrahieren
    # Extract specific date for recognized month/year
    # Präzisere Regex: sucht nach "Monat Jahr" als separate Wörter, Gross-/Kleinschreibung ignoriert
    month_year_pattern = r'\b(' + '|'.join(GERMAN_MONTH_TO_NUM.keys()) + r')\s+(\d{4})\b' # \b für Wortgrenze
    month_year_match = re.search(month_year_pattern, pdf_filename, re.IGNORECASE)

    if month_year_match:
        month_name_de = month_year_match.group(1).lower()
        year_str = month_year_match.group(2)
        log_message(f"Für '{pdf_filename}': Monat '{month_name_de}', Jahr '{year_str}' im Dateinamen erkannt.") # Debug-Log
        
        try:
            year = int(year_str)
            month = GERMAN_MONTH_TO_NUM[month_name_de]
            # Letzten Tag des Monats bestimmen (determine last day of month)
            last_day = calendar.monthrange(year, month)[1]
            specific_date = datetime.date(year, month, last_day)
            specific_effective_date_str = specific_date.strftime("%m/%d/%Y")
            log_message(f"Spezifisches Datum für '{pdf_filename}' (Monatsende aus Dateiname): {specific_effective_date_str}")
        except ValueError:
            log_message(f"Warnung: Ungültiges Jahr '{year_str}' in '{pdf_filename}'. Globales Datum wird verwendet.", is_error=True)
            specific_effective_date_str = None # Sicherstellen, dass es None ist bei Fehler
        except Exception as e:
            log_message(f"Fehler bei Datumsberechnung für '{pdf_filename}': {e}. Globales Datum wird verwendet.", is_error=True)
            specific_effective_date_str = None # Sicherstellen, dass es None ist bei Fehler
    else:
        log_message(f"Kein 'Monat Jahr'-Muster im Dateinamen '{pdf_filename}' gefunden. Globales Datum wird verwendet.")
        specific_effective_date_str = None


    return person_id, doc_name_base, specific_effective_date_str


def prepare_pay_slips_csv_data(pdf_files_info_with_date, global_effective_date):
    # Prepares the data for Pay Slips.csv.
    """Bereitet die Daten für Pay Slips.csv vor."""
    header1 = ["[OPERATOR]", "externalCode", "effectiveStartDate"]
    header2 = ["Supported operators: Delimit, Clear and Delete", "externalCode", "effectiveStartDate"]
    data_rows = []
    for person_id, _, specific_date_str in pdf_files_info_with_date:
        effective_date_to_use = specific_date_str if specific_date_str else global_effective_date
        data_rows.append(["", person_id, effective_date_to_use])
    return header1, header2, data_rows

def prepare_pay_slips_payslips_csv_data(pdf_files_info_full_with_date, global_effective_date):
    # Prepares the data for Pay Slips-payslips.csv.
    """Bereitet die Daten für Pay Slips-payslips.csv vor."""
    header1 = [
        "[OPERATOR]", 
        "externalCode",                 
        "effectiveStartDate",           
        "cust_PaySlips_Details.externalCode", 
        "cust_PaySlips_Details.cust_Document_Name", 
        "cust_PaySlips_Details.cust_AttachmentPaySlip"
    ]
    header2 = [
        "Supported operators: Delimit, Clear and Delete", "Pay Slips.externalCode", 
        "Pay Slips.effectiveStartDate", "externalCode", "Document Name", "Attachment"
    ]
    data_rows = []
    for person_id, doc_name_base, pdf_filename, specific_date_str in pdf_files_info_full_with_date:
        effective_date_to_use = specific_date_str if specific_date_str else global_effective_date
        data_rows.append(["", person_id, effective_date_to_use, "", doc_name_base, pdf_filename])
    return header1, header2, data_rows

def write_csv_to_file(filepath, header1, header2, data_rows, encoding="utf-8-sig"):
    # Writes the CSV data to a file.
    """Schreibt die CSV-Daten in eine Datei."""
    try:
        with open(filepath, "w", newline="", encoding=encoding) as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow(header1)
            writer.writerow(header2)
            writer.writerows(data_rows)
        return True
    except IOError as e:
        log_message(f"Fehler beim Schreiben der CSV-Datei '{os.path.basename(filepath)}': {e}", is_error=True)
        return False

def format_csv_data_for_preview(header1, header2, data_rows, num_preview_rows=10):
    # Formats CSV data as a string for the preview.
    """Formatiert CSV-Daten als String für die Vorschau."""
    output = io.StringIO()
    writer = csv.writer(output)
    writer.writerow(header1)
    writer.writerow(header2)
    for i, row in enumerate(data_rows):
        if i < num_preview_rows:
            writer.writerow(row)
    if len(data_rows) > num_preview_rows:
        output.write(f"\n... und {len(data_rows) - num_preview_rows} weitere Zeile(n).")
    return output.getvalue()

def create_import_properties(work_dir):
    # Creates the import.properties file in the working directory.
    """Erstellt die Datei import.properties im Arbeitsverzeichnis."""
    properties_content = """encoding=UTF-8
#purgeType should be one of 'incremental' or 'fullPurge'
purgeType=incremental
#'suppressData' applies only when 'purgeType=incremental'. You can set the value either to 'true' or 'false'. By default, the value is set to 'true'.
#When 'suppressData' is set to 'true', the system automatically identifies and skips duplicate records within the dataset, ensuring that unique records are added or updated.
#In this context, "duplicate records" refer to records where all business fields have identical values, except for the key field values, such as the effective start date or transaction sequence ID.
#Note that setting 'suppressData=true' during 'purgeType=fullPurge' leads to import failure.
#Remove '#' in the following line to use the parameter 'suppressData' during import.
#suppressData=true
#keyPreference should be one of 'ExternalCode' or 'BusinessKey'
keyPreference=BusinessKey
#ignoreSecurity indicates whether we ignore the RBP checks during the import process, it should be either 'true' or 'false'.
ignoreSecurity=false
#Use the formatLocale field to specify a locale. Fields whose data type is 'Date' or 'Number' are required to follow the format of the specified locale. Only Gregorian date format is supported. 
#formatLocale=en_US
#identityType should be one of 'AssignmentID' or 'UserID'
identityType=UserID
rootFileName=Pay Slips.csv
"""
    filepath = os.path.join(work_dir, "import.properties")
    try:
        with open(filepath, "w", encoding="utf-8") as f:
            f.write(properties_content)
        log_message(f"'import.properties' erfolgreich erstellt (basierend auf Vorlage).")
    except IOError as e:
        log_message(f"Fehler beim Erstellen von 'import.properties': {e}", is_error=True)
        return False
    return True

def create_import_sequence_csv(work_dir):
    # Creates the import_sequence.csv file in the working directory.
    """Erstellt die Datei import_sequence.csv im Arbeitsverzeichnis."""
    header = ["File Name", "Object Type", "Import Order", "Path"]
    rows = [
        ["Pay Slips.csv", "cust_PaySlips", "1", "cust_PaySlips"],
        ["Pay Slips-payslips.csv", "cust_PaySlips", "2", "cust_PaySlips-cust_PaySlips_Details"]
    ]
    filepath = os.path.join(work_dir, "import_sequence.csv")
    try:
        with open(filepath, "w", newline="", encoding="utf-8") as csvfile:
            writer = csv.writer(csvfile)
            writer.writerow(header)
            writer.writerows(rows)
        log_message(f"'import_sequence.csv' erfolgreich erstellt (basierend auf Vorlage).")
    except IOError as e:
        log_message(f"Fehler beim Erstellen von 'import_sequence.csv': {e}", is_error=True)
        return False
    return True

def create_zip_archive(work_dir, output_zip_folder):
    # Creates the ZIP archive and returns the full path to the ZIP file.
    """Erstellt das ZIP-Archiv und gibt den vollständigen Pfad zur ZIP-Datei zurück."""
    current_date_str = datetime.datetime.now().strftime("%d%m%Y")
    zip_filename = f"PaySlips_{current_date_str}.zip"
    zip_filepath = os.path.join(output_zip_folder, zip_filename)
    try:
        with zipfile.ZipFile(zip_filepath, 'w', zipfile.ZIP_DEFLATED) as zf:
            for item in ["import.properties", "import_sequence.csv", "Pay Slips.csv", "Pay Slips-payslips.csv"]:
                zf.write(os.path.join(work_dir, item), arcname=item)
            attachments_source_path = os.path.join(work_dir, "attachments")
            for root, _, files_in_dir in os.walk(attachments_source_path):
                for file_in_zip in files_in_dir: 
                    full_file_path = os.path.join(root, file_in_zip)
                    zf.write(full_file_path, arcname=os.path.join("attachments", file_in_zip))
        log_message(f"ZIP-Archiv '{zip_filepath}' erfolgreich erstellt.")
        messagebox.showinfo("Erfolg", f"ZIP-Archiv '{zip_filename}' wurde erfolgreich erstellt in:\n{output_zip_folder}")
        return zip_filepath 
    except Exception as e:
        log_message(f"Fehler beim Erstellen des ZIP-Archivs: {e}", is_error=True)
        messagebox.showerror("Fehler", f"Fehler beim Erstellen des ZIP-Archivs:\n{e}")
        return None 

# --- SFTP Upload Funktion ---
def sftp_upload_progress_callback(bytes_so_far, total_bytes):
    # Callback function for SFTP upload progress.
    """Callback-Funktion für den SFTP-Upload-Fortschritt."""
    if progress_bar and root_window_ref:
        progress = int((bytes_so_far / total_bytes) * 100)
        # Sende Update an den Haupt-Thread
        # Send update to the main thread
        root_window_ref.after_idle(lambda: progress_bar.config(value=progress, mode='determinate'))


def upload_sftp_threaded(local_zip_path, sftp_server, sftp_user, sftp_password, sftp_remote_folder, button_to_re_enable):
    # Executes the SFTP upload in a separate thread.
    """Führt den SFTP-Upload in einem separaten Thread aus."""
    if button_to_re_enable: 
        root_window_ref.after_idle(lambda: button_to_re_enable.config(state=tk.DISABLED))
    if progress_bar:
        root_window_ref.after_idle(lambda: progress_bar.config(value=0, mode='determinate', maximum=100))
        root_window_ref.after_idle(lambda: progress_bar.pack(fill=tk.X, pady=(0, 5), before=main_process_button_ref)) 

    if not local_zip_path or not os.path.exists(local_zip_path):
        log_message("SFTP Upload: Lokale ZIP-Datei nicht gefunden.", is_error=True)
        messagebox.showerror("SFTP Fehler", "Lokale ZIP-Datei für Upload nicht gefunden.")
        if button_to_re_enable: root_window_ref.after_idle(lambda: button_to_re_enable.config(state=tk.NORMAL))
        if progress_bar: root_window_ref.after_idle(progress_bar.pack_forget)
        return 

    zip_filename = os.path.basename(local_zip_path)
    remote_path = os.path.join(sftp_remote_folder, zip_filename).replace("\\", "/") 

    log_message(f"Starte SFTP-Upload von '{local_zip_path}' nach '{sftp_server}:{remote_path}'...")
    
    transport = None
    sftp = None
    try:
        transport = paramiko.Transport((sftp_server, 22)) 
        transport.connect(username=sftp_user, password=sftp_password)
        sftp = paramiko.SFTPClient.from_transport(transport)
        log_message(f"SFTP-Verbindung zu {sftp_server} erfolgreich hergestellt.")
        try:
            sftp.chdir(sftp_remote_folder)
            log_message(f"Erfolgreich zum Remote-Ordner '{sftp_remote_folder}' gewechselt.")
        except IOError: 
            log_message(f"Remote-Ordner '{sftp_remote_folder}' nicht gefunden. Versuche zu erstellen...")
            try:
                current_dir = ""
                for part in sftp_remote_folder.strip("/").split("/"):
                    current_dir += "/" + part
                    try:
                        sftp.listdir(current_dir)
                    except IOError:
                        sftp.mkdir(current_dir)
                        log_message(f"Remote-Ordner '{current_dir}' erstellt.")
                sftp.chdir(sftp_remote_folder) 
                log_message(f"Erfolgreich zum neu erstellten Remote-Ordner '{sftp_remote_folder}' gewechselt.")
            except Exception as e_mkdir:
                log_message(f"Fehler beim Erstellen des Remote-Ordners '{sftp_remote_folder}': {e_mkdir}", is_error=True)
                messagebox.showerror("SFTP Fehler", f"Konnte Remote-Ordner nicht erstellen:\n{sftp_remote_folder}\n{e_mkdir}")
                if progress_bar: root_window_ref.after_idle(progress_bar.pack_forget)
                if button_to_re_enable: root_window_ref.after_idle(lambda: button_to_re_enable.config(state=tk.NORMAL))
                return 

        log_message(f"Lade '{zip_filename}' nach '{remote_path}' hoch...")
        sftp.putfo(open(local_zip_path, 'rb'), remote_path, callback=sftp_upload_progress_callback) 
        log_message("SFTP-Upload erfolgreich abgeschlossen.")
        messagebox.showinfo("SFTP Erfolg", f"Datei '{zip_filename}' erfolgreich hochgeladen.")

    except paramiko.AuthenticationException:
        log_message("SFTP-Authentifizierung fehlgeschlagen. Bitte Benutzername/Passwort prüfen.", is_error=True)
        messagebox.showerror("SFTP Fehler", "Authentifizierung fehlgeschlagen.\nBitte Benutzername und Passwort überprüfen.")
    except paramiko.SSHException as sshException:
        log_message(f"SFTP SSH-Fehler: {sshException}", is_error=True)
        messagebox.showerror("SFTP Fehler", f"SSH-Fehler:\n{sshException}")
    except Exception as e:
        log_message(f"Allgemeiner SFTP-Fehler: {e}", is_error=True)
        messagebox.showerror("SFTP Fehler", f"Ein Fehler ist beim SFTP-Upload aufgetreten:\n{e}")
    finally:
        if sftp:
            sftp.close()
        if transport:
            transport.close()
        log_message("SFTP-Verbindung geschlossen.")
        if progress_bar: root_window_ref.after_idle(progress_bar.pack_forget)
        if button_to_re_enable: root_window_ref.after_idle(lambda: button_to_re_enable.config(state=tk.NORMAL)) 

def test_sftp_connection_threaded(sftp_server, sftp_user, sftp_password, sftp_remote_folder, test_button_widget):
    # Executes the SFTP connection test in a separate thread.
    """Führt den SFTP-Verbindungstest in einem separaten Thread aus."""
    if test_button_widget: 
        root_window_ref.after_idle(lambda: test_button_widget.config(state=tk.DISABLED))
    if progress_bar:
        root_window_ref.after_idle(lambda: progress_bar.config(mode='indeterminate'))
        root_window_ref.after_idle(lambda: progress_bar.pack(fill=tk.X, pady=(0, 5), before=main_process_button_ref)) 
        root_window_ref.after_idle(progress_bar.start)

    log_message(f"Teste SFTP-Verbindung zu {sftp_server} mit Benutzer {sftp_user}...")
    transport = None
    sftp = None
    try:
        transport = paramiko.Transport((sftp_server, 22))
        transport.connect(username=sftp_user, password=sftp_password)
        sftp = paramiko.SFTPClient.from_transport(transport)
        log_message("SFTP-Authentifizierung erfolgreich.")
        try:
            sftp.listdir(sftp_remote_folder)
            log_message(f"SFTP-Verbindungstest erfolgreich. Inhalt von '{sftp_remote_folder}' konnte aufgelistet werden.")
            messagebox.showinfo("SFTP Test", "SFTP-Verbindung erfolgreich getestet!")
        except IOError:
            log_message(f"SFTP-Verbindungstest: Remote-Ordner '{sftp_remote_folder}' nicht gefunden oder Zugriff verweigert.", is_error=True)
            messagebox.showwarning("SFTP Test", f"Verbindung erfolgreich, aber Remote-Ordner '{sftp_remote_folder}' nicht gefunden oder Zugriff verweigert.")
        
    except paramiko.AuthenticationException:
        log_message("SFTP-Authentifizierung fehlgeschlagen.", is_error=True)
        messagebox.showerror("SFTP Test", "Authentifizierung fehlgeschlagen.\nBitte Benutzername und Passwort überprüfen.")
    except paramiko.SSHException as sshException:
        log_message(f"SFTP SSH-Fehler: {sshException}", is_error=True)
        messagebox.showerror("SFTP Test", f"SSH-Fehler:\n{sshException}")
    except Exception as e:
        log_message(f"Allgemeiner SFTP-Verbindungsfehler: {e}", is_error=True)
        messagebox.showerror("SFTP Test", f"Ein Fehler ist beim Verbindungstest aufgetreten:\n{e}")
    finally:
        if sftp:
            sftp.close()
        if transport:
            transport.close()
        log_message("SFTP-Verbindung für Test geschlossen.")
        if progress_bar: 
            root_window_ref.after_idle(progress_bar.stop)
            root_window_ref.after_idle(progress_bar.pack_forget)
        if test_button_widget: 
            root_window_ref.after_idle(lambda: test_button_widget.config(state=tk.NORMAL))


# --- GUI Preview Window ---
class PreviewWindow(tk.Toplevel):
    def __init__(self, parent, pdf_files, payslips_csv_str, payslips_payslips_csv_str, zip_structure_str):
        super().__init__(parent)
        self.title("Vorschau der Verarbeitung")
        self.geometry("700x600") 
        self.transient(parent) 
        self.grab_set() 
        self.proceed = False 

        notebook = ttk.Notebook(self) 

        pdf_frame = ttk.Frame(notebook, padding=10)
        notebook.add(pdf_frame, text='PDF Dateien')
        tk.Label(pdf_frame, text="Folgende PDF-Dateien werden verarbeitet:", anchor="w").pack(fill="x")
        pdf_text = scrolledtext.ScrolledText(pdf_frame, height=10, wrap=tk.WORD, relief=tk.SUNKEN, borderwidth=1)
        pdf_text.insert(tk.END, "\n".join(pdf_files) if pdf_files else "Keine PDF-Dateien gefunden.")
        pdf_text.config(state=tk.DISABLED)
        pdf_text.pack(fill="both", expand=True, pady=5)

        payslips_csv_frame = ttk.Frame(notebook, padding=10)
        notebook.add(payslips_csv_frame, text='Pay Slips.csv Inhalt')
        tk.Label(payslips_csv_frame, text="Voraussichtlicher Inhalt von 'Pay Slips.csv' (Auszug):", anchor="w").pack(fill="x")
        payslips_csv_text = scrolledtext.ScrolledText(payslips_csv_frame, height=10, wrap=tk.NONE, relief=tk.SUNKEN, borderwidth=1) 
        payslips_csv_text.insert(tk.END, payslips_csv_str)
        payslips_csv_text.config(state=tk.DISABLED)
        payslips_csv_text.pack(fill="both", expand=True, pady=5)

        payslips_payslips_csv_frame = ttk.Frame(notebook, padding=10)
        notebook.add(payslips_payslips_csv_frame, text='Pay Slips-payslips.csv Inhalt')
        tk.Label(payslips_payslips_csv_frame, text="Voraussichtlicher Inhalt von 'Pay Slips-payslips.csv' (Auszug):", anchor="w").pack(fill="x")
        payslips_payslips_csv_text = scrolledtext.ScrolledText(payslips_payslips_csv_frame, height=10, wrap=tk.NONE, relief=tk.SUNKEN, borderwidth=1)
        payslips_payslips_csv_text.insert(tk.END, payslips_payslips_csv_str)
        payslips_payslips_csv_text.config(state=tk.DISABLED)
        payslips_payslips_csv_text.pack(fill="both", expand=True, pady=5)
        
        zip_frame = ttk.Frame(notebook, padding=10)
        notebook.add(zip_frame, text='ZIP Struktur')
        tk.Label(zip_frame, text="Voraussichtliche Struktur der ZIP-Datei:", anchor="w").pack(fill="x")
        zip_text = scrolledtext.ScrolledText(zip_frame, height=10, wrap=tk.WORD, relief=tk.SUNKEN, borderwidth=1)
        zip_text.insert(tk.END, zip_structure_str)
        zip_text.config(state=tk.DISABLED)
        zip_text.pack(fill="both", expand=True, pady=5)

        notebook.pack(fill="both", expand=True, padx=5, pady=5)

        button_frame = tk.Frame(self, pady=10)
        ttk.Button(button_frame, text="Fortfahren", command=self.on_proceed).pack(side=tk.LEFT, padx=10) 
        ttk.Button(button_frame, text="Abbrechen", command=self.on_cancel).pack(side=tk.RIGHT, padx=10) 
        button_frame.pack(fill="x")
        
        self.protocol("WM_DELETE_WINDOW", self.on_cancel)

    def on_proceed(self):
        self.proceed = True
        self.destroy()

    def on_cancel(self):
        self.proceed = False
        self.destroy()

# --- GUI Funktionen (GUI Functions) ---
log_text_area = None 
app_icon = None 
config_data = {} 
main_process_button_ref = None 

def log_message(message, is_error=False):
    if log_text_area: 
        log_text_area.config(state=tk.NORMAL)
        if is_error:
            log_text_area.insert(tk.END, f"FEHLER: {message}\n", "error")
        else:
            log_text_area.insert(tk.END, f"{message}\n")
        log_text_area.see(tk.END) 
        log_text_area.config(state=tk.DISABLED)
        log_text_area.update_idletasks() 
    else: 
        print(f"{'FEHLER: ' if is_error else ''}{message}")

def clear_log():
    """Löscht den Inhalt des Log-Fensters."""
    if log_text_area:
        log_text_area.config(state=tk.NORMAL)
        log_text_area.delete('1.0', tk.END)
        log_text_area.config(state=tk.DISABLED)
        log_message("Log-Fenster geleert.") # Logge die Aktion selbst

def save_log():
    """Speichert den aktuellen Inhalt des Log-Fensters in eine Textdatei."""
    if log_text_area:
        log_content = log_text_area.get('1.0', tk.END).strip()
        if not log_content:
            messagebox.showinfo("Log Speichern", "Das Log-Fenster ist leer.")
            return
        
        filepath = filedialog.asksaveasfilename(
            defaultextension=".txt",
            filetypes=[("Textdateien", "*.txt"), ("Alle Dateien", "*.*")],
            title="Log-Datei speichern unter..."
        )
        if filepath:
            try:
                with open(filepath, "w", encoding="utf-8") as f:
                    f.write(log_content)
                log_message(f"Log erfolgreich gespeichert in: {filepath}")
                messagebox.showinfo("Log Speichern", f"Log erfolgreich gespeichert als:\n{filepath}")
            except Exception as e:
                log_message(f"Fehler beim Speichern des Logs: {e}", is_error=True)
                messagebox.showerror("Log Speichern Fehler", f"Fehler beim Speichern des Logs:\n{e}")

def browse_file(entry_widget, title, filetypes, config_key):
    """Öffnet einen Dialog zur Auswahl einer Datei und speichert Pfad in Konfiguration."""
    """Opens a dialog to select a file and saves the path to configuration."""
    current_path = entry_widget.get()
    initial_dir = os.path.dirname(current_path) if current_path and os.path.isfile(current_path) else get_application_path()

    file_selected = filedialog.askopenfilename(
        title=title,
        initialdir=initial_dir,
        filetypes=filetypes
    )
    if file_selected:
        entry_widget.config(state=tk.NORMAL)
        entry_widget.delete(0, tk.END)
        entry_widget.insert(0, file_selected)
        entry_widget.config(state='readonly')
        config_data[config_key] = file_selected 
        save_config(config_data)

def browse_folder(entry_widget, config_key):
    """Öffnet Dialog für Ordnerauswahl und speichert Pfad in Konfiguration."""
    """Opens dialog for folder selection and saves path to configuration."""
    current_dir = entry_widget.get()
    initial_dir = current_dir if current_dir and os.path.isdir(current_dir) else get_application_path()
    
    folder_selected = filedialog.askdirectory(initialdir=initial_dir)
    if folder_selected:
        entry_widget.config(state=tk.NORMAL)
        entry_widget.delete(0, tk.END)
        entry_widget.insert(0, folder_selected)
        entry_widget.config(state='readonly')
        config_data[config_key] = folder_selected 
        save_config(config_data)


def toggle_split_fields_state(split_var, split_fields, manual_fields):
    """Aktiviert/Deaktiviert die Felder basierend auf der Split-Checkbox."""
    """Enables/Disables fields based on the split checkbox."""
    if split_var.get(): 
        for field in split_fields:
            if isinstance(field, (tk.Entry, ttk.Button, DateEntry)): 
                field.config(state=tk.NORMAL if isinstance(field, ttk.Button) else 'readonly') 
                if isinstance(field, DateEntry): field.config(state=tk.NORMAL) 
        for field in manual_fields:
            field.config(state=tk.DISABLED)
    else: 
        for field in split_fields:
            field.config(state=tk.DISABLED)
        for field in manual_fields:
            if isinstance(field, (tk.Entry, ttk.Button)): 
                field.config(state=tk.NORMAL if isinstance(field, ttk.Button) else 'readonly') 


def start_main_workflow_thread(*args): # Wrapper für Threading
    threading.Thread(target=start_main_workflow, args=args, daemon=True).start()

def start_main_workflow( 
    split_pdf_var, 
    split_source_pdf_entry, 
    split_rule_entry, 
    pcscmd_path_entry,
    input_folder_entry, 
    date_entry_widget, 
    output_folder_entry, 
    sftp_server_entry, 
    sftp_user_entry,   
    sftp_pass_entry,   
    sftp_remote_folder_entry, 
    upload_after_zip_var, 
    main_process_button, 
    root_window  
):
    global last_created_zip_filepath 
    last_created_zip_filepath = None 
    
    original_button_text = main_process_button["text"] 
    root_window_ref.after_idle(lambda: main_process_button.config(text="Verarbeite...", state=tk.DISABLED)) 
    if progress_bar:
        root_window_ref.after_idle(lambda: progress_bar.config(mode='indeterminate'))
        root_window_ref.after_idle(lambda: progress_bar.pack(fill=tk.X, pady=(0, 5), before=main_process_button_ref)) 
        root_window_ref.after_idle(progress_bar.start)


    global_effective_date_str = date_entry_widget.get_date().strftime("%m/%d/%Y")
    output_zip_folder = output_folder_entry.get()
    
    current_input_folder = input_folder_entry.get() 
    pcscmd_path = pcscmd_path_entry.get()
    split_rule_path = split_rule_entry.get()
    split_source_pdf_path = split_source_pdf_entry.get()

    sftp_server = sftp_server_entry.get()
    sftp_user = sftp_user_entry.get()
    sftp_password = sftp_pass_entry.get()
    sftp_remote_folder = sftp_remote_folder_entry.get()

    config_data["split_pdf_active"] = split_pdf_var.get()
    config_data["sftp_server"] = sftp_server
    config_data["sftp_user"] = sftp_user
    config_data["sftp_password"] = sftp_password 
    config_data["sftp_remote_folder"] = sftp_remote_folder
    config_data["upload_after_zip_creation"] = upload_after_zip_var.get() 
    save_config(config_data)

    log_message("Starte Verarbeitung (Split, ZIP, ggf. Upload)...")
    log_message(f"Globales Gültigkeitsdatum gewählt: {global_effective_date_str}")

    if not output_zip_folder : 
        messagebox.showerror("Fehler", "Bitte wählen Sie einen Ausgabeordner für die ZIP-Datei.")
        log_message("Kein Ausgabeordner für ZIP gewählt.", is_error=True)
        if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
        root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
    try:
        datetime.datetime.strptime(global_effective_date_str, "%m/%d/%Y")
    except ValueError: 
        messagebox.showerror("Fehler", "Ungültiges globales Datumsformat erhalten vom Date Picker.")
        log_message("Ungültiges globales Datumsformat vom Date Picker.", is_error=True)
        if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
        root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return

    temp_split_output_dir = None
    actual_input_pdf_folder_for_zip = current_input_folder 

    if split_pdf_var.get(): 
        log_message("PDF-Split-Modus aktiviert.")
        if not split_source_pdf_path or not os.path.isfile(split_source_pdf_path):
            messagebox.showerror("Fehler (Split)", "Bitte wählen Sie eine gültige grosse PDF-Quelldatei für den Split.")
            log_message("Ungültige grosse PDF-Quelldatei für Split.", is_error=True)
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        if not split_rule_path or not os.path.isfile(split_rule_path):
            messagebox.showerror("Fehler (Split)", "Bitte wählen Sie eine gültige A-PDF Split-Regeldatei (.rul).")
            log_message("Ungültige A-PDF Split-Regeldatei.", is_error=True)
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        if not pcscmd_path or not os.path.isfile(pcscmd_path):
            messagebox.showerror("Fehler (Split)", "Bitte wählen Sie den korrekten Pfad zur PCSCMD.exe.")
            log_message("Ungültiger Pfad zu PCSCMD.exe.", is_error=True)
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return

        try:
            temp_split_output_dir = tempfile.mkdtemp(prefix="pdf_split_out_")
            log_message(f"Temporäres Ausgabeverzeichnis für Split erstellt: {temp_split_output_dir}")

            abs_pcscmd_path = os.path.abspath(os.path.normpath(pcscmd_path))
            abs_split_source_pdf_path = os.path.abspath(os.path.normpath(split_source_pdf_path))
            abs_split_rule_path = os.path.abspath(os.path.normpath(split_rule_path))
            abs_temp_split_output_dir = os.path.abspath(os.path.normpath(temp_split_output_dir))

            command = [
                abs_pcscmd_path,
                abs_split_source_pdf_path,
                abs_split_rule_path,
                f"-O{abs_temp_split_output_dir}" 
            ]
            
            log_message(f"Normalisierte absolute Pfade für PCSCMD:")
            log_message(f"  PCSCMD: {abs_pcscmd_path}")
            log_message(f"  Source PDF: {abs_split_source_pdf_path}")
            log_message(f"  Rule File: {abs_split_rule_path}")
            log_message(f"  Output Dir: {abs_temp_split_output_dir}")
            log_message(f"Führe A-PDF Split aus (Befehl für Log): {' '.join(command)}") 
            
            startupinfo = subprocess.STARTUPINFO()
            startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            startupinfo.wShowWindow = subprocess.SW_HIDE
            
            pcscmd_working_directory = os.path.dirname(abs_pcscmd_path)

            process = subprocess.run(
                command, 
                capture_output=True, 
                text=True, 
                check=False, 
                startupinfo=startupinfo, 
                encoding='latin-1', 
                cwd=pcscmd_working_directory 
            )

            log_message(f"A-PDF Split stdout:\n{process.stdout}")
            if process.stderr:
                log_message(f"A-PDF Split stderr:\n{process.stderr}", is_error=True)

            if process.returncode == 0:
                log_message("A-PDF Split erfolgreich abgeschlossen.")
                actual_input_pdf_folder_for_zip = temp_split_output_dir 
            else:
                error_map = {
                    1: "Parameterfehler", 2: "Eingabedatei nicht gefunden oder ungültig", 3: "Regeldatei nicht gefunden oder ungültig",
                    4: "Fehler beim Laden der Eingabedatei (PDF)", 5: "Fehler beim Splitten der Dateien (evtl. Log-Datei Problem)",
                    6: "Fehler beim Erstellen des Ausgabeordners", 99: "Unbekannter Ausnahmefehler"
                } 
                error_message = error_map.get(process.returncode, f"Unbekannter Fehlercode: {process.returncode}")
                log_message(f"Fehler bei A-PDF Split: {error_message} (Code: {process.returncode})", is_error=True)
                messagebox.showerror("Fehler bei PDF-Split", f"A-PDF Content Splitter meldete einen Fehler:\n{error_message}\nPrüfen Sie das Log für Details.")
                if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
                root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL))
                if temp_split_output_dir and os.path.exists(temp_split_output_dir):
                    shutil.rmtree(temp_split_output_dir)
                return
        except Exception as e:
            log_message(f"Schwerwiegender Fehler während des PDF-Split-Prozesses: {e}", is_error=True)
            messagebox.showerror("Fehler", f"Ein Fehler ist während des PDF-Splittings aufgetreten:\n{e}")
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL))
            if temp_split_output_dir and os.path.exists(temp_split_output_dir): 
                shutil.rmtree(temp_split_output_dir)
            return
    else: 
        log_message("PDF-Split-Modus nicht aktiviert. Verwende direkt ausgewählten Ordner.")
        if not current_input_folder or not os.path.isdir(current_input_folder):
            messagebox.showerror("Fehler", "Bitte wählen Sie einen gültigen Eingabeordner für die einzelnen PDFs.")
            log_message("Ungültiger Eingabeordner für einzelne PDFs.", is_error=True)
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        actual_input_pdf_folder_for_zip = current_input_folder


    work_dir = None 
    created_zip_filepath_local = None 
    try:
        pdf_files_info_simple = [] 
        pdf_files_info_full = []   
        pdf_filenames_for_preview = [] 
        pdf_count = 0 

        if not os.path.isdir(actual_input_pdf_folder_for_zip) or not os.listdir(actual_input_pdf_folder_for_zip):
            log_message(f"Der Ordner '{actual_input_pdf_folder_for_zip}' ist leer oder existiert nicht nach dem Split-Prozess (falls aktiviert).", is_error=True)
            messagebox.showerror("Fehler", "Keine PDF-Dateien im Verarbeitungsordner gefunden.")
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return


        for filename in os.listdir(actual_input_pdf_folder_for_zip):
            if filename.lower().endswith(".pdf"):
                pdf_filenames_for_preview.append(filename)
                person_id, doc_name_base, specific_date_str = extract_payslip_info(filename)
                if person_id and doc_name_base: 
                    pdf_files_info_simple.append((person_id, doc_name_base, specific_date_str))
                    pdf_files_info_full.append((person_id, doc_name_base, filename, specific_date_str))
                    pdf_count += 1
        
        if pdf_count == 0:
            log_message(f"Keine PDF-Dateien konnten erfolgreich für die CSV-Erstellung verarbeitet werden im Ordner '{actual_input_pdf_folder_for_zip}'. Bitte prüfen Sie die Dateinamen und Log-Warnungen.", is_error=True)
            messagebox.showwarning("Warnung", "Keine PDF-Dateien konnten für die CSV-Erstellung verarbeitet werden. Prüfen Sie das Log.")
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        log_message(f"{pdf_count} PDF-Dateien erfolgreich für die CSV-Erstellung analysiert.")

        ps_h1, ps_h2, ps_data = prepare_pay_slips_csv_data(pdf_files_info_simple, global_effective_date_str)
        psp_h1, psp_h2, psp_data = prepare_pay_slips_payslips_csv_data(pdf_files_info_full, global_effective_date_str)
        
        payslips_csv_preview_str = format_csv_data_for_preview(ps_h1, ps_h2, ps_data)
        payslips_payslips_csv_preview_str = format_csv_data_for_preview(psp_h1, psp_h2, psp_data)

        zip_structure_list = [
            "import.properties",
            "import_sequence.csv",
            "Pay Slips.csv",
            "Pay Slips-payslips.csv",
            "attachments/"
        ]
        for _, _, fname_processed, _ in pdf_files_info_full: 
            zip_structure_list.append(f"  {fname_processed}")
        zip_structure_preview_str = "\n".join(zip_structure_list)

        preview = PreviewWindow(root_window, pdf_filenames_for_preview, payslips_csv_preview_str, payslips_payslips_csv_preview_str, zip_structure_preview_str)
        root_window.wait_window(preview)

        if not preview.proceed:
            log_message("Verarbeitung vom Benutzer abgebrochen.", is_error=True)
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        
        log_message("Benutzer hat Fortfahren gewählt. Erstelle Dateien...")

        if not os.path.isdir(output_zip_folder):
            try:
                os.makedirs(output_zip_folder, exist_ok=True)
                log_message(f"Ausgabeordner '{output_zip_folder}' erstellt.")
            except OSError as e:
                messagebox.showerror("Fehler", f"Ausgabeordner konnte nicht erstellt werden:\n{output_zip_folder}\n{e}")
                log_message(f"Ausgabeordner konnte nicht erstellt werden: {output_zip_folder}. Fehler: {e}", is_error=True)
                if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
                root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        
        work_dir = tempfile.mkdtemp(prefix="sftp_zip_gui_") 
        log_message(f"Temporäres Arbeitsverzeichnis für ZIP erstellt: '{work_dir}'")
        attachments_dir = os.path.join(work_dir, "attachments")
        os.makedirs(attachments_dir)
        log_message(f"Temporärer 'attachments'-Ordner für ZIP erstellt: '{attachments_dir}'")

        for _, _, pdf_filename, _ in pdf_files_info_full: 
             source_pdf_path = os.path.join(actual_input_pdf_folder_for_zip, pdf_filename) 
             if os.path.exists(source_pdf_path):
                 try:
                     shutil.copy(source_pdf_path, attachments_dir)
                 except IOError as e:
                     log_message(f"Fehler beim Kopieren von '{pdf_filename}' in ZIP-temp: {e}. Überspringe.", is_error=True)
             else:
                 log_message(f"Warnung: PDF-Datei '{source_pdf_path}' nicht gefunden zum Kopieren für ZIP.", is_error=True)

        
        if not write_csv_to_file(os.path.join(work_dir, "Pay Slips.csv"), ps_h1, ps_h2, ps_data):
             if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
             root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        if not write_csv_to_file(os.path.join(work_dir, "Pay Slips-payslips.csv"), psp_h1, psp_h2, psp_data):
             if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
             root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        if not create_import_properties(work_dir): 
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        if not create_import_sequence_csv(work_dir): 
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        
        created_zip_filepath_local = create_zip_archive(work_dir, output_zip_folder) 
                                                                               
        if not created_zip_filepath_local: 
            if progress_bar: root_window_ref.after_idle(progress_bar.stop); root_window_ref.after_idle(progress_bar.pack_forget)
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)); return
        
        last_created_zip_filepath = created_zip_filepath_local 
        log_message("ZIP-Erstellung erfolgreich abgeschlossen.")

        if upload_after_zip_var.get():
            log_message("Automatischer SFTP-Upload wird gestartet...")
            sftp_server = sftp_server_entry.get()
            sftp_user = sftp_user_entry.get()
            sftp_password = sftp_pass_entry.get()
            sftp_remote_folder = sftp_remote_folder_entry.get()

            if not sftp_server or not sftp_user or not sftp_password or not sftp_remote_folder:
                messagebox.showwarning("SFTP Upload Übersprungen", "SFTP-Zugangsdaten für automatischen Upload unvollständig.")
                log_message("Automatischer SFTP-Upload übersprungen: Zugangsdaten unvollständig.", is_error=True)
            else:
                # Starte Upload im Thread, übergebe den Haupt-Button zum Re-Aktivieren
                # Start upload in thread, pass the main button to re-enable
                threading.Thread(target=upload_sftp_threaded, 
                                 args=(last_created_zip_filepath, sftp_server, sftp_user, sftp_password, sftp_remote_folder, main_process_button), 
                                 daemon=True).start()
                return # Der Button wird vom Thread wieder aktiviert
                       # The button will be re-enabled by the thread
        else:
            log_message("Automatischer SFTP-Upload nicht aktiviert.")


    except Exception as e:
        log_message(f"Ein unerwarteter Fehler ist aufgetreten: {e}", is_error=True)
        messagebox.showerror("Schwerwiegender Fehler", f"Ein unerwarteter Fehler ist aufgetreten:\n{e}")
    finally:
        if work_dir and os.path.exists(work_dir): 
            try:
                shutil.rmtree(work_dir)
                log_message(f"Temporäres Arbeitsverzeichnis für ZIP '{work_dir}' wurde entfernt.")
            except Exception as e:
                log_message(f"Warnung: Temporäres Arbeitsverzeichnis für ZIP '{work_dir}' konnte nicht entfernt werden: {e}", is_error=True)
        
        if temp_split_output_dir and os.path.exists(temp_split_output_dir): 
            try:
                shutil.rmtree(temp_split_output_dir)
                log_message(f"Temporäres Ausgabeverzeichnis für Split '{temp_split_output_dir}' wurde entfernt.")
            except Exception as e:
                log_message(f"Warnung: Temporäres Ausgabeverzeichnis für Split '{temp_split_output_dir}' konnte nicht entfernt werden: {e}", is_error=True)
        
        if not (upload_after_zip_var.get() and last_created_zip_filepath): 
            if progress_bar: 
                root_window_ref.after_idle(progress_bar.stop)
                root_window_ref.after_idle(progress_bar.pack_forget) 
            root_window_ref.after_idle(lambda: main_process_button.config(text=original_button_text, state=tk.NORMAL)) 

def handle_sftp_test_thread(*args): # Wrapper für Threading
    threading.Thread(target=test_sftp_connection_threaded, args=args, daemon=True).start()

def handle_sftp_test(sftp_server_entry, sftp_user_entry, sftp_pass_entry, sftp_remote_folder_entry, test_button_widget):
    """Behandelt den SFTP-Verbindungstest."""
    """Handles the SFTP connection test."""
    sftp_server = sftp_server_entry.get()
    sftp_user = sftp_user_entry.get()
    sftp_password = sftp_pass_entry.get()
    sftp_remote_folder = sftp_remote_folder_entry.get()

    config_data["sftp_server"] = sftp_server
    config_data["sftp_user"] = sftp_user
    config_data["sftp_password"] = sftp_password 
    config_data["sftp_remote_folder"] = sftp_remote_folder
    save_config(config_data)

    if not sftp_server or not sftp_user or not sftp_password: 
        messagebox.showwarning("SFTP Test Übersprungen", "SFTP Server, Benutzername oder Passwort fehlen für den Test.")
        log_message("SFTP-Test übersprungen: Server, Benutzer oder Passwort fehlen.", is_error=True)
        if test_button_widget: test_button_widget.config(state=tk.NORMAL) 
        return 
    
    handle_sftp_test_thread(sftp_server, sftp_user, sftp_password, sftp_remote_folder, test_button_widget)


def create_gui():
    global log_text_area, app_icon, config_data, progress_bar, root_window_ref, main_process_button_ref
    root = tk.Tk()
    root_window_ref = root 
    root.title("SuccessFactors SFTP ZIP Generator")
    root.minsize(600, 650) 

    config_data = load_config() 

    icon_path = get_icon_file_path()
    if os.path.exists(icon_path):
        try:
            app_icon = tk.PhotoImage(file=icon_path) 
            root.iconphoto(False, app_icon)
        except tk.TclError as e:
            print(f"Warnung: Icon '{icon_path}' konnte nicht geladen werden: {e}.")
    else:
        print(f"Warnung: Icon-Datei '{icon_path}' nicht gefunden.")

    main_frame = tk.Frame(root, padx=10, pady=10)
    main_frame.pack(fill=tk.BOTH, expand=True)
    
    # main_frame.columnconfigure(0, weight=1) # Entfernt, da main_frame pack verwendet

    # --- Tab-Steuerung erstellen ---
    # Create tab control
    notebook = ttk.Notebook(main_frame)
    
    # Tab 1: Datenquelle & ZIP
    # Tab 1: Data Source & ZIP
    tab_data_zip = ttk.Frame(notebook, padding=(10,10))
    notebook.add(tab_data_zip, text=' 1. Datenquelle & ZIP ')
    tab_data_zip.columnconfigure(1, weight=1) 

    # PDF Split Sektion in Tab 1
    # PDF Split section in Tab 1
    split_frame = ttk.LabelFrame(tab_data_zip, text="PDF-Split Optionen (A-PDF Content Splitter)", padding=(10,5))
    split_frame.grid(row=0, column=0, columnspan=3, sticky=tk.EW, pady=(0,10)) 
    split_frame.columnconfigure(1, weight=1) 

    split_pdf_var = tk.BooleanVar(value=config_data.get("split_pdf_active", True)) 
                                                                                   
    pcscmd_path_entry = tk.Entry(split_frame, width=50, state='readonly') 
    split_rule_entry = tk.Entry(split_frame, width=50, state='readonly')
    split_source_pdf_entry = tk.Entry(split_frame, width=50, state='readonly')
    
    pcscmd_browse_button = ttk.Button(split_frame, text="Durchsuchen...", 
                                     command=lambda: browse_file(pcscmd_path_entry, "PCSCMD.exe auswählen", [("Executable", "*.exe")], "pcscmd_path"))
    rule_browse_button = ttk.Button(split_frame, text="Durchsuchen...", 
                                   command=lambda: browse_file(split_rule_entry, "A-PDF Regeldatei auswählen", [("Regeldatei", "*.rul")], "split_rule_path"))
    source_browse_button = ttk.Button(split_frame, text="Durchsuchen...", 
                                     command=lambda: browse_file(split_source_pdf_entry, "Grosse PDF-Quelldatei auswählen", [("PDF-Dateien", "*.pdf")], "split_source_pdf_path"))
    
    standard_input_frame = ttk.LabelFrame(tab_data_zip, text="Alternative: Manuelle Auswahl (falls kein Split oben)", padding=(10,5))
    standard_input_frame.grid(row=1, column=0, columnspan=3, sticky=tk.EW, pady=(0,10))
    standard_input_frame.columnconfigure(1, weight=1) 

    input_folder_entry = tk.Entry(standard_input_frame, width=50, state='readonly') 
    input_folder_browse_button = ttk.Button(standard_input_frame, text="Durchsuchen...", 
                                           command=lambda: browse_folder(input_folder_entry, "input_folder"))

    split_fields_to_toggle = [
        pcscmd_path_entry, pcscmd_browse_button,
        split_rule_entry, rule_browse_button,
        split_source_pdf_entry, source_browse_button
    ]
    manual_input_fields_to_toggle = [input_folder_entry, input_folder_browse_button]
    
    split_pdf_checkbox = ttk.Checkbutton(split_frame, text="Grosse PDF-Datei zuerst splitten?", variable=split_pdf_var, 
                                        command=lambda: toggle_split_fields_state(split_pdf_var, split_fields_to_toggle, manual_input_fields_to_toggle)) 
    split_pdf_checkbox.grid(row=0, column=0, columnspan=3, sticky=tk.W, pady=(0,5)) 

    tk.Label(split_frame, text="Pfad zu PCSCMD.exe:").grid(row=1, column=0, sticky=tk.W, padx=(0,5), pady=(0,2))
    pcscmd_path_entry.grid(row=1, column=1, sticky=tk.EW, pady=(0,5)) 
    pcscmd_browse_button.grid(row=1, column=2, sticky=tk.W, padx=(5,0), pady=(0,5)) 

    tk.Label(split_frame, text="A-PDF Split-Regeldatei (.rul):").grid(row=2, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    split_rule_entry.grid(row=2, column=1, sticky=tk.EW, pady=(0,5))
    rule_browse_button.grid(row=2, column=2, sticky=tk.W, padx=(5,0), pady=(0,5))

    tk.Label(split_frame, text="Grosse PDF-Quelldatei (für Split):").grid(row=3, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    split_source_pdf_entry.grid(row=3, column=1, sticky=tk.EW, pady=(0,5))
    source_browse_button.grid(row=3, column=2, sticky=tk.W, padx=(5,0), pady=(0,5))
    
    tk.Label(standard_input_frame, text="Ordner mit (einzelnen) PDFs:").grid(row=0, column=0, sticky=tk.W, padx=(0,5), pady=(0,2))
    input_folder_entry.grid(row=0, column=1, sticky=tk.EW, pady=(0,5)) 
    input_folder_browse_button.grid(row=0, column=2, sticky=tk.W, padx=(5,0), pady=(0,5)) 
    
    common_fields_frame = ttk.LabelFrame(tab_data_zip, text="Allgemeine ZIP-Einstellungen", padding=(10,5)) 
    common_fields_frame.grid(row=2, column=0, columnspan=3, sticky=tk.EW, pady=(10,10))
    common_fields_frame.columnconfigure(1, weight=1) 

    tk.Label(common_fields_frame, text="Globales Gültigkeitsdatum (MM/TT/JJJJ):").grid(row=0, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    date_entry = DateEntry(common_fields_frame, width=12, background='darkblue',
                           foreground='white', borderwidth=2, 
                           date_pattern='mm/dd/y', 
                           firstweekday='monday',
                           showweeknumbers=False) 
    date_entry.grid(row=0, column=1, sticky=tk.W, pady=(0,5)) 
    date_entry.set_date(datetime.date.today())

    tk.Label(common_fields_frame, text="Ausgabeordner für ZIP-Datei:").grid(row=1, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    output_folder_entry = tk.Entry(common_fields_frame, width=50, state='readonly') 
    output_folder_entry.grid(row=1, column=1, sticky=tk.EW, pady=(0,5))
    ttk.Button(common_fields_frame, text="Durchsuchen...", 
              command=lambda: browse_folder(output_folder_entry, "output_folder")).grid(row=1, column=2, sticky=tk.W, padx=(5,0), pady=(0,5))

    upload_after_zip_var = tk.BooleanVar(value=config_data.get("upload_after_zip_creation", True))
    upload_after_zip_checkbox = ttk.Checkbutton(common_fields_frame, text="SFTP-Upload direkt nach ZIP-Erstellung durchführen?", variable=upload_after_zip_var)
    upload_after_zip_checkbox.grid(row=2, column=0, columnspan=3, sticky=tk.W, pady=(10,5))


    # Tab 2: SFTP Upload
    # Tab 2: SFTP Upload
    tab_sftp = ttk.Frame(notebook, padding=(10,10))
    notebook.add(tab_sftp, text=' 2. SFTP Upload ')
    tab_sftp.columnconfigure(1, weight=1) 

    sftp_frame = ttk.LabelFrame(tab_sftp, text="SFTP Upload Optionen", padding=(10,5))
    sftp_frame.grid(row=0, column=0, columnspan=3, sticky=tk.EW, pady=(0,10)) 
    sftp_frame.columnconfigure(1, weight=1) 

    tk.Label(sftp_frame, text="SFTP Server:").grid(row=1, column=0, sticky=tk.W, padx=(0,5), pady=(0,2)) # Startet bei row=1
    sftp_server_entry = tk.Entry(sftp_frame, width=50)
    sftp_server_entry.grid(row=1, column=1, columnspan=2, sticky=tk.EW, pady=(0,5))
    sftp_server_entry.insert(0, config_data.get("sftp_server", "sftp74.sapsf.eu"))

    tk.Label(sftp_frame, text="SFTP Benutzername:").grid(row=2, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    sftp_user_entry = tk.Entry(sftp_frame, width=50)
    sftp_user_entry.grid(row=2, column=1, columnspan=2, sticky=tk.EW, pady=(0,5))
    sftp_user_entry.insert(0, config_data.get("sftp_user", "sefarag-stage"))

    tk.Label(sftp_frame, text="SFTP Passwort:").grid(row=3, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    sftp_pass_entry = tk.Entry(sftp_frame, width=50, show="*")
    sftp_pass_entry.grid(row=3, column=1, columnspan=2, sticky=tk.EW, pady=(0,5))
    sftp_pass_entry.insert(0, config_data.get("sftp_password", ""))

    tk.Label(sftp_frame, text="SFTP Zielordner (Remote):").grid(row=4, column=0, sticky=tk.W, padx=(0,5), pady=(5,2))
    sftp_remote_folder_entry = tk.Entry(sftp_frame, width=50)
    sftp_remote_folder_entry.grid(row=4, column=1, columnspan=2, sticky=tk.EW, pady=(0,5))
    sftp_remote_folder_entry.insert(0, config_data.get("sftp_remote_folder", "/incoming/PaySlips_MonosuisseAG"))
    
    sftp_test_button = ttk.Button(sftp_frame, text="SFTP Verbindung Testen", 
                                 command=lambda: handle_sftp_test_thread( 
                                     sftp_server_entry, sftp_user_entry, sftp_pass_entry, 
                                     sftp_remote_folder_entry, sftp_test_button
                                 ))
    sftp_test_button.grid(row=5, column=0, columnspan=3, pady=(10,10), sticky=tk.EW) 

    # Tab 3: Log
    # Tab 3: Log
    tab_log = ttk.Frame(notebook, padding=(10,10))
    notebook.add(tab_log, text=' Log-Nachrichten ')
    # tab_log.columnconfigure(0, weight=1) # Entfernt
    # tab_log.rowconfigure(0, weight=1)    # Entfernt

    log_buttons_frame = tk.Frame(tab_log)
    log_buttons_frame.pack(fill=tk.X, pady=(0,5))

    clear_log_button = ttk.Button(log_buttons_frame, text="Log löschen", command=clear_log)
    clear_log_button.pack(side=tk.LEFT, padx=(0,5))
    save_log_button = ttk.Button(log_buttons_frame, text="Log speichern als...", command=save_log)
    save_log_button.pack(side=tk.LEFT)

    log_text_area = scrolledtext.ScrolledText(tab_log, width=70, height=20, state=tk.DISABLED, wrap=tk.WORD, relief=tk.SUNKEN, borderwidth=1) 
    log_text_area.pack(expand=True, fill='both', pady=(0,5)) 
    log_text_area.tag_config("error", foreground="red")

    # Tab 4: Hilfe & Info
    # Tab 4: Help & Info
    tab_help = ttk.Frame(notebook, padding=(10,10))
    notebook.add(tab_help, text=' Hilfe & Info ')
    # tab_help.columnconfigure(0, weight=1) # Entfernt
    # tab_help.rowconfigure(0, weight=1)    # Entfernt

    help_text_content = """Willkommen beim SFTP ZIP Generator!

Kurzanleitung:
1.  **Tab "1. Datenquelle & ZIP":**
    * **PDF-Split Optionen:** Wenn Sie eine grosse PDF-Datei haben, die einzelne Lohnabrechnungen enthält, aktivieren Sie "Grosse PDF-Datei zuerst splitten?".
        * Geben Sie den Pfad zur `PCSCMD.exe` (von A-PDF Content Splitter), Ihrer `.rul`-Regeldatei und der grossen PDF-Quelldatei an.
    * **Alternative: Manuelle Auswahl:** Wenn Ihre Lohnabrechnungen bereits als einzelne PDF-Dateien vorliegen, deaktivieren Sie die Split-Option und wählen Sie den Ordner mit diesen PDFs aus.
    * **Allgemeine ZIP-Einstellungen:**
        * Wählen Sie das globale Gültigkeitsdatum. Für Februar-Dateien wird das Datum automatisch auf Monatsende gesetzt, wenn "Februar" und ein Jahr im Dateinamen erkannt werden.
        * Wählen Sie den Ausgabeordner für die zu erstellende ZIP-Datei.
        * Aktivieren Sie "SFTP-Upload direkt nach ZIP-Erstellung durchführen?", wenn die erstellte ZIP-Datei automatisch hochgeladen werden soll.

2.  **Tab "2. SFTP Upload":**
    * Konfigurieren Sie hier Ihre SFTP-Serverdaten (Server, Benutzer, Passwort, Zielordner).
    * Nutzen Sie "SFTP Verbindung Testen", um Ihre Eingaben zu prüfen.

3.  **Prozess Starten:**
    * Klicken Sie auf den Button "Prozess Starten (Split, ZIP, ggf. Upload)" unterhalb der Tabs.
    * Eine Vorschau der zu erstellenden Daten wird angezeigt. Prüfen Sie diese und klicken Sie auf "Fortfahren".

4.  **Tab "Log-Nachrichten":**
    * Hier sehen Sie detaillierte Informationen zum Ablauf und eventuelle Fehlermeldungen.
    * Sie können das Log löschen oder als Textdatei speichern.

Voraussetzungen:
* Python 3.x
* Bibliotheken: `tkcalendar`, `paramiko` (Installation via `pip install tkcalendar paramiko`)
* Für PDF-Split: A-PDF Content Splitter (`PCSCMD.exe`) und eine gültige `.rul`-Datei.

Dateinamen der PDFs:
Das Skript versucht, die Personal-ID aus den PDF-Dateinamen zu extrahieren. Folgende Muster werden erkannt:
* `BeliebigerText_ID_WeitererText.pdf` (z.B. `Lohn_12345_Mai2025.pdf`)
* `BeliebigerText_ID.pdf` (z.B. `Report_12345.pdf`)
* `ID_BeliebigerText.pdf` (z.B. `12345_LohnMai2025.pdf`)

Bei Problemen prüfen Sie bitte die Log-Meldungen und die eingestellten Pfade.
"""
    help_text_widget = scrolledtext.ScrolledText(tab_help, wrap=tk.WORD, relief=tk.FLAT, state=tk.NORMAL, font=("Arial", 10))
    help_text_widget.insert(tk.END, help_text_content)
    help_text_widget.config(state=tk.DISABLED) 
    help_text_widget.pack(expand=True, fill='both')


    notebook.pack(expand=True, fill='both', pady=(0,10)) 

    # --- Fortschrittsbalken ---
    # Progress bar
    progress_bar = ttk.Progressbar(main_frame, orient="horizontal", length=300, mode="determinate")
    
    # --- Haupt-Aktionsbutton ---
    # Main action button
    style = ttk.Style()
    style.configure("Accent.TButton", font=('Arial', 10, 'bold'), padding=(10,5))

    main_process_button = ttk.Button(main_frame, text="Prozess Starten (Split, ZIP, ggf. Upload)", 
                             style="Accent.TButton", 
                             command=lambda: start_main_workflow_thread( 
                                 split_pdf_var, split_source_pdf_entry, split_rule_entry, pcscmd_path_entry,
                                 input_folder_entry, date_entry, output_folder_entry, 
                                 sftp_server_entry, sftp_user_entry, sftp_pass_entry, sftp_remote_folder_entry, 
                                 upload_after_zip_var, 
                                 main_process_button, 
                                 root 
                                 ))
    main_process_button.pack(fill=tk.X, pady=(5,10)) 
    main_process_button_ref = main_process_button 
    
    
    # --- Konfiguration beim Start laden und Felder setzen ---
    # Load configuration at start and set fields
    if config_data.get("input_folder") and os.path.isdir(config_data["input_folder"]): 
        input_folder_entry.config(state=tk.NORMAL)
        input_folder_entry.insert(0, config_data["input_folder"])
        input_folder_entry.config(state='readonly')
    if config_data.get("output_folder") and os.path.isdir(config_data["output_folder"]): 
        output_folder_entry.config(state=tk.NORMAL)
        output_folder_entry.insert(0, config_data["output_folder"])
        output_folder_entry.config(state='readonly')
    if config_data.get("pcscmd_path") and os.path.isfile(config_data["pcscmd_path"]): 
        pcscmd_path_entry.config(state=tk.NORMAL)
        pcscmd_path_entry.insert(0, config_data["pcscmd_path"])
        pcscmd_path_entry.config(state='readonly')
    if config_data.get("split_rule_path") and os.path.isfile(config_data["split_rule_path"]): 
        split_rule_entry.config(state=tk.NORMAL)
        split_rule_entry.insert(0, config_data["split_rule_path"])
        split_rule_entry.config(state='readonly')
    if config_data.get("split_source_pdf_path") and os.path.isfile(config_data["split_source_pdf_path"]): 
        split_source_pdf_entry.config(state=tk.NORMAL)
        split_source_pdf_entry.insert(0, config_data["split_source_pdf_path"])
        split_source_pdf_entry.config(state='readonly')
    
    toggle_split_fields_state(split_pdf_var, split_fields_to_toggle, manual_input_fields_to_toggle)


    if any(value for key, value in config_data.items() if key not in ["split_pdf_active", "upload_after_zip_creation"]): 
        log_message(f"Konfiguration geladen von: {get_config_file_path()}")
    else:
        log_message(f"Keine Konfigurationsdatei gefunden oder Pfade leer: {get_config_file_path()}")


    root.mainloop()

if __name__ == "__main__":
    create_gui()