#!/bin/bash

# ===================================================================
# MYP Druckerverwaltung - KONSOLIDIERTES SETUP-SKRIPT
# Kombiniert alle Installationsfunktionen in einer einzigen Datei
# Optimiert für Debian/Linux (Raspberry Pi OS) - KEIN Windows-Support
# HTTPS auf Port 443 mit automatischer SSL-Zertifikat-Generierung
# Kiosk-Modus mit Chromium-Autostart ohne Desktop-Environment
# Version: 4.0.0
# ===================================================================

set -euo pipefail

# =========================== GLOBALE KONFIGURATION ===========================
readonly APP_NAME="MYP Druckerverwaltung"
readonly APP_VERSION="4.0.0"
readonly APP_DIR="/opt/myp"
readonly HTTPS_SERVICE_NAME="myp-https"
readonly KIOSK_SERVICE_NAME="myp-kiosk"
readonly WATCHDOG_SERVICE_NAME="kiosk-watchdog"
readonly WATCHDOG_PYTHON_SERVICE_NAME="kiosk-watchdog-python"
readonly FIREWALL_SERVICE_NAME="myp-firewall"
readonly KIOSK_USER="kiosk"
readonly CURRENT_DIR="$(pwd)"
readonly INSTALL_LOG="/var/log/myp-install.log"
readonly HTTPS_PORT="443"
readonly HTTPS_URL="https://localhost:${HTTPS_PORT}"
readonly SYSTEMD_DIR="$CURRENT_DIR/systemd"
readonly SYSTEM_SYSTEMD_DIR="/etc/systemd/system"

# Farben für Ausgabe
readonly RED='\033[0;31m'
readonly GREEN='\033[0;32m'
readonly YELLOW='\033[1;33m'
readonly BLUE='\033[0;34m'
readonly PURPLE='\033[0;35m'
readonly CYAN='\033[0;36m'
readonly NC='\033[0m'

# =========================== LOGGING-FUNKTIONEN ===========================
log() {
    echo -e "${GREEN}[$(date '+%Y-%m-%d %H:%M:%S')] $1${NC}" | tee -a "$INSTALL_LOG"
}

error() {
    echo -e "${RED}[FEHLER] $1${NC}" | tee -a "$INSTALL_LOG"
    exit 1
}

warning() {
    echo -e "${YELLOW}[WARNUNG] $1${NC}" | tee -a "$INSTALL_LOG"
}

info() {
    echo -e "${BLUE}[INFO] $1${NC}" | tee -a "$INSTALL_LOG"
}

progress() {
    echo -e "${PURPLE}[FORTSCHRITT] $1${NC}" | tee -a "$INSTALL_LOG"
}

success() {
    echo -e "${CYAN}[ERFOLG] $1${NC}" | tee -a "$INSTALL_LOG"
}

# =========================== SYSTEM-VALIDIERUNG ===========================
check_root() {
    if [ "$EUID" -ne 0 ]; then
        error "Dieses Skript muss als Root ausgeführt werden: sudo $0"
    fi
    export PATH="/usr/sbin:/sbin:/usr/bin:/bin:/usr/local/bin:$PATH"
    log "✅ Root-Berechtigung bestätigt"
}

check_debian_system() {
    if [ ! -f /etc/debian_version ]; then
        error "Dieses Skript ist nur für Debian/Raspbian-Systeme geeignet!"
    fi
    
    local debian_version=$(cat /etc/debian_version 2>/dev/null || echo "Unbekannt")
    log "✅ Debian/Raspbian-System erkannt (Version: $debian_version)"
    
    # Prüfe auf Raspberry Pi
    if [ -f /proc/device-tree/model ]; then
        local pi_model=$(cat /proc/device-tree/model 2>/dev/null || echo "Unbekannt")
        info "Raspberry Pi Modell: $pi_model"
    fi
}

check_internet_connection() {
    progress "Prüfe Internetverbindung..."
    
    local test_urls=("8.8.8.8" "1.1.1.1" "google.com")
    local connection_ok=false
    
    for url in "${test_urls[@]}"; do
        if ping -c 1 -W 3 "$url" >/dev/null 2>&1; then
            connection_ok=true
            break
        fi
    done
    
    if [ "$connection_ok" = true ]; then
        log "✅ Internetverbindung verfügbar"
    else
        warning "⚠️ Keine Internetverbindung - Installation könnte fehlschlagen"
    fi
}

# =========================== SYSTEM-VORBEREITUNG ===========================
update_system() {
    log "=== SYSTEM-UPDATE ==="
    
    progress "Aktualisiere Paketlisten..."
    apt-get update -y || error "APT Update fehlgeschlagen"
    
    progress "Führe System-Upgrade durch..."
    apt-get upgrade -y || warning "System-Upgrade teilweise fehlgeschlagen"
    
    progress "Installiere grundlegende System-Tools..."
    apt-get install -y \
        curl \
        wget \
        git \
        nano \
        htop \
        rsync \
        unzip \
        sudo \
        systemd \
        ca-certificates \
        gnupg \
        lsb-release \
        apt-transport-https \
        software-properties-common \
        bc \
        || error "Grundlegende Tools Installation fehlgeschlagen"
    
    log "✅ System-Update abgeschlossen"
}

# =========================== DESKTOP-ENVIRONMENT ENTFERNUNG ===========================
remove_desktop_environments() {
    log "=== ENTFERNE DESKTOP ENVIRONMENTS FÜR KIOSK-MODUS ==="
    
    progress "Stoppe alle Desktop-Services..."
    local desktop_services=("lightdm" "gdm3" "sddm" "xdm" "nodm")
    
    for service in "${desktop_services[@]}"; do
        systemctl stop "$service" 2>/dev/null || true
        systemctl disable "$service" 2>/dev/null || true
    done
    
    progress "Entferne Desktop-Pakete vollständig..."
    
    # Raspberry Pi OS Desktop-Pakete
    apt-get remove --purge -y \
        raspberrypi-ui-mods \
        pi-package \
        desktop-base \
        lxde* \
        xfce4* \
        gnome* \
        kde* \
        mate* \
        cinnamon* \
        openbox \
        pcmanfm \
        file-manager* \
        task-lxde-desktop \
        task-xfce-desktop \
        task-gnome-desktop \
        task-kde-desktop \
        2>/dev/null || true
    
    # Display Manager entfernen
    apt-get remove --purge -y \
        lightdm* \
        gdm3* \
        sddm* \
        xdm* \
        nodm* \
        2>/dev/null || true
    
    # Unnötige Anwendungen entfernen
    apt-get remove --purge -y \
        libreoffice* \
        thunderbird* \
        firefox* \
        vlc* \
        gimp* \
        scratch* \
        minecraft-pi \
        sonic-pi \
        2>/dev/null || true
    
    # Aufräumen
    apt-get autoremove --purge -y
    apt-get autoclean
    
    log "✅ Desktop Environments vollständig entfernt"
}

# =========================== MINIMALE X11-UMGEBUNG ===========================
install_minimal_x11() {
    log "=== INSTALLIERE MINIMALE X11-UMGEBUNG FÜR KIOSK ==="
    
    progress "Installiere minimale X11-Pakete..."
    apt-get install -y \
        xserver-xorg-core \
        xserver-xorg-input-all \
        xserver-xorg-video-fbdev \
        xserver-xorg-video-vesa \
        xinit \
        x11-xserver-utils \
        xdotool \
        unclutter \
        openbox \
        || error "X11 Installation fehlgeschlagen"
    
    # Browser-Installation mit Fallback-Mechanismus
    progress "Installiere Browser für Kiosk-Modus..."
    local browser_installed=false
    
    # Versuche Chromium zu installieren
    if apt-get install -y chromium 2>/dev/null; then
        log "✅ Chromium erfolgreich installiert"
        browser_installed=true
    elif apt-get install -y chromium-browser 2>/dev/null; then
        log "✅ Chromium-Browser erfolgreich installiert"
        browser_installed=true
    elif apt-get install -y firefox-esr 2>/dev/null; then
        warning "⚠️ Chromium nicht verfügbar - Firefox ESR als Fallback installiert"
        browser_installed=true
    fi
    
    if [ "$browser_installed" = false ]; then
        error "❌ Kein Browser verfügbar (chromium, chromium-browser, firefox-esr)"
    fi
    
    log "✅ Minimale X11-Umgebung installiert"
}

# =========================== KIOSK-BENUTZER MANAGEMENT ===========================
create_kiosk_user() {
    log "=== KIOSK-BENUTZER SETUP ==="
    
    if ! id "$KIOSK_USER" &>/dev/null; then
        progress "Erstelle Kiosk-Benutzer: $KIOSK_USER"
        useradd -m -s /bin/bash "$KIOSK_USER" || error "Kann Kiosk-Benutzer nicht erstellen"
        
        # Gruppen hinzufügen
        usermod -aG audio,video,input,dialout,plugdev,users "$KIOSK_USER" 2>/dev/null || true
    else
        info "Kiosk-Benutzer $KIOSK_USER existiert bereits"
    fi
    
    # Passwort entfernen für automatischen Login
    passwd -d "$KIOSK_USER" || warning "Konnte Passwort nicht entfernen"
    
    log "✅ Kiosk-Benutzer konfiguriert: $KIOSK_USER"
}

configure_autologin() {
    log "=== KONFIGURIERE AUTOLOGIN FÜR KIOSK-BENUTZER ==="
    
    # Getty-Service für automatischen Login konfigurieren
    progress "Konfiguriere automatischen Login auf tty1..."
    
    local getty_override_dir="/etc/systemd/system/getty@tty1.service.d"
    mkdir -p "$getty_override_dir"
    
    cat > "$getty_override_dir/override.conf" << EOF
[Service]
ExecStart=
ExecStart=-/sbin/agetty --autologin $KIOSK_USER --noclear %I \$TERM
EOF
    
    # Systemd-Konfiguration neu laden
    systemctl daemon-reload
    systemctl enable getty@tty1.service
    
    log "✅ Autologin für $KIOSK_USER konfiguriert"
}

# =========================== PYTHON & NODE.JS INSTALLATION ===========================
install_python_dependencies() {
    log "=== PYTHON-ABHÄNGIGKEITEN INSTALLATION ==="
    
    progress "Installiere Python 3 und Entwicklungstools..."
    apt-get install -y \
        python3 \
        python3-pip \
        python3-dev \
        python3-setuptools \
        python3-venv \
        build-essential \
        libssl-dev \
        libffi-dev \
        sqlite3 \
        || error "Python Installation fehlgeschlagen"
    
    # pip auf neueste Version aktualisieren
    progress "Aktualisiere pip..."
    python3 -m pip install --upgrade pip --break-system-packages || warning "pip Update fehlgeschlagen"
    
    # SSL-Konfiguration für pip
    mkdir -p /root/.pip
    cat > /root/.pip/pip.conf << EOF
[global]
trusted-host = pypi.org
               pypi.python.org
               files.pythonhosted.org
cert = /etc/ssl/certs/ca-certificates.crt
timeout = 60
retries = 3
no-cache-dir = true

[install]
trusted-host = pypi.org
               pypi.python.org
               files.pythonhosted.org
no-warn-script-location = true
EOF
    
    log "✅ Python-Umgebung vorbereitet"
}

install_nodejs_npm() {
    log "=== NODE.JS UND NPM INSTALLATION ==="
    
    # Alte Node.js-Installationen entfernen
    progress "Entferne alte Node.js-Installationen..."
    apt-get remove --purge -y nodejs npm 2>/dev/null || true
    apt-get autoremove -y 2>/dev/null || true
    
    # NodeSource Repository für Node.js LTS hinzufügen
    progress "Installiere Node.js LTS..."
    
    if curl -fsSL https://deb.nodesource.com/setup_lts.x | bash - 2>/dev/null; then
        apt-get update -y
        apt-get install -y nodejs || error "Node.js Installation fehlgeschlagen"
    else
        warning "NodeSource Repository nicht verfügbar - verwende Debian-Repository"
        apt-get install -y nodejs npm || error "Node.js Fallback Installation fehlgeschlagen"
    fi
    
    # Versionen prüfen
    if command -v node >/dev/null 2>&1; then
        local node_version=$(node --version)
        log "✅ Node.js installiert: $node_version"
    else
        error "❌ Node.js Installation fehlgeschlagen"
    fi
    
    if command -v npm >/dev/null 2>&1; then
        local npm_version=$(npm --version)
        log "✅ npm installiert: $npm_version"
        
        # npm-Konfiguration optimieren
        npm config set fund false 2>/dev/null || true
        npm config set audit-level moderate 2>/dev/null || true
    else
        error "❌ npm Installation fehlgeschlagen"
    fi
    
    log "✅ Node.js und npm erfolgreich installiert"
}

install_python_packages() {
    log "=== PYTHON-PAKETE INSTALLATION ==="
    
    local pip_opts="--break-system-packages --trusted-host pypi.org --trusted-host pypi.python.org --trusted-host files.pythonhosted.org --timeout 60 --retries 3"
    
    progress "Installiere Flask-Framework..."
    pip3 install $pip_opts Flask==3.1.1 || pip3 install $pip_opts Flask || error "Flask Installation fehlgeschlagen"
    pip3 install $pip_opts Flask-Login==0.6.3 || pip3 install $pip_opts Flask-Login || error "Flask-Login Installation fehlgeschlagen"
    pip3 install $pip_opts Flask-WTF==1.2.1 || pip3 install $pip_opts Flask-WTF || error "Flask-WTF Installation fehlgeschlagen"
    
    progress "Installiere Datenbank-Komponenten..."
    pip3 install $pip_opts SQLAlchemy==2.0.36 || pip3 install $pip_opts SQLAlchemy || error "SQLAlchemy Installation fehlgeschlagen"
    
    progress "Installiere Sicherheits-Komponenten..."
    pip3 install $pip_opts bcrypt==4.2.1 || pip3 install $pip_opts bcrypt || error "bcrypt Installation fehlgeschlagen"
    pip3 install $pip_opts cryptography==44.0.0 || pip3 install $pip_opts cryptography || error "cryptography Installation fehlgeschlagen"
    pip3 install $pip_opts Werkzeug==3.1.3 || pip3 install $pip_opts Werkzeug || error "Werkzeug Installation fehlgeschlagen"
    
    progress "Installiere weitere Abhängigkeiten..."
    pip3 install $pip_opts requests==2.32.3 || pip3 install $pip_opts requests || error "requests Installation fehlgeschlagen"
    pip3 install $pip_opts psutil==6.1.1 || pip3 install $pip_opts psutil || error "psutil Installation fehlgeschlagen"
    pip3 install $pip_opts MarkupSafe==3.0.2 || pip3 install $pip_opts MarkupSafe || error "MarkupSafe Installation fehlgeschlagen"
    pip3 install $pip_opts gunicorn==23.0.0 || pip3 install $pip_opts gunicorn || error "gunicorn Installation fehlgeschlagen"
    
    # Optionale Pakete
    pip3 install $pip_opts PyP100 || warning "PyP100 Installation fehlgeschlagen (optional)"
    pip3 install $pip_opts redis==5.2.1 || warning "redis Installation fehlgeschlagen (optional)"
    
    log "✅ Python-Pakete erfolgreich installiert"
}

# =========================== SSL-ZERTIFIKATE ===========================
install_ssl_certificates() {
    log "=== SSL-ZERTIFIKATE KONFIGURATION ==="
    
    progress "Aktualisiere CA-Zertifikate..."
    apt-get install -y ca-certificates openssl || error "CA-Zertifikate Installation fehlgeschlagen"
    update-ca-certificates || warning "CA-Zertifikate Update fehlgeschlagen"
    
    # Mercedes Corporate Zertifikate (falls vorhanden)
    if [ -d "$CURRENT_DIR/certs/mercedes" ] && [ "$(ls -A $CURRENT_DIR/certs/mercedes 2>/dev/null)" ]; then
        progress "Installiere Mercedes Corporate Zertifikate..."
        
        find "$CURRENT_DIR/certs/mercedes" -type f \( -name "*.crt" -o -name "*.pem" -o -name "*.cer" \) | while read cert_file; do
            local cert_basename=$(basename "$cert_file")
            local cert_name="${cert_basename%.*}"
            
            progress "Verarbeite Mercedes-Zertifikat: $cert_basename"
            
            # Zertifikat validieren und installieren
            if openssl x509 -in "$cert_file" -text -noout >/dev/null 2>&1; then
                cp "$cert_file" "/usr/local/share/ca-certificates/${cert_name}.crt"
                log "✅ Zertifikat installiert: ${cert_name}.crt"
            elif openssl x509 -in "$cert_file" -inform DER -text -noout >/dev/null 2>&1; then
                openssl x509 -in "$cert_file" -inform DER -out "/usr/local/share/ca-certificates/${cert_name}.crt" -outform PEM
                log "✅ DER-Zertifikat konvertiert und installiert: ${cert_name}.crt"
            else
                warning "⚠️ Ungültiges Zertifikat übersprungen: $cert_file"
            fi
        done
        
        update-ca-certificates || warning "Mercedes Zertifikate Update fehlgeschlagen"
    fi
    
    # SSL-Umgebungsvariablen setzen
    export SSL_CERT_FILE="/etc/ssl/certs/ca-certificates.crt"
    export REQUESTS_CA_BUNDLE="/etc/ssl/certs/ca-certificates.crt"
    export CURL_CA_BUNDLE="/etc/ssl/certs/ca-certificates.crt"
    
    log "✅ SSL-Zertifikate konfiguriert"
}

# =========================== ANWENDUNGS-DEPLOYMENT ===========================
deploy_application() {
    log "=== ANWENDUNGS-DEPLOYMENT ==="
    
    progress "Erstelle Zielverzeichnis: $APP_DIR"
    mkdir -p "$APP_DIR" || error "Konnte Zielverzeichnis nicht erstellen"
    
    progress "Kopiere Anwendungsdateien..."
    
    # Liste der zu kopierenden Dateien/Ordner
    local copy_items=(
        "app.py"
        "models.py"
        "requirements.txt"
        "blueprints/"
        "config/"
        "database/"
        "static/"
        "templates/"
        "uploads/"
        "utils/"
        "logs/"
        "certs/"
    )
    
    # Sichere selektive Kopie
    for item in "${copy_items[@]}"; do
        if [ -e "$CURRENT_DIR/$item" ]; then
            progress "Kopiere: $item"
            cp -r "$CURRENT_DIR/$item" "$APP_DIR/" || warning "Fehler beim Kopieren von $item"
        else
            info "Überspringe nicht vorhandenes Element: $item"
        fi
    done
    
    # Spezielle Dateien
    for file in "package.json" "package-lock.json" "tailwind.config.js" "postcss.config.js"; do
        if [ -f "$CURRENT_DIR/$file" ]; then
            cp "$CURRENT_DIR/$file" "$APP_DIR/" || warning "Fehler beim Kopieren von $file"
        fi
    done
    
    # Erstelle notwendige Verzeichnisse
    mkdir -p "$APP_DIR"/{database/backups,logs/{app,auth,errors},uploads/temp,certs/localhost}
    
    # Berechtigungen setzen
    chown -R root:root "$APP_DIR"
    chmod -R 755 "$APP_DIR"
    chmod 750 "$APP_DIR"/{database,logs,certs}
    chmod +x "$APP_DIR/app.py"
    
    log "✅ Anwendung erfolgreich deployed"
}

install_npm_dependencies() {
    log "=== NPM-ABHÄNGIGKEITEN INSTALLATION ==="
    
    if [ -f "$APP_DIR/package.json" ]; then
        progress "Installiere npm-Abhängigkeiten..."
        
        cd "$APP_DIR"
        
        # npm install mit verschiedenen Fallback-Strategien
        if npm install --no-optional --no-audit --no-fund 2>/dev/null; then
            log "✅ npm install erfolgreich (Standard)"
        elif npm install --legacy-peer-deps --no-optional 2>/dev/null; then
            log "✅ npm install erfolgreich (Legacy-Modus)"
        elif npm install --force 2>/dev/null; then
            log "✅ npm install erfolgreich (Force-Modus)"
        else
            warning "⚠️ npm install fehlgeschlagen - überspringe"
        fi
        
        cd "$CURRENT_DIR"
    else
        info "Keine package.json gefunden - überspringe npm-Installation"
    fi
    
    log "✅ NPM-Abhängigkeiten verarbeitet"
}

# =========================== SSL-ZERTIFIKAT GENERIERUNG ===========================
generate_ssl_certificate() {
    log "=== SSL-ZERTIFIKAT GENERIERUNG ==="
    
    progress "Generiere selbstsigniertes SSL-Zertifikat für localhost..."
    
    local cert_dir="$APP_DIR/certs/localhost"
    mkdir -p "$cert_dir"
    
    # Generiere privaten Schlüssel
    openssl genrsa -out "$cert_dir/localhost.key" 2048 || error "Fehler beim Generieren des privaten Schlüssels"
    
    # Generiere Zertifikat
    openssl req -new -x509 -key "$cert_dir/localhost.key" -out "$cert_dir/localhost.crt" -days 365 \
        -subj "/C=DE/ST=Baden-Wuerttemberg/L=Stuttgart/O=Mercedes-Benz/OU=IT/CN=localhost" \
        || error "Fehler beim Generieren des SSL-Zertifikats"
    
    # Berechtigungen setzen
    chmod 600 "$cert_dir/localhost.key"
    chmod 644 "$cert_dir/localhost.crt"
    
    log "✅ SSL-Zertifikat erfolgreich generiert"
}

# =========================== SYSTEMD-SERVICES ===========================
install_systemd_services() {
    log "=== SYSTEMD-SERVICES INSTALLATION ==="
    
    # Prüfe ob systemd-Verzeichnis existiert
    if [ ! -d "$SYSTEMD_DIR" ]; then
        error "systemd-Verzeichnis nicht gefunden: $SYSTEMD_DIR"
    fi
    
    progress "Kopiere Service-Dateien nach $SYSTEM_SYSTEMD_DIR..."
    
    # Kopiere alle Service-Dateien
    local service_files=(
        "$HTTPS_SERVICE_NAME.service"
        "$KIOSK_SERVICE_NAME.service"
        "$WATCHDOG_SERVICE_NAME.service"
        "$WATCHDOG_PYTHON_SERVICE_NAME.service"
        "$FIREWALL_SERVICE_NAME.service"
    )
    
    for service_file in "${service_files[@]}"; do
        if [ -f "$SYSTEMD_DIR/$service_file" ]; then
            progress "Kopiere Service: $service_file"
            cp "$SYSTEMD_DIR/$service_file" "$SYSTEM_SYSTEMD_DIR/" || error "Fehler beim Kopieren von $service_file"
        else
            warning "Service-Datei nicht gefunden: $service_file"
        fi
    done
    
    # Systemd-Konfiguration neu laden
    progress "Lade systemd-Konfiguration neu..."
    systemctl daemon-reload || error "systemctl daemon-reload fehlgeschlagen"
    
    log "✅ Systemd-Services installiert"
}

enable_and_start_services() {
    log "=== SERVICES AKTIVIEREN UND STARTEN ==="
    
    # HTTPS-Service aktivieren und starten
    progress "Aktiviere und starte HTTPS-Service..."
    systemctl enable "$HTTPS_SERVICE_NAME" || error "Fehler beim Aktivieren des HTTPS-Service"
    systemctl start "$HTTPS_SERVICE_NAME" || error "Fehler beim Starten des HTTPS-Service"
    
    # Warte kurz und prüfe Status
    sleep 5
    if systemctl is-active --quiet "$HTTPS_SERVICE_NAME"; then
        log "✅ HTTPS-Service läuft erfolgreich"
    else
        error "❌ HTTPS-Service konnte nicht gestartet werden"
    fi
    
    # Kiosk-Service aktivieren (aber nicht starten - wird beim nächsten Boot gestartet)
    progress "Aktiviere Kiosk-Service..."
    systemctl enable "$KIOSK_SERVICE_NAME" || warning "Fehler beim Aktivieren des Kiosk-Service"
    
    # Watchdog-Service aktivieren und starten
    progress "Aktiviere und starte Watchdog-Service..."
    systemctl enable "$WATCHDOG_SERVICE_NAME" || warning "Fehler beim Aktivieren des Watchdog-Service"
    systemctl start "$WATCHDOG_SERVICE_NAME" || warning "Fehler beim Starten des Watchdog-Service"
    
    # Firewall-Service aktivieren (falls vorhanden)
    if [ -f "$SYSTEM_SYSTEMD_DIR/$FIREWALL_SERVICE_NAME.service" ]; then
        progress "Aktiviere Firewall-Service..."
        systemctl enable "$FIREWALL_SERVICE_NAME" || warning "Fehler beim Aktivieren des Firewall-Service"
    fi
    
    log "✅ Services erfolgreich konfiguriert"
}

# =========================== SYSTEM-TEST ===========================
test_application() {
    log "=== SYSTEM-TEST ==="
    
    progress "Teste HTTPS-Verbindung..."
    
    # Warte auf Service-Start
    local max_attempts=30
    local attempt=1
    
    while [ $attempt -le $max_attempts ]; do
        if curl -k -s --connect-timeout 5 "$HTTPS_URL" >/dev/null 2>&1; then
            success "✅ HTTPS-Backend erreichbar unter $HTTPS_URL"
            break
        fi
        
        progress "Warte auf HTTPS-Backend... ($attempt/$max_attempts)"
        sleep 2
        ((attempt++))
    done
    
    if [ $attempt -gt $max_attempts ]; then
        error "❌ HTTPS-Backend nicht erreichbar nach $max_attempts Versuchen"
    fi
    
    # Teste SSL-Zertifikat
    progress "Teste SSL-Zertifikat..."
    if openssl s_client -connect localhost:443 -servername localhost </dev/null 2>/dev/null | openssl x509 -noout -text >/dev/null 2>&1; then
        success "✅ SSL-Zertifikat gültig"
    else
        warning "⚠️ SSL-Zertifikat-Test fehlgeschlagen"
    fi
    
    log "✅ System-Test abgeschlossen"
}

# =========================== AUFRÄUMEN ===========================
cleanup_old_files() {
    log "=== AUFRÄUMEN ALTE DATEIEN ==="
    
    progress "Entferne alte Shell-Skripte..."
    
    # Entferne alte Skripte (falls vorhanden)
    local old_scripts=("combined.sh" "installer.sh")
    
    for script in "${old_scripts[@]}"; do
        if [ -f "$CURRENT_DIR/$script" ]; then
            progress "Entferne: $script"
            rm -f "$CURRENT_DIR/$script" || warning "Fehler beim Entfernen von $script"
        fi
    done
    
    log "✅ Aufräumen abgeschlossen"
}

# =========================== HAUPTMENÜ ===========================
show_menu() {
    clear
    echo -e "${CYAN}=================================================================${NC}"
    echo -e "${CYAN}  $APP_NAME - Setup-Skript v$APP_VERSION${NC}"
    echo -e "${CYAN}=================================================================${NC}"
    echo ""
    echo -e "${YELLOW}Bitte wählen Sie eine Option:${NC}"
    echo ""
    echo -e "${GREEN}1)${NC} Nur Abhängigkeiten installieren und System vorbereiten"
    echo -e "   ${BLUE}→ Python, Node.js, SSL-Zertifikate, minimaler Test${NC}"
    echo ""
    echo -e "${GREEN}2)${NC} Finale Installation mit kompletter Kiosk-Modus-Konfiguration"
    echo -e "   ${BLUE}→ Desktop entfernen, Autologin, Services aktivieren${NC}"
    echo ""
    echo -e "${GREEN}3)${NC} Nur Services installieren/aktualisieren"
    echo -e "   ${BLUE}→ Systemd-Services aus systemd/ Verzeichnis kopieren${NC}"
    echo ""
    echo -e "${GREEN}4)${NC} Remote-Zugang konfigurieren (RDP + SSH + Firewall)"
    echo -e "   ${BLUE}→ SSH (user:raspberry), RDP (root:744563017196A), firewalld${NC}"
    echo ""
    echo -e "${GREEN}5)${NC} System-Test durchführen"
    echo -e "   ${BLUE}→ HTTPS-Verbindung, SSL-Zertifikat, Remote-Zugang testen${NC}"
    echo ""
    echo -e "${GREEN}6)${NC} Beenden"
    echo ""
    echo -e "${CYAN}=================================================================${NC}"
    echo -n "Ihre Wahl [1-6]: "
}

# =========================== INSTALLATIONS-MODI ===========================
install_dependencies_only() {
    log "=== MODUS: NUR ABHÄNGIGKEITEN INSTALLIEREN ==="
    
    check_root
    check_debian_system
    check_internet_connection
    
    update_system
    install_python_dependencies
    install_nodejs_npm
    install_ssl_certificates
    install_python_packages
    deploy_application
    install_npm_dependencies
    generate_ssl_certificate
    
    # Minimaler Test
    progress "Starte minimalen Test..."
    cd "$APP_DIR"
    
    # Teste Python-Import
    if python3 -c "import sys; sys.path.insert(0, '$APP_DIR'); from app import app; print('✅ Flask-App erfolgreich importiert')" 2>/dev/null; then
        success "✅ Python-Abhängigkeiten funktionieren"
    else
        error "❌ Python-Import fehlgeschlagen"
    fi
    
    cd "$CURRENT_DIR"
    
    success "✅ Abhängigkeiten-Installation abgeschlossen!"
    info "Das System ist bereit für die finale Kiosk-Installation (Option 2)"
}

install_full_kiosk() {
    log "=== MODUS: FINALE KIOSK-INSTALLATION ==="
    
    check_root
    check_debian_system
    
    # Führe zuerst Abhängigkeiten-Installation durch (falls noch nicht geschehen)
    if [ ! -d "$APP_DIR" ] || [ ! -f "$APP_DIR/app.py" ]; then
        warning "Anwendung noch nicht deployed - führe Abhängigkeiten-Installation durch..."
        install_dependencies_only
    fi
    
    remove_desktop_environments
    install_minimal_x11
    create_kiosk_user
    configure_autologin
    install_systemd_services
    enable_and_start_services
    
    # Frage nach Remote-Zugang
    echo ""
    echo -n "Remote-Zugang (RDP + SSH + Firewall) konfigurieren? [j/N]: "
    read -r configure_remote
    
    if [[ "$configure_remote" =~ ^[Jj]$ ]]; then
        install_remote_access
        configure_firewall
    fi
    
    test_application
    cleanup_old_files
    
    success "✅ Finale Kiosk-Installation abgeschlossen!"
    info "Das System wird beim nächsten Neustart automatisch im Kiosk-Modus starten"
    warning "⚠️ Neustart empfohlen: sudo reboot"
}

install_services_only() {
    log "=== MODUS: NUR SERVICES INSTALLIEREN ==="
    
    check_root
    install_systemd_services
    
    # Frage ob Services aktiviert werden sollen
    echo ""
    echo -n "Services aktivieren und starten? [j/N]: "
    read -r activate_services
    
    if [[ "$activate_services" =~ ^[Jj]$ ]]; then
        enable_and_start_services
    else
        info "Services installiert aber nicht aktiviert"
        info "Manuell aktivieren mit: sudo systemctl enable $HTTPS_SERVICE_NAME"
    fi
    
    success "✅ Service-Installation abgeschlossen!"
}

install_remote_access_only() {
    log "=== MODUS: NUR REMOTE-ZUGANG KONFIGURIEREN ==="
    
    check_root
    check_debian_system
    check_internet_connection
    
    install_remote_access
    configure_firewall
    test_remote_access
    
    success "✅ Remote-Zugang-Konfiguration abgeschlossen!"
    info "Zugang verfügbar über:"
    info "  📡 SSH: ssh user@<ip-adresse> (Passwort: raspberry)"
    info "  🖥️ RDP: <ip-adresse>:3389 (Benutzer: root, Passwort: 744563017196A)"
}

run_system_test() {
    log "=== MODUS: SYSTEM-TEST ==="
    
    test_application
    
    # Zusätzliche Tests
    progress "Prüfe Service-Status..."
    
    local services=("$HTTPS_SERVICE_NAME" "$KIOSK_SERVICE_NAME" "$WATCHDOG_SERVICE_NAME" "$FIREWALL_SERVICE_NAME")
    
    for service in "${services[@]}"; do
        if systemctl is-enabled --quiet "$service" 2>/dev/null; then
            if systemctl is-active --quiet "$service"; then
                success "✅ $service: aktiv und läuft"
            else
                warning "⚠️ $service: aktiviert aber läuft nicht"
            fi
        else
            info "ℹ️ $service: nicht aktiviert"
        fi
    done
    
    # Remote-Zugang testen (falls konfiguriert)
    if systemctl is-enabled --quiet ssh 2>/dev/null || systemctl is-enabled --quiet xrdp 2>/dev/null; then
        test_remote_access
    else
        info "ℹ️ Remote-Zugang nicht konfiguriert"
    fi
    
    success "✅ System-Test abgeschlossen!"
}

# =========================== RDP & SSH ZUGANG ===========================
install_remote_access() {
    log "=== INSTALLIERE REMOTE-ZUGANG (RDP & SSH) ==="
    
    # SSH-Server installieren und konfigurieren
    progress "Installiere und konfiguriere SSH-Server..."
    apt-get install -y openssh-server || error "SSH-Server Installation fehlgeschlagen"
    
    # SSH-Service aktivieren
    systemctl enable ssh
    systemctl start ssh
    
    # SSH-Benutzer 'user' erstellen (falls nicht vorhanden)
    if ! id "user" &>/dev/null; then
        progress "Erstelle SSH-Benutzer: user"
        useradd -m -s /bin/bash user || error "Kann SSH-Benutzer nicht erstellen"
        echo "user:raspberry" | chpasswd || error "Kann Passwort für SSH-Benutzer nicht setzen"
        usermod -aG sudo user 2>/dev/null || true
        log "✅ SSH-Benutzer 'user' erstellt mit Passwort 'raspberry'"
    else
        info "SSH-Benutzer 'user' existiert bereits"
        echo "user:raspberry" | chpasswd || warning "Konnte Passwort für SSH-Benutzer nicht aktualisieren"
    fi
    
    # RDP-Server (xrdp) installieren
    progress "Installiere RDP-Server (xrdp)..."
    
    # Minimale Desktop-Umgebung für RDP installieren
    progress "Installiere minimale Desktop-Umgebung für RDP..."
    apt-get install -y tasksel || error "tasksel Installation fehlgeschlagen"
    
    # XFCE als leichtgewichtige Desktop-Umgebung installieren
    progress "Installiere XFCE Desktop-Umgebung..."
    apt-get install -y xfce4 xfce4-goodies || error "XFCE Installation fehlgeschlagen"
    
    # xrdp installieren
    apt-get install -y xrdp || error "xrdp Installation fehlgeschlagen"
    
    # xrdp-Service aktivieren
    systemctl enable xrdp
    systemctl start xrdp
    
    # SSL-Zertifikate für xrdp erstellen
    progress "Erstelle SSL-Zertifikate für xrdp..."
    mkdir -p /etc/xrdp/certs
    cd /etc/xrdp/certs
    
    openssl req -x509 -newkey rsa:2048 -nodes -keyout key.pem -out cert.pem -days 3650 \
        -subj "/C=DE/ST=Baden-Wuerttemberg/L=Stuttgart/O=Mercedes-Benz/OU=IT/CN=myp-rdp" \
        || error "SSL-Zertifikat-Generierung für xrdp fehlgeschlagen"
    
    # Berechtigungen für xrdp-Zertifikate setzen
    chown -R xrdp:xrdp /etc/xrdp/certs
    chmod 0644 /etc/xrdp/certs/cert.pem
    chmod 0600 /etc/xrdp/certs/key.pem
    
    # xrdp-Konfiguration für TLS
    progress "Konfiguriere xrdp für TLS..."
    cp /etc/xrdp/xrdp.ini /etc/xrdp/xrdp.ini.backup
    
    cat > /etc/xrdp/xrdp.ini << 'EOF'
[Globals]
ini_version=1
fork=true
port=3389
tcp_nodelay=true
tcp_keepalive=true
security_layer=tls
certificate=/etc/xrdp/certs/cert.pem
key_file=/etc/xrdp/certs/key.pem
ssl_protocols=TLSv1.2, TLSv1.3
autorun=
allow_channels=true
allow_multimon=true
bitmap_cache=true
bitmap_compression=true
bulk_compression=true
max_bpp=32
new_cursors=true
use_fastpath=both
require_credentials=true
ask_for_reconnect_reason=true
enable_token_login=true

[Xorg]
name=Xorg
lib=libxup.so
username=ask
password=ask
ip=127.0.0.1
port=-1
code=20
EOF
    
    # Root-Passwort für RDP setzen
    progress "Setze Root-Passwort für RDP-Zugang..."
    echo "root:744563017196A" | chpasswd || error "Kann Root-Passwort nicht setzen"
    
    # xrdp-Service neu starten
    systemctl restart xrdp
    
    cd "$CURRENT_DIR"
    
    log "✅ Remote-Zugang konfiguriert:"
    log "   📡 SSH: user:raspberry (Port 22)"
    log "   🖥️ RDP: root:744563017196A (Port 3389)"
}

# =========================== FIREWALL KONFIGURATION ===========================
configure_firewall() {
    log "=== KONFIGURIERE FIREWALL (firewalld) ==="
    
    # firewalld installieren
    progress "Installiere firewalld..."
    apt-get install -y firewalld || error "firewalld Installation fehlgeschlagen"
    
    # firewalld aktivieren und starten
    systemctl enable firewalld
    systemctl start firewalld
    
    # Warte kurz bis firewalld vollständig gestartet ist
    sleep 3
    
    progress "Konfiguriere firewalld-Zonen und -Regeln..."
    
    # Zone definieren
    firewall-cmd --permanent --new-zone=myp-backend 2>/dev/null || true
    firewall-cmd --permanent --zone=myp-backend --add-source=192.168.0.0/24
    
    # Nur HTTPS für API & Kiosk zulassen
    firewall-cmd --permanent --zone=myp-backend --add-port=443/tcp
    
    # SSH für Wartung
    firewall-cmd --permanent --zone=myp-backend --add-service=ssh
    
    # RDP für Remote-Desktop
    firewall-cmd --permanent --zone=myp-backend --add-port=3389/tcp
    
    # Default-Zone setzen
    firewall-cmd --set-default-zone=myp-backend
    
    # Änderungen übernehmen
    firewall-cmd --reload
    
    # Firewall-Status anzeigen
    progress "Firewall-Konfiguration:"
    firewall-cmd --list-all-zones | grep -A 10 "myp-backend" || true
    
    log "✅ Firewall konfiguriert:"
    log "   🔒 Zone: myp-backend (192.168.0.0/24)"
    log "   🌐 HTTPS: Port 443/tcp"
    log "   📡 SSH: Port 22/tcp"
    log "   🖥️ RDP: Port 3389/tcp"
}

# =========================== REMOTE-ZUGANG TESTEN ===========================
test_remote_access() {
    log "=== TESTE REMOTE-ZUGANG ==="
    
    # SSH-Service testen
    progress "Teste SSH-Service..."
    if systemctl is-active --quiet ssh; then
        success "✅ SSH-Service läuft"
        
        # SSH-Port testen
        if ss -tlnp | grep -q ":22 "; then
            success "✅ SSH-Port 22 ist offen"
        else
            warning "⚠️ SSH-Port 22 nicht erreichbar"
        fi
    else
        error "❌ SSH-Service läuft nicht"
    fi
    
    # RDP-Service testen
    progress "Teste RDP-Service..."
    if systemctl is-active --quiet xrdp; then
        success "✅ RDP-Service läuft"
        
        # RDP-Port testen
        if ss -tlnp | grep -q ":3389 "; then
            success "✅ RDP-Port 3389 ist offen"
        else
            warning "⚠️ RDP-Port 3389 nicht erreichbar"
        fi
    else
        error "❌ RDP-Service läuft nicht"
    fi
    
    # Firewall-Status testen
    progress "Teste Firewall-Status..."
    if systemctl is-active --quiet firewalld; then
        success "✅ Firewall läuft"
        
        # Aktive Zone anzeigen
        local active_zone=$(firewall-cmd --get-active-zones | head -1)
        info "Aktive Zone: $active_zone"
    else
        warning "⚠️ Firewall läuft nicht"
    fi
    
    log "✅ Remote-Zugang-Test abgeschlossen"
}

# =========================== HAUPTPROGRAMM ===========================
main() {
    # Erstelle Log-Datei
    touch "$INSTALL_LOG" || true
    
    while true; do
        show_menu
        read -r choice
        
        case $choice in
            1)
                install_dependencies_only
                echo ""
                echo -n "Drücken Sie Enter um fortzufahren..."
                read -r
                ;;
            2)
                install_full_kiosk
                echo ""
                echo -n "Drücken Sie Enter um fortzufahren..."
                read -r
                ;;
            3)
                install_services_only
                echo ""
                echo -n "Drücken Sie Enter um fortzufahren..."
                read -r
                ;;
            4)
                install_remote_access_only
                echo ""
                echo -n "Drücken Sie Enter um fortzufahren..."
                read -r
                ;;
            5)
                run_system_test
                echo ""
                echo -n "Drücken Sie Enter um fortzufahren..."
                read -r
                ;;
            6)
                log "Setup-Skript beendet"
                exit 0
                ;;
            *)
                error "Ungültige Auswahl. Bitte wählen Sie 1-6."
                ;;
        esac
    done
}

# Skript starten
main "$@"