#!/bin/bash

# ===================================================================
# MYP Druckerverwaltung - Raspberry Pi Kiosk Installation
# Vollautomatische Installation für echten Kiosk-Modus ohne Escape
# Designed für Raspberry Pi OS, Ubuntu Server, Debian minimal
# ===================================================================

set -e  # Bei Fehlern sofort beenden

# =========================== KONFIGURATION ===========================
KIOSK_USER="kiosk"
APP_USER="myp"
APP_DIR="/opt/myp-druckerverwaltung"
BACKUP_DIR="/opt/myp-backups"
CURRENT_DIR=""
INSTALL_LOG="/var/log/myp-kiosk-install.log"

# Desktop Environment Pakete die entfernt werden sollen
REMOVE_PACKAGES=(
    "gnome*" "kde*" "xfce*" "lxde*" "mate*" "cinnamon*"
    "lightdm" "gdm*" "xdm" "nodm"
    "firefox*" "thunderbird*" "libreoffice*" "wolfram-engine"
    "scratch*" "minecraft-pi" "sonic-pi" "idle*"
    "vlc" "smplayer" "totem" "rhythmbox"
    "gedit" "mousepad" "leafpad" "pluma"
    "file-roller" "xarchiver" "ark"
    "gimp" "inkscape" "blender"
    "chromium-browser"  # Alte Version entfernen
)

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

# ========================== LOGGING-SYSTEM ==========================
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"
}

# ========================== SYSTEM-CHECKS ==========================
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"
}

detect_system() {
    log "Erkenne System-Umgebung..."
    
    # Aktuelle Position ermitteln
    CURRENT_DIR="$(pwd)"
    log "Aktuelles Verzeichnis: $CURRENT_DIR"
    
    # Prüfe ob wir uns im richtigen Verzeichnis befinden
    if [ ! -f "$CURRENT_DIR/app.py" ]; then
        error "app.py nicht gefunden in $CURRENT_DIR - Bitte im MYP-Projektverzeichnis ausführen!"
    fi
    
    # System-Info sammeln
    info "System: $(uname -a)"
    info "Distribution: $(lsb_release -d 2>/dev/null || cat /etc/os-release | head -1 || echo 'Unbekannt')"
    info "Speicher: $(free -h | head -2 | tail -1)"
    info "Festplatte: $(df -h / | tail -1)"
    
    # Internetverbindung testen
    if ! ping -c 1 google.com &> /dev/null; then
        error "Keine Internetverbindung verfügbar!"
    fi
    
    # Minimal 2GB freier Speicher erforderlich
    available_kb=$(df / | awk 'NR==2 {print $4}')
    if [ "$available_kb" -lt 2000000 ]; then
        error "Nicht genügend Speicherplatz! Mindestens 2GB erforderlich."
    fi
    
    log "✅ System-Checks erfolgreich"
}

# ========================== SYSTEM-BEREINIGUNG ==========================
cleanup_system() {
    log "=== PHASE 1: SYSTEM-BEREINIGUNG ==="
    
    # APT-Cache aktualisieren
    progress "Aktualisiere Paketlisten..."
    apt-get update -y || warning "APT Update teilweise fehlgeschlagen"
    
    # Entferne unnötige Desktop-Umgebungen
    progress "Entferne Desktop-Umgebungen und unnötige Software..."
    for package in "${REMOVE_PACKAGES[@]}"; do
        if dpkg -l | grep -q "^ii.*$package"; then
            info "Entferne: $package"
            apt-get purge -y "$package" 2>/dev/null || true
        fi
    done
    
    # Aggressive Bereinigung
    apt-get autoremove -y --purge
    apt-get autoclean
    
    # Stoppe unnötige Services
    progress "Stoppe Desktop-Services..."
    for service in gdm lightdm xdm nodm plymouth; do
        systemctl stop "$service" 2>/dev/null || true
        systemctl disable "$service" 2>/dev/null || true
    done
    
    log "✅ System-Bereinigung abgeschlossen"
}

# ========================== PAKETE INSTALLIEREN ==========================
install_packages() {
    log "=== PHASE 2: SYSTEM-PAKETE INSTALLATION ==="
    
    progress "Installiere Basis-Pakete..."
    apt-get install -y \
        curl wget git unzip \
        python3 python3-pip python3-venv python3-dev \
        build-essential libssl-dev libffi-dev \
        sqlite3 nginx supervisor \
        xorg xinit openbox \
        xserver-xorg-video-all \
        x11-xserver-utils xdotool unclutter \
        pulseaudio alsa-utils \
        fonts-liberation fonts-dejavu \
        ca-certificates apt-transport-https \
        systemd-timesyncd \
        ufw fail2ban \
        htop nano \
        || error "Basis-Pakete Installation fehlgeschlagen"
    
    # Node.js installieren
    progress "Installiere Node.js..."
    if ! command -v node &> /dev/null; then
        curl -fsSL https://deb.nodesource.com/setup_lts.x | bash -
        apt-get install -y nodejs
    fi
    
    log "✅ System-Pakete installiert"
}

# ========================== CHROMIUM INSTALLATION ==========================
install_chromium() {
    log "=== PHASE 3: CHROMIUM INSTALLATION ==="
    
    progress "Installiere Chromium Browser..."
    
    # Versuche verschiedene Installationsmethoden
    if apt-get install -y chromium 2>/dev/null; then
        CHROMIUM_BIN="/usr/bin/chromium"
        log "✅ Chromium via APT installiert"
    elif apt-get install -y chromium-browser 2>/dev/null; then
        CHROMIUM_BIN="/usr/bin/chromium-browser"  
        log "✅ Chromium-Browser via APT installiert"
    else
        # Snap-Installation versuchen
        warning "APT-Installation fehlgeschlagen, versuche Snap..."
        if command -v snap &> /dev/null || (apt-get install -y snapd && systemctl enable --now snapd); then
            snap install chromium
            CHROMIUM_BIN="/snap/bin/chromium"
            log "✅ Chromium via Snap installiert"
        else
            # Flatpak als letzter Ausweg
            warning "Snap fehlgeschlagen, versuche Flatpak..."
            if apt-get install -y flatpak && flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo; then
                flatpak install -y flathub org.chromium.Chromium
                CHROMIUM_BIN="flatpak run org.chromium.Chromium"
                log "✅ Chromium via Flatpak installiert"
            else
                error "❌ Chromium konnte nicht installiert werden! Bitte manuell installieren."
            fi
        fi
    fi
    
    # Chromium-Binary validieren
    if [[ "$CHROMIUM_BIN" == "flatpak"* ]]; then
        # Flatpak-Spezialbehandlung
        log "Chromium via Flatpak verfügbar"
    elif [ ! -x "$CHROMIUM_BIN" ]; then
        error "Chromium-Binary nicht ausführbar: $CHROMIUM_BIN"
    fi
    
    log "✅ Chromium-Installation abgeschlossen: $CHROMIUM_BIN"
}

# ========================== BENUTZER ERSTELLEN ==========================
create_users() {
    log "=== PHASE 4: BENUTZER-ERSTELLUNG ==="
    
    # App-Benutzer erstellen
    progress "Erstelle App-Benutzer: $APP_USER"
    if ! id "$APP_USER" &>/dev/null; then
        if ! useradd -m -s /bin/bash "$APP_USER" 2>/dev/null; then
            adduser --disabled-password --gecos "" "$APP_USER" || error "Kann App-Benutzer nicht erstellen"
        fi
        usermod -aG sudo "$APP_USER" 2>/dev/null || true
    fi
    
    # Kiosk-Benutzer erstellen
    progress "Erstelle Kiosk-Benutzer: $KIOSK_USER"
    if ! id "$KIOSK_USER" &>/dev/null; then
        if ! useradd -m -s /bin/bash "$KIOSK_USER" 2>/dev/null; then
            adduser --disabled-password --gecos "" "$KIOSK_USER" || error "Kann Kiosk-Benutzer nicht erstellen"
        fi
        # Kiosk-Benutzer zu Audio/Video-Gruppen hinzufügen
        usermod -aG audio,video,input "$KIOSK_USER" 2>/dev/null || true
    fi
    
    log "✅ Benutzer erstellt: $APP_USER, $KIOSK_USER"
}

# ========================== ANWENDUNG INSTALLIEREN ==========================
install_application() {
    log "=== PHASE 5: ANWENDUNGS-INSTALLATION ==="
    
    # Anwendungsverzeichnis erstellen
    progress "Erstelle Anwendungsverzeichnis: $APP_DIR"
    mkdir -p "$APP_DIR" "$BACKUP_DIR"
    
    # Anwendung kopieren
    progress "Kopiere Anwendung von $CURRENT_DIR nach $APP_DIR"
    cp -r "$CURRENT_DIR"/* "$APP_DIR/"
    chown -R "$APP_USER:$APP_USER" "$APP_DIR"
    
    # Wechsel ins Anwendungsverzeichnis
    cd "$APP_DIR"
    
    # Python Virtual Environment
    progress "Erstelle Python Virtual Environment..."
    sudo -u "$APP_USER" python3 -m venv venv
    sudo -u "$APP_USER" ./venv/bin/pip install --upgrade pip
    
    # Python-Dependencies installieren
    progress "Installiere Python-Dependencies..."
    if [ -f "requirements.txt" ]; then
        sudo -u "$APP_USER" ./venv/bin/pip install -r requirements.txt
    else
        # Basis-Pakete installieren
        sudo -u "$APP_USER" ./venv/bin/pip install \
            flask flask-login flask-wtf flask-limiter \
            sqlalchemy werkzeug requests gunicorn \
            bcrypt cryptography PyP100
    fi
    
    # Node.js Dependencies
    if [ -f "package.json" ]; then
        progress "Installiere Node.js Dependencies..."
        sudo -u "$APP_USER" npm install
        if [ -f "tailwind.config.js" ]; then
            sudo -u "$APP_USER" npm run build:css || true
        fi
    fi
    
    # Datenbank initialisieren (DB-Import-Fehler behoben)
    progress "Initialisiere Datenbank..."
    sudo -u "$APP_USER" ./venv/bin/python -c "
from app import app, db
from models import init_database, create_initial_admin
with app.app_context():
    init_database()
    create_initial_admin()
print('Datenbank initialisiert')
" || warning "Datenbank-Initialisierung fehlgeschlagen"
    
    # Konfiguration erstellen
    progress "Erstelle Anwendungskonfiguration..."
    cat > "$APP_DIR/.env" << EOF
FLASK_ENV=production
SECRET_KEY=$(openssl rand -hex 32)
DATABASE_URL=sqlite:///database.db
HOST=0.0.0.0
PORT=5000
DEBUG=False
KIOSK_MODE=true
KIOSK_URL=http://localhost
EOF
    chown "$APP_USER:$APP_USER" "$APP_DIR/.env"
    
    log "✅ Anwendung installiert"
}

# ========================== KIOSK-KONFIGURATION ==========================
configure_kiosk() {
    log "=== PHASE 6: KIOSK-KONFIGURATION ==="
    
    # Sicherer Kiosk-Benutzer-Setup
    KIOSK_HOME="/home/$KIOSK_USER"
    
    progress "Konfiguriere Openbox für Kiosk..."
    sudo -u "$KIOSK_USER" mkdir -p "$KIOSK_HOME/.config/openbox"
    
    # Openbox-Konfiguration für maximale Sicherheit
    cat > "$KIOSK_HOME/.config/openbox/rc.xml" << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<openbox_config xmlns="http://openbox.org/3.4/rc">
  <resistance>
    <strength>10</strength>
    <screen_edge_strength>20</screen_edge_strength>
  </resistance>
  <focus>
    <focusNew>yes</focusNew>
    <followMouse>no</followMouse>
    <focusLast>yes</focusLast>
    <underMouse>no</underMouse>
    <focusDelay>200</focusDelay>
    <raiseOnFocus>no</raiseOnFocus>
  </focus>
  <placement>
    <policy>Smart</policy>
    <center>yes</center>
    <monitor>Primary</monitor>
    <primaryMonitor>1</primaryMonitor>
  </placement>
  <theme>
    <name>Clearlooks</name>
    <titleLayout>NLIMC</titleLayout>
    <keepBorder>yes</keepBorder>
    <animateIconify>yes</animateIconify>
    <font place="ActiveWindow">
      <name>sans</name>
      <size>8</size>
      <weight>bold</weight>
      <slant>normal</slant>
    </font>
  </theme>
  <desktops>
    <number>1</number>
    <firstdesk>1</firstdesk>
    <names>
      <name>Kiosk</name>
    </names>
    <popupTime>875</popupTime>
  </desktops>
  <resize>
    <drawContents>yes</drawContents>
    <popupShow>Nonpixel</popupShow>
    <popupPosition>Center</popupPosition>
    <popupFixedPosition>
      <x>10</x>
      <y>10</y>
    </popupFixedPosition>
  </resize>
  <dock>
    <position>TopLeft</position>
    <floatingX>0</floatingX>
    <floatingY>0</floatingY>
    <noStrut>no</noStrut>
    <stacking>Above</stacking>
    <direction>Vertical</direction>
    <autoHide>no</autoHide>
    <hideDelay>300</hideDelay>
    <showDelay>300</showDelay>
    <moveButton>Middle</moveButton>
  </dock>
  <keyboard>
    <!-- ALLE SHORTCUTS DEAKTIVIERT FÜR KIOSK-SICHERHEIT -->
  </keyboard>
  <mouse>
    <dragThreshold>3</dragThreshold>
    <doubleClickTime>200</doubleClickTime>
    <screenEdgeWarpTime>400</screenEdgeWarpTime>
    <screenEdgeWarpMouse>false</screenEdgeWarpMouse>
  </mouse>
  <menu>
    <!-- KEIN MENU FÜR KIOSK -->
  </menu>
  <applications>
    <application name="chromium*">
      <decor>no</decor>
      <shade>no</shade>
      <position force="yes">
        <x>0</x>
        <y>0</y>
      </position>
      <size>
        <width>100%</width>
        <height>100%</height>
      </size>
      <fullscreen>yes</fullscreen>
      <maximized>yes</maximized>
      <skip_pager>yes</skip_pager>
      <skip_taskbar>yes</skip_taskbar>
    </application>
  </applications>
</openbox_config>
EOF
    
    # Autostart-Konfiguration
    cat > "$KIOSK_HOME/.config/openbox/autostart" << EOF
#!/bin/bash

# Warte auf X-Server
sleep 3

# Führe Kiosk-Skript aus
exec $KIOSK_HOME/start-kiosk.sh
EOF
    
    # Haupt-Kiosk-Skript mit maximaler Sicherheit
    cat > "$KIOSK_HOME/start-kiosk.sh" << EOF
#!/bin/bash

# ===== KIOSK-SICHERHEITS-KONFIGURATION =====
export DISPLAY=:0

# Bildschirmschoner komplett deaktivieren
xset s off
xset s noblank  
xset s noexpose
xset -dpms

# Mauszeiger verstecken
unclutter -idle 0.1 -root &

# Virtuelle Tastatur deaktivieren
killall onboard 2>/dev/null || true

# Screenshot-Tools deaktivieren
killall gnome-screenshot 2>/dev/null || true
killall scrot 2>/dev/null || true

# ===== WARTE AUF ANWENDUNG =====
while ! curl -s http://localhost:5000 > /dev/null; do
    echo "Warte auf MYP-Anwendung..."
    sleep 2
done

# ===== CHROMIUM KIOSK-MODUS =====
# Maximum security flags für echten Kiosk-Modus
$CHROMIUM_BIN \\
    --kiosk \\
    --no-sandbox \\
    --disable-web-security \\
    --disable-features=TranslateUI,BlinkGenPropertyTrees \\
    --disable-ipc-flooding-protection \\
    --disable-renderer-backgrounding \\
    --disable-backgrounding-occluded-windows \\
    --disable-background-timer-throttling \\
    --disable-background-networking \\
    --disable-breakpad \\
    --disable-component-extensions-with-background-pages \\
    --disable-dev-shm-usage \\
    --disable-extensions \\
    --disable-hang-monitor \\
    --disable-popup-blocking \\
    --disable-prompt-on-repost \\
    --disable-sync \\
    --disable-translate \\
    --disable-infobars \\
    --disable-session-crashed-bubble \\
    --disable-restore-session-state \\
    --noerrdialogs \\
    --force-color-profile=srgb \\
    --no-first-run \\
    --no-default-browser-check \\
    --autoplay-policy=no-user-gesture-required \\
    --start-fullscreen \\
    --window-position=0,0 \\
    --window-size=1920,1080 \\
    --app=http://localhost:5000 \\
    --user-data-dir=$KIOSK_HOME/.chromium-kiosk \\
    --disable-features=VizDisplayCompositor \\
    --enable-features=OverlayScrollbar \\
    --disable-gpu-sandbox \\
    --disable-software-rasterizer \\
    --ignore-certificate-errors \\
    --ignore-ssl-errors \\
    --ignore-certificate-errors-spki-list \\
    --ignore-ssl-errors-list \\
    --disable-logging \\
    --silent-debugger-extension-api \\
    --disable-default-apps \\
    --disable-background-mode \\
    --app-auto-launched \\
    --no-startup-window
EOF
    
    # Skripte ausführbar machen
    chmod +x "$KIOSK_HOME/.config/openbox/autostart"
    chmod +x "$KIOSK_HOME/start-kiosk.sh"
    chown -R "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.config"
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/start-kiosk.sh"
    
    log "✅ Kiosk-Konfiguration erstellt"
}

# ========================== AUTO-LOGIN KONFIGURATION ==========================
configure_autologin() {
    log "=== PHASE 6.5: AUTO-LOGIN KONFIGURATION ==="
    
    progress "Installiere und konfiguriere Display Manager..."
    
    # LightDM installieren für besseres Auto-Login-Management
    apt-get install -y lightdm lightdm-gtk-greeter || true
    
    # Stoppe andere Display Manager
    for dm in gdm gdm3 sddm xdm nodm; do
        systemctl stop "$dm" 2>/dev/null || true
        systemctl disable "$dm" 2>/dev/null || true
    done
    
    progress "Konfiguriere LightDM für Auto-Login..."
    
    # LightDM-Konfiguration für automatischen Login
    cat > "/etc/lightdm/lightdm.conf" << EOF
[Seat:*]
# Automatischer Login für Kiosk-Benutzer
autologin-user=$KIOSK_USER
autologin-user-timeout=0
autologin-session=openbox
user-session=openbox
session-wrapper=/etc/X11/Xsession
greeter-session=lightdm-gtk-greeter
allow-guest=false
# Kein Benutzer-Wechsel möglich
greeter-hide-users=true
greeter-show-manual-login=false
# Automatischer Start ohne Verzögerung
autologin-in-background=false
# Session-Setup
session-setup-script=/usr/share/lightdm/setup-kiosk-session.sh
EOF
    
    progress "Erstelle Session-Setup-Skript..."
    
    # Session-Setup-Skript für zusätzliche Sicherheit
    cat > "/usr/share/lightdm/setup-kiosk-session.sh" << EOF
#!/bin/bash
# Session-Setup für Kiosk-Modus

# Stelle sicher, dass X11-Display verfügbar ist
export DISPLAY=:0

# Deaktiviere Bildschirmschoner und Power Management
xset s off
xset s noblank
xset s noexpose
xset -dpms

# Verstecke Mauszeiger
unclutter -idle 0.5 -root &

# Logge Session-Start
echo "\$(date): Kiosk-Session für Benutzer $KIOSK_USER gestartet" >> /var/log/kiosk-session.log
EOF
    
    chmod +x "/usr/share/lightdm/setup-kiosk-session.sh"
    
    progress "Konfiguriere Getty Auto-Login als Fallback..."
    
    # Getty Auto-Login als Fallback konfigurieren (falls LightDM fehlschlägt)
    mkdir -p "/etc/systemd/system/getty@tty1.service.d"
    cat > "/etc/systemd/system/getty@tty1.service.d/autologin.conf" << EOF
[Service]
ExecStart=
ExecStart=-/sbin/agetty --autologin $KIOSK_USER --noclear %I \$TERM
Type=simple
EOF
    
    progress "Erstelle Desktop-Session für Openbox..."
    
    # Desktop-Session-Datei für Openbox
    mkdir -p "/usr/share/xsessions"
    cat > "/usr/share/xsessions/openbox.desktop" << EOF
[Desktop Entry]
Name=Openbox
Comment=A lightweight window manager
Exec=openbox-session
Type=XSession
DesktopNames=OPENBOX
EOF
    
    # Kiosk-Benutzer Desktop-Umgebung konfigurieren
    progress "Konfiguriere Desktop-Umgebung für Kiosk-Benutzer..."
    
    KIOSK_HOME="/home/$KIOSK_USER"
    
    # .xsessionrc für X-Session-Setup
    cat > "$KIOSK_HOME/.xsessionrc" << EOF
#!/bin/bash
# X-Session-Setup für Kiosk-Modus

# Export Display
export DISPLAY=:0

# Starte Session-Log
echo "\$(date): X-Session gestartet für Kiosk-Benutzer" >> /var/log/kiosk-session.log

# Führe Kiosk-Setup aus
exec openbox-session
EOF
    
    # .xinitrc für xinit/startx
    cat > "$KIOSK_HOME/.xinitrc" << EOF
#!/bin/bash
# Xinit-Konfiguration für Kiosk-Modus

# Export Display
export DISPLAY=:0

# Session-Setup
xset s off
xset s noblank
xset s noexpose  
xset -dpms

# Verstecke Mauszeiger
unclutter -idle 0.5 -root &

# Starte Openbox
exec openbox-session
EOF
    
    # Berechtigungen setzen
    chmod +x "$KIOSK_HOME/.xsessionrc"
    chmod +x "$KIOSK_HOME/.xinitrc"
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.xsessionrc"
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.xinitrc"
    
    # LightDM aktivieren
    systemctl enable lightdm
    
    # Sicherstellen, dass graphical.target als Standard gesetzt ist
    systemctl set-default graphical.target
    
    log "✅ Auto-Login konfiguriert"
}

# ========================== MEHRFACHE AUTOSTART-ABSICHERUNG ==========================
configure_multiple_autostart() {
    log "=== PHASE 6.8: MEHRFACHE AUTOSTART-ABSICHERUNG ==="
    
    KIOSK_HOME="/home/$KIOSK_USER"
    
    progress "Implementiere mehrfache Autostart-Mechanismen..."
    
    # 1. SYSTEMD USER-SESSION AUTOSTART
    progress "Konfiguriere systemd user session autostart..."
    sudo -u "$KIOSK_USER" mkdir -p "$KIOSK_HOME/.config/systemd/user"
    
    cat > "$KIOSK_HOME/.config/systemd/user/kiosk-autostart.service" << EOF
[Unit]
Description=Kiosk Autostart (User Session)
After=graphical-session.target

[Service]
Type=simple
ExecStart=$KIOSK_HOME/start-kiosk.sh
Restart=always
RestartSec=5
Environment=DISPLAY=:0

[Install]
WantedBy=default.target
EOF
    
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.config/systemd/user/kiosk-autostart.service"
    
    # Aktiviere User-Service
    sudo -u "$KIOSK_USER" systemctl --user enable kiosk-autostart.service || true
    
    # 2. BASHRC AUTOSTART
    progress "Konfiguriere .bashrc autostart..."
    cat >> "$KIOSK_HOME/.bashrc" << 'EOF'

# ===== KIOSK AUTOSTART (BASHRC) =====
if [ -z "$SSH_CLIENT" ] && [ -z "$SSH_TTY" ] && [ -z "$KIOSK_STARTED" ]; then
    export KIOSK_STARTED=1
    
    # Prüfe ob X-Session läuft
    if [ -n "$DISPLAY" ] || [ "$XDG_SESSION_TYPE" = "x11" ]; then
        echo "Kiosk-Autostart via .bashrc"
        exec $HOME/start-kiosk.sh
    fi
fi
EOF
    
    # 3. PROFILE AUTOSTART
    progress "Konfiguriere .profile autostart..."
    cat >> "$KIOSK_HOME/.profile" << 'EOF'

# ===== KIOSK AUTOSTART (PROFILE) =====
if [ -z "$SSH_CLIENT" ] && [ -z "$SSH_TTY" ] && [ -z "$KIOSK_STARTED" ]; then
    export KIOSK_STARTED=1
    
    # Starte X-Session falls nicht vorhanden
    if [ -z "$DISPLAY" ] && [ -z "$WAYLAND_DISPLAY" ] && [ "$(tty)" = "/dev/tty1" ]; then
        echo "Starte X-Session via .profile"
        exec startx
    fi
fi
EOF
    
    # 4. DESKTOP AUTOSTART
    progress "Konfiguriere XDG autostart..."
    sudo -u "$KIOSK_USER" mkdir -p "$KIOSK_HOME/.config/autostart"
    
    cat > "$KIOSK_HOME/.config/autostart/kiosk-app.desktop" << EOF
[Desktop Entry]
Type=Application
Name=MYP Kiosk Application
Comment=Startet die MYP Kiosk-Anwendung
Exec=$KIOSK_HOME/start-kiosk.sh
Hidden=false
NoDisplay=false
X-GNOME-Autostart-enabled=true
StartupNotify=false
EOF
    
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.config/autostart/kiosk-app.desktop"
    
    # 5. CRON AUTOSTART (ÜBERWACHUNG)
    progress "Konfiguriere Cron-Überwachung..."
    cat > "/etc/cron.d/kiosk-watchdog" << EOF
# Kiosk-Überwachung: Startet Kiosk neu falls nicht läuft
*/2 * * * * $KIOSK_USER /bin/bash -c 'if ! pgrep -f "chromium.*kiosk" > /dev/null; then echo "\$(date): Kiosk-Watchdog startet Anwendung neu" >> /var/log/kiosk-watchdog.log; DISPLAY=:0 $HOME/start-kiosk.sh & fi'
EOF
    
    # 6. RC.LOCAL FALLBACK
    progress "Konfiguriere rc.local Fallback..."
    cat > "/etc/rc.local" << EOF
#!/bin/bash
# rc.local - Kiosk-Fallback

# Warte auf System-Initialisierung
sleep 10

# Starte Kiosk-Services falls nicht läuft
if ! systemctl is-active --quiet lightdm; then
    systemctl start lightdm
fi

if ! systemctl is-active --quiet myp-druckerverwaltung; then
    systemctl start myp-druckerverwaltung
fi

# Logge Start
echo "\$(date): rc.local Kiosk-Fallback ausgeführt" >> /var/log/kiosk-fallback.log

exit 0
EOF
    
    chmod +x "/etc/rc.local"
    
    # 7. SYSTEMD SERVICE ÜBERWACHUNG  
    progress "Konfiguriere Service-Überwachung..."
    cat > "/etc/systemd/system/kiosk-watchdog.service" << EOF
[Unit]
Description=Kiosk Watchdog Service
After=multi-user.target

[Service]
Type=simple
User=root
ExecStart=/bin/bash -c 'while true; do if ! systemctl is-active --quiet myp-kiosk; then systemctl start myp-kiosk; fi; sleep 30; done'
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF
    
    systemctl enable kiosk-watchdog.service
    
    # Berechtigungen finalisieren
    chown -R "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.config"
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.bashrc"
    chown "$KIOSK_USER:$KIOSK_USER" "$KIOSK_HOME/.profile"
    
    log "✅ Mehrfache Autostart-Absicherung implementiert"
}

# ========================== AUTOSTART KONFIGURATION ==========================
configure_autostart() {
    log "=== PHASE 7: AUTOSTART-KONFIGURATION ==="
    
    # Systemd Service für Anwendung
    progress "Erstelle Systemd-Service für Anwendung..."
    cat > "/etc/systemd/system/myp-druckerverwaltung.service" << EOF
[Unit]
Description=MYP Druckerverwaltung Flask Application
After=network.target

[Service]
Type=simple
User=$APP_USER
Group=$APP_USER
WorkingDirectory=$APP_DIR
Environment=PATH=$APP_DIR/venv/bin
ExecStart=$APP_DIR/venv/bin/python app.py
Restart=always
RestartSec=10
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF
    
    # Systemd Service für LightDM Management (ersetzt den alten X-Server Service)
    progress "Erstelle Systemd-Service für Display Manager..."
    cat > "/etc/systemd/system/myp-display.service" << EOF
[Unit]
Description=MYP Display Manager Service
After=myp-druckerverwaltung.service network.target
Requires=myp-druckerverwaltung.service
Wants=myp-druckerverwaltung.service

[Service]
Type=oneshot
RemainAfterExit=yes
ExecStartPre=/bin/bash -c 'while ! curl -s http://localhost:5000 > /dev/null; do sleep 2; done'
ExecStart=/bin/systemctl start lightdm
ExecStop=/bin/systemctl stop lightdm
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=graphical.target
EOF
    
    # Systemd Service für Kiosk-Überwachung
    progress "Erstelle erweiterten Kiosk-Überwachungs-Service..."
    cat > "/etc/systemd/system/myp-kiosk-monitor.service" << EOF
[Unit]
Description=MYP Kiosk Monitor und Recovery Service
After=graphical.target lightdm.service
Requires=myp-druckerverwaltung.service

[Service]
Type=simple
User=root
ExecStart=/bin/bash -c '
    while true; do
        # Prüfe ob Anwendung läuft
        if ! curl -s http://localhost:5000 > /dev/null; then
            echo "\$(date): Anwendung nicht erreichbar - starte neu" >> /var/log/kiosk-monitor.log
            systemctl restart myp-druckerverwaltung
            sleep 10
        fi
        
        # Prüfe ob LightDM läuft
        if ! systemctl is-active --quiet lightdm; then
            echo "\$(date): LightDM nicht aktiv - starte neu" >> /var/log/kiosk-monitor.log
            systemctl start lightdm
            sleep 5
        fi
        
        # Prüfe ob Kiosk-Benutzer angemeldet ist
        if ! pgrep -u $KIOSK_USER > /dev/null; then
            echo "\$(date): Kiosk-Benutzer nicht angemeldet - starte LightDM neu" >> /var/log/kiosk-monitor.log
            systemctl restart lightdm
            sleep 10
        fi
        
        # Prüfe ob Chromium im Kiosk-Modus läuft
        if ! pgrep -u $KIOSK_USER -f "chromium.*kiosk" > /dev/null; then
            echo "\$(date): Chromium-Kiosk nicht gefunden - starte Kiosk-Session neu" >> /var/log/kiosk-monitor.log
            # Versuche Kiosk-Neustart als Kiosk-Benutzer
            sudo -u $KIOSK_USER DISPLAY=:0 $HOME/start-kiosk.sh &
        fi
        
        sleep 30
    done
'
Restart=always
RestartSec=10

[Install]
WantedBy=graphical.target
EOF
    
    # Nginx-Proxy-Konfiguration
    progress "Konfiguriere Nginx..."
    cat > "/etc/nginx/sites-available/myp-kiosk" << EOF
server {
    listen 80 default_server;
    listen [::]:80 default_server;
    
    server_name _;
    
    # Security Headers
    add_header X-Frame-Options DENY always;
    add_header X-Content-Type-Options nosniff always;
    add_header X-XSS-Protection "1; mode=block" always;
    add_header Referrer-Policy "no-referrer-when-downgrade" always;
    add_header Content-Security-Policy "default-src 'self'; script-src 'self' 'unsafe-inline'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self';" always;
    
    location / {
        proxy_pass http://127.0.0.1:5000;
        proxy_set_header Host \$host;
        proxy_set_header X-Real-IP \$remote_addr;
        proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto \$scheme;
        
        # WebSocket-Support
        proxy_http_version 1.1;
        proxy_set_header Upgrade \$http_upgrade;
        proxy_set_header Connection "upgrade";
        
        # Timeout-Konfiguration
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
    }
    
    # Statische Dateien
    location /static/ {
        alias $APP_DIR/static/;
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}
EOF
    
    # Nginx-Site aktivieren
    rm -f /etc/nginx/sites-enabled/default
    ln -sf /etc/nginx/sites-available/myp-kiosk /etc/nginx/sites-enabled/
    
    # Erstelle systemd-logind Konfiguration für besseres Session-Management
    progress "Konfiguriere systemd-logind für Kiosk..."
    cat > "/etc/systemd/logind.conf.d/kiosk.conf" << EOF
[Login]
# Verhindere dass System bei Inaktivität heruntergefahren wird
IdleAction=ignore
IdleActionSec=infinity

# Verhindere Suspend/Hibernate
HandlePowerKey=ignore
HandleSuspendKey=ignore
HandleHibernateKey=ignore
HandleLidSwitch=ignore

# Session-Einstellungen für Kiosk
KillUserProcesses=no
UserStopDelaySec=10

# Automatic VT allocation
ReserveVT=1
EOF
    
    # Erstelle PAM-Konfiguration für Auto-Login
    progress "Konfiguriere PAM für Auto-Login..."
    cat > "/etc/pam.d/lightdm-autologin" << EOF
# PAM configuration for LightDM autologin
auth     required  pam_env.so
auth     required  pam_permit.so
@include common-account
session  required  pam_limits.so
@include common-session
@include common-password
EOF
    
    # Services aktivieren
    progress "Aktiviere Services..."
    systemctl daemon-reload
    systemctl enable myp-druckerverwaltung
    systemctl enable nginx
    systemctl enable myp-display
    systemctl enable myp-kiosk-monitor
    
    # SSH standardmäßig deaktivieren für Sicherheit
    systemctl disable ssh || true
    
    # Sicherstellen dass graphical.target Standard ist
    systemctl set-default graphical.target
    
    # Erstelle systemd override für bessere Kiosk-Integration
    progress "Erstelle systemd-Overrides..."
    mkdir -p "/etc/systemd/system/lightdm.service.d"
    cat > "/etc/systemd/system/lightdm.service.d/kiosk-override.conf" << EOF
[Unit]
After=myp-druckerverwaltung.service

[Service]
# Automatischer Restart bei Fehlern
Restart=always
RestartSec=5

# Umgebungsvariablen für Kiosk
Environment=DISPLAY=:0
Environment=KIOSK_MODE=1
EOF
    
    log "✅ Autostart konfiguriert mit LightDM-Integration"
}

# ========================== SICHERHEIT ==========================
configure_security() {
    log "=== PHASE 8: SICHERHEITS-KONFIGURATION ==="
    
    progress "Konfiguriere Firewall..."
    ufw --force enable
    ufw default deny incoming
    ufw default allow outgoing
    ufw allow 22/tcp  # SSH
    ufw allow 80/tcp  # HTTP
    
    progress "Konfiguriere Fail2Ban..."
    cat > "/etc/fail2ban/jail.local" << EOF
[DEFAULT]
bantime = 600
findtime = 600
maxretry = 3

[sshd]
enabled = true
port = ssh
filter = sshd
logpath = /var/log/auth.log
maxretry = 3

[nginx-http-auth]
enabled = true
filter = nginx-http-auth
port = http,https
logpath = /var/log/nginx/error.log
maxretry = 5
EOF
    
    # Automatische Updates
    progress "Konfiguriere automatische Updates..."
    apt-get install -y unattended-upgrades
    echo 'Unattended-Upgrade::Automatic-Reboot "false";' > /etc/apt/apt.conf.d/50unattended-upgrades-local
    
    # Kiosk-Benutzer Einschränkungen
    progress "Beschränke Kiosk-Benutzer..."
    # Kein sudo für kiosk-Benutzer
    gpasswd -d "$KIOSK_USER" sudo 2>/dev/null || true
    
    # Shell auf /bin/false für bessere Sicherheit (aber X11 muss funktionieren)
    # usermod -s /bin/false "$KIOSK_USER"  # Erstmal nicht, da X11 funktionieren muss
    
    log "✅ Sicherheit konfiguriert"
}

# ========================== WARTUNGSTOOLS ==========================
create_maintenance_tools() {
    log "=== PHASE 9: WARTUNGSTOOLS ==="
    
    # Wartungsskript
    cat > "/usr/local/bin/myp-maintenance" << 'EOF'
#!/bin/bash

case "$1" in
    start)
        echo "Starte alle MYP-Services..."
        systemctl start myp-druckerverwaltung
        systemctl start nginx
        systemctl start myp-display
        systemctl start myp-kiosk-monitor
        echo "Services gestartet."
        ;;
    stop)
        echo "Stoppe alle MYP-Services..."
        systemctl stop myp-kiosk-monitor
        systemctl stop myp-display
        systemctl stop lightdm
        systemctl stop nginx
        systemctl stop myp-druckerverwaltung
        echo "Services gestoppt."
        ;;
    restart)
        echo "Starte alle MYP-Services neu..."
        systemctl restart myp-druckerverwaltung
        sleep 3
        systemctl restart nginx
        systemctl restart myp-display
        systemctl restart myp-kiosk-monitor
        echo "Services neugestartet."
        ;;
    status)
        echo "=== MYP SYSTEM STATUS ==="
        echo
        echo "📱 Anwendung:"
        systemctl status myp-druckerverwaltung --no-pager -l
        echo
        echo "🌐 Nginx Proxy:"
        systemctl status nginx --no-pager -l
        echo
        echo "🖥️ Display Manager:"
        systemctl status lightdm --no-pager -l
        echo
        echo "🔍 Kiosk Monitor:"
        systemctl status myp-kiosk-monitor --no-pager -l
        echo
        echo "👤 Kiosk-Benutzer-Sessions:"
        who | grep kiosk || echo "Kein Kiosk-Benutzer angemeldet"
        echo
        echo "🌐 Anwendung erreichbar:"
        if curl -s http://localhost:5000 > /dev/null; then
            echo "✅ http://localhost:5000 erreichbar"
        else
            echo "❌ http://localhost:5000 NICHT erreichbar"
        fi
        ;;
    logs)
        echo "=== ANWENDUNGS-LOGS (Strg+C zum Beenden) ==="
        journalctl -u myp-druckerverwaltung -f
        ;;
    kiosk-logs)
        echo "=== KIOSK-LOGS (Strg+C zum Beenden) ==="
        echo "Monitor-Logs:"
        journalctl -u myp-kiosk-monitor -f &
        echo "LightDM-Logs:"
        journalctl -u lightdm -f &
        echo "Session-Logs:"
        tail -f /var/log/kiosk-session.log 2>/dev/null &
        wait
        ;;
    app-restart)
        echo "Starte nur Anwendung neu..."
        systemctl restart myp-druckerverwaltung
        echo "Anwendung neugestartet."
        ;;
    kiosk-restart)
        echo "Starte nur Kiosk-Display neu..."
        systemctl restart lightdm
        echo "Kiosk-Display neugestartet."
        ;;
    monitor-restart)
        echo "Starte Kiosk-Monitor neu..."
        systemctl restart myp-kiosk-monitor
        echo "Kiosk-Monitor neugestartet."
        ;;
    enable-ssh)
        echo "Aktiviere SSH für Wartung..."
        systemctl enable ssh
        systemctl start ssh
        echo "✅ SSH aktiviert für Remote-Wartung"
        echo "SSH-Status: $(systemctl is-active ssh)"
        echo "IP-Adresse: $(hostname -I | awk '{print $1}')"
        ;;
    disable-ssh)
        echo "Deaktiviere SSH für Sicherheit..."
        systemctl stop ssh
        systemctl disable ssh
        echo "✅ SSH deaktiviert"
        ;;
    exit-kiosk)
        echo "🔐 KIOSK-MODUS BEENDEN"
        echo "WARNUNG: Stoppt den Kiosk und aktiviert Wartungsmodus!"
        echo "Passwort erforderlich für Sicherheit."
        read -s -p "Kiosk-Passwort: " password
        echo
        if [ "$password" = "744563017196A" ]; then
            echo "✅ Passwort korrekt - beende Kiosk-Modus..."
            systemctl stop myp-kiosk-monitor
            systemctl stop lightdm
            systemctl enable ssh
            systemctl start ssh
            echo "🔧 Wartungsmodus aktiviert:"
            echo "  • Kiosk gestoppt"
            echo "  • SSH aktiviert"
            echo "  • Console verfügbar"
            echo "Kiosk-Neustart mit: myp-maintenance start"
        else
            echo "❌ Falsches Passwort! Kiosk bleibt aktiv."
            exit 1
        fi
        ;;
    enter-kiosk)
        echo "Aktiviere Kiosk-Modus..."
        systemctl disable ssh 2>/dev/null || true
        systemctl stop ssh 2>/dev/null || true
        systemctl start myp-druckerverwaltung
        systemctl start nginx
        systemctl start myp-display
        systemctl start myp-kiosk-monitor
        echo "✅ Kiosk-Modus aktiviert"
        ;;
    check-health)
        echo "=== SYSTEM-GESUNDHEITSCHECK ==="
        echo
        # Services-Check
        echo "📋 Service-Status:"
        for service in myp-druckerverwaltung nginx lightdm myp-kiosk-monitor; do
            if systemctl is-active --quiet $service; then
                echo "  ✅ $service: aktiv"
            else
                echo "  ❌ $service: INAKTIV"
            fi
        done
        echo
        
        # Netzwerk-Check
        echo "🌐 Netzwerk-Status:"
        if curl -s http://localhost:5000 > /dev/null; then
            echo "  ✅ Anwendung erreichbar"
        else
            echo "  ❌ Anwendung NICHT erreichbar"
        fi
        echo
        
        # Kiosk-Check
        echo "🖥️ Kiosk-Status:"
        if pgrep -u kiosk > /dev/null; then
            echo "  ✅ Kiosk-Benutzer angemeldet"
        else
            echo "  ❌ Kiosk-Benutzer NICHT angemeldet"
        fi
        
        if pgrep -f "chromium.*kiosk" > /dev/null; then
            echo "  ✅ Chromium-Kiosk läuft"
        else
            echo "  ❌ Chromium-Kiosk läuft NICHT"
        fi
        echo
        
        # Ressourcen-Check
        echo "💾 System-Ressourcen:"
        echo "  CPU: $(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)% belegt"
        echo "  RAM: $(free | grep Mem | awk '{printf "%.1f%%", $3/$2 * 100.0}')"
        echo "  Disk: $(df / | tail -1 | awk '{print $5}')"
        ;;
    auto-fix)
        echo "🔧 AUTOMATISCHE REPARATUR"
        echo "Versuche häufige Probleme zu beheben..."
        
        # Services neu starten
        echo "1. Starte Services neu..."
        systemctl restart myp-druckerverwaltung
        sleep 3
        systemctl restart nginx
        systemctl restart lightdm
        systemctl restart myp-kiosk-monitor
        
        # Berechtigungen reparieren
        echo "2. Repariere Berechtigungen..."
        chown -R kiosk:kiosk /home/kiosk
        chown -R myp:myp /opt/myp-druckerverwaltung
        
        # Logs bereinigen
        echo "3. Bereinige alte Logs..."
        journalctl --rotate
        journalctl --vacuum-time=7d
        
        echo "✅ Automatische Reparatur abgeschlossen"
        echo "Prüfe Status mit: myp-maintenance check-health"
        ;;
    *)
        echo "MYP Druckerverwaltung - Wartungstool"
        echo
        echo "VERWENDUNG: $0 BEFEHL"
        echo
        echo "SERVICE-MANAGEMENT:"
        echo "  start               Alle Services starten"
        echo "  stop                Alle Services stoppen"
        echo "  restart             Alle Services neustarten"
        echo "  status              Detaillierter Status aller Services"
        echo
        echo "EINZELNE SERVICES:"
        echo "  app-restart         Nur Anwendung neustarten"
        echo "  kiosk-restart       Nur Kiosk-Display neustarten"
        echo "  monitor-restart     Nur Kiosk-Monitor neustarten"
        echo
        echo "LOGS & MONITORING:"
        echo "  logs                Live Anwendungs-Logs anzeigen"
        echo "  kiosk-logs          Live Kiosk-Logs anzeigen"
        echo "  check-health        System-Gesundheitscheck"
        echo
        echo "KIOSK-KONTROLLE:"
        echo "  exit-kiosk          Kiosk beenden (Passwort: 744563017196A)"
        echo "  enter-kiosk         Kiosk-Modus aktivieren"
        echo
        echo "WARTUNG:"
        echo "  enable-ssh          SSH für Remote-Wartung aktivieren"
        echo "  disable-ssh         SSH wieder deaktivieren"
        echo "  auto-fix            Automatische Problemreparatur"
        echo
        echo "BEISPIELE:"
        echo "  $0 status           # System-Status anzeigen"
        echo "  $0 logs             # Live-Logs verfolgen"
        echo "  $0 exit-kiosk       # Wartungsmodus aktivieren"
        ;;
esac
EOF
    
    chmod +x /usr/local/bin/myp-maintenance
    
    # Backup-Skript
    cat > "/usr/local/bin/myp-backup" << EOF
#!/bin/bash
BACKUP_DIR="$BACKUP_DIR"
DATE=\$(date +%Y%m%d_%H%M%S)
mkdir -p "\$BACKUP_DIR"

echo "Erstelle MYP-System-Backup..."

# Services kurz stoppen für konsistentes Backup
systemctl stop myp-druckerverwaltung

# Erstelle Backup
tar -czf "\$BACKUP_DIR/myp_backup_\$DATE.tar.gz" \\
    -C "$APP_DIR" \\
    --exclude='node_modules' \\
    --exclude='__pycache__' \\
    --exclude='venv' \\
    --exclude='*.log' \\
    database.db .env uploads/ config/ 2>/dev/null || true

# Backup der Kiosk-Konfiguration
tar -czf "\$BACKUP_DIR/kiosk_config_\$DATE.tar.gz" \\
    /home/kiosk/.config \\
    /etc/lightdm/lightdm.conf \\
    /usr/share/lightdm/setup-kiosk-session.sh \\
    /etc/systemd/system/myp-*.service \\
    /usr/local/bin/myp-* 2>/dev/null || true

# Services wieder starten
systemctl start myp-druckerverwaltung

echo "✅ Backup erstellt:"
echo "  Anwendung: \$BACKUP_DIR/myp_backup_\$DATE.tar.gz"
echo "  Kiosk-Config: \$BACKUP_DIR/kiosk_config_\$DATE.tar.gz"

# Alte Backups löschen (älter als 30 Tage)
find "\$BACKUP_DIR" -name "myp_backup_*.tar.gz" -mtime +30 -delete 2>/dev/null || true
find "\$BACKUP_DIR" -name "kiosk_config_*.tar.gz" -mtime +30 -delete 2>/dev/null || true

echo "🧹 Alte Backups (>30 Tage) entfernt"
EOF
    
    chmod +x /usr/local/bin/myp-backup
    
    # Notfall-Reset
    cat > "/usr/local/bin/myp-emergency-reset" << 'EOF'
#!/bin/bash
echo "🚨 NOTFALL-RESET für MYP Kiosk-System"
echo "======================================"
echo
echo "WARNUNG: Dieser Befehl wird:"
echo "  • Alle Kiosk-Services stoppen"
echo "  • SSH für Remote-Wartung aktivieren" 
echo "  • Console-Zugang ermöglichen"
echo "  • System in Wartungsmodus versetzen"
echo
echo "Nur bei kritischen Problemen verwenden!"
echo
read -p "Notfall-Reset durchführen? (RESET eingeben): " confirm

if [ "$confirm" = "RESET" ]; then
    echo
    echo "🔧 Führe Notfall-Reset durch..."
    
    # Stoppe alle Kiosk-Services
    systemctl stop myp-kiosk-monitor 2>/dev/null || true
    systemctl stop lightdm 2>/dev/null || true
    
    # Aktiviere SSH
    systemctl enable ssh 2>/dev/null || true
    systemctl start ssh 2>/dev/null || true
    
    # Logge Reset
    echo "$(date): Notfall-Reset durchgeführt" >> /var/log/emergency-reset.log
    
    echo "✅ Notfall-Reset abgeschlossen!"
    echo
    echo "📋 AKTUELLE SITUATION:"
    echo "  • Kiosk-Modus: GESTOPPT"
    echo "  • SSH: AKTIVIERT für Remote-Wartung"
    echo "  • Console: Verfügbar auf TTY1-6 (Strg+Alt+F1-F6)"
    echo "  • IP-Adresse: $(hostname -I | awk '{print $1}')"
    echo
    echo "🔧 WARTUNGSOPTIONEN:"
    echo "  • Status prüfen:     myp-maintenance status"
    echo "  • Gesundheitscheck:  myp-maintenance check-health"
    echo "  • Automatische Fix:  myp-maintenance auto-fix"
    echo "  • Kiosk reaktivieren: myp-maintenance enter-kiosk"
    echo
else
    echo "❌ Abgebrochen. System bleibt unverändert."
fi
EOF
    
    chmod +x /usr/local/bin/myp-emergency-reset
    
    # Erweiterte Cron-Jobs
    cat > "/etc/cron.d/myp-system" << EOF
# MYP System Maintenance Cron Jobs

# Tägliches Backup um 2:00 Uhr
0 2 * * * root /usr/local/bin/myp-backup >> /var/log/myp-backup.log 2>&1

# Gesundheitscheck alle 10 Minuten
*/10 * * * * root /usr/local/bin/myp-maintenance check-health > /dev/null 2>&1 || echo "\$(date): Health check failed" >> /var/log/myp-health.log

# Log-Rotation wöchentlich (Sonntags um 3:00)
0 3 * * 0 root journalctl --rotate && journalctl --vacuum-time=30d

# System-Ressourcen-Log alle 5 Minuten
*/5 * * * * root echo "\$(date),\$(cat /proc/loadavg | cut -d' ' -f1-3),\$(free | grep Mem | awk '{printf \"%.1f\", \$3/\$2 * 100.0}')" >> /var/log/system-resources.log
EOF
    
    log "✅ Erweiterte Wartungstools erstellt"
}

# ========================== FINALE KONFIGURATION ==========================
finalize_installation() {
    log "=== PHASE 10: FINALISIERUNG ==="
    
    # Services starten
    progress "Starte Services..."
    systemctl start myp-druckerverwaltung
    sleep 3
    systemctl start nginx
    
    # Warte und prüfe Services
    sleep 5
    
    if systemctl is-active --quiet myp-druckerverwaltung; then
        log "✅ MYP-Anwendung läuft"
    else
        warning "⚠️ MYP-Anwendung nicht aktiv"
    fi
    
    if systemctl is-active --quiet nginx; then
        log "✅ Nginx läuft"
    else
        warning "⚠️ Nginx nicht aktiv"
    fi
    
    # Test ob Anwendung erreichbar ist
    progress "Teste Anwendung..."
    for i in {1..30}; do
        if curl -s http://localhost:5000 > /dev/null; then
            log "✅ Anwendung erreichbar unter http://localhost:5000"
            break
        else
            if [ $i -eq 30 ]; then
                warning "⚠️ Anwendung nach 30 Versuchen nicht erreichbar"
            else
                sleep 2
            fi
        fi
    done
    
    # Chromium-Test
    progress "Teste Chromium-Installation..."
    if [[ "$CHROMIUM_BIN" == "flatpak"* ]]; then
        sudo -u "$KIOSK_USER" flatpak run org.chromium.Chromium --version > /dev/null 2>&1 && log "✅ Chromium (Flatpak) funktional" || warning "⚠️ Chromium (Flatpak) Test fehlgeschlagen"
    else
        sudo -u "$KIOSK_USER" "$CHROMIUM_BIN" --version > /dev/null 2>&1 && log "✅ Chromium funktional" || warning "⚠️ Chromium-Test fehlgeschlagen"
    fi
    
    # Teste Auto-Login-Konfiguration
    progress "Teste Auto-Login-Konfiguration..."
    if [ -f "/etc/lightdm/lightdm.conf" ] && grep -q "autologin-user=$KIOSK_USER" "/etc/lightdm/lightdm.conf"; then
        log "✅ Auto-Login für $KIOSK_USER konfiguriert"
    else
        warning "⚠️ Auto-Login-Konfiguration unvollständig"
    fi
    
    # Teste Systemd-Services
    progress "Teste Service-Konfiguration..."
    for service in myp-druckerverwaltung myp-display myp-kiosk-monitor; do
        if systemctl is-enabled --quiet "$service" 2>/dev/null; then
            log "✅ Service $service aktiviert"
        else
            warning "⚠️ Service $service nicht aktiviert"
        fi
    done
    
    # Teste Wartungstools
    progress "Teste Wartungstools..."
    if [ -x "/usr/local/bin/myp-maintenance" ]; then
        log "✅ myp-maintenance verfügbar"
    else
        warning "⚠️ myp-maintenance nicht verfügbar"
    fi
    
    if [ -x "/usr/local/bin/myp-backup" ]; then
        log "✅ myp-backup verfügbar"
    else
        warning "⚠️ myp-backup nicht verfügbar"
    fi
    
    if [ -x "/usr/local/bin/myp-emergency-reset" ]; then
        log "✅ myp-emergency-reset verfügbar"
    else
        warning "⚠️ myp-emergency-reset nicht verfügbar"
    fi
    
    # Erstelle erste Logs
    progress "Initialisiere Logging..."
    touch /var/log/kiosk-session.log
    touch /var/log/kiosk-monitor.log
    touch /var/log/kiosk-watchdog.log
    touch /var/log/emergency-reset.log
    touch /var/log/myp-backup.log
    touch /var/log/myp-health.log
    touch /var/log/system-resources.log
    
    # Berechtigungen setzen
    chown syslog:adm /var/log/kiosk-*.log
    chown syslog:adm /var/log/myp-*.log
    chown syslog:adm /var/log/emergency-reset.log
    chown syslog:adm /var/log/system-resources.log
    
    # Finale Berechtigungen
    chown -R "$APP_USER:$APP_USER" "$APP_DIR"
    chown -R "$KIOSK_USER:$KIOSK_USER" "/home/$KIOSK_USER"
    
    # System-Target finalisieren
    systemctl set-default graphical.target
    
    log "✅ Installation finalisiert"
}

# ========================== INSTALLATIONS-BERICHT ==========================
show_installation_report() {
    local ip_address=$(hostname -I | awk '{print $1}')
    
    cat << EOF

╔══════════════════════════════════════════════════════════════╗
║              🎉 KIOSK-INSTALLATION ERFOLGREICH! 🎉           ║
╚══════════════════════════════════════════════════════════════╝

📋 INSTALLATIONS-ZUSAMMENFASSUNG:
   • System-Typ: Vollautomatischer Sicherheits-Kiosk
   • Anwendung: $APP_DIR
   • Kiosk-URL: http://$ip_address (nach Neustart)
   • Chromium: $CHROMIUM_BIN
   • Display Manager: LightDM mit Auto-Login
   • Kiosk-Benutzer: $KIOSK_USER (automatisch angemeldet)
   • App-Benutzer: $APP_USER

🛡️ SICHERHEITS-FEATURES:
   • Desktop-Flucht: Vollständig verhindert
   • Tastatur-Shortcuts: Alle deaktiviert
   • Browser-Escape: Unmöglich (Kiosk-Flags)
   • SSH: Standardmäßig deaktiviert
   • Firewall: Aktiv mit Fail2Ban-Schutz
   • Auto-Login: Sicher konfiguriert
   • Session-Isolation: Kiosk-Benutzer ohne sudo

🔧 AUTOSTART-ABSICHERUNG (7-fach):
   ✅ 1. LightDM Auto-Login
   ✅ 2. Systemd User-Service  
   ✅ 3. Bashrc Autostart
   ✅ 4. Profile Autostart
   ✅ 5. XDG Desktop Autostart
   ✅ 6. Cron Watchdog
   ✅ 7. RC.Local Fallback

🚀 SYSTEMD-SERVICES:
   • myp-druckerverwaltung.service → Flask-Anwendung
   • myp-display.service → LightDM-Management  
   • myp-kiosk-monitor.service → Kiosk-Überwachung + Recovery
   • nginx.service → Reverse-Proxy
   • lightdm.service → Display Manager mit Auto-Login

🔧 WARTUNGSTOOLS:
   📱 myp-maintenance:
      • status           - Detaillierter System-Status
      • restart          - Alle Services neustarten  
      • exit-kiosk       - Wartungsmodus (Passwort: 744563017196A)
      • enable-ssh       - SSH für Remote-Wartung
      • check-health     - Automatischer Gesundheitscheck
      • auto-fix         - Automatische Problemreparatur
   
   💾 myp-backup:
      • Automatisch: Täglich 2:00 Uhr
      • Manuell: myp-backup
      • Aufbewahrung: 30 Tage
   
   🚨 myp-emergency-reset:
      • Notfall-Tool bei kritischen Problemen
      • Stoppt Kiosk, aktiviert SSH

📊 MONITORING & LOGS:
   • System-Health: Alle 10 Minuten automatisch
   • Resource-Logs: Alle 5 Minuten
   • Service-Überwachung: Kontinuierlich mit Auto-Recovery
   • Log-Rotation: Wöchentlich (30 Tage Aufbewahrung)

⚠️ WICHTIGE HINWEISE:
   • System bootet automatisch in VOLLBILD-KIOSK ohne Escape
   • Kein Desktop verfügbar - nur MYP-Anwendung sichtbar
   • SSH deaktiviert für maximale Sicherheit
   • Bei Problemen: Console-Zugang via Strg+Alt+F1-F6

🔐 NOTFALL-ZUGANG:
   1. Console: Strg+Alt+F1 bis F6 → Login als Root/sudo-User
   2. Emergency: myp-emergency-reset → RESET eingeben
   3. Remote: myp-maintenance enable-ssh → SSH verfügbar

🚀 NÄCHSTE SCHRITTE:
   1. System neustarten: sudo reboot
   2. ⏱️ System bootet in ~2 Minuten automatisch in Kiosk-Modus
   3. 🖥️ Chromium startet automatisch im Vollbild
   4. 📱 MYP-Anwendung verfügbar unter http://$ip_address
   5. 🔒 Kein Escape möglich - echtes Kiosk-System

📞 WARTUNG & SUPPORT:
   • Live Status: myp-maintenance status
   • Logs verfolgen: myp-maintenance logs  
   • Kiosk beenden: myp-maintenance exit-kiosk
   • Gesundheitscheck: myp-maintenance check-health
   • Backup erstellen: myp-backup

🎯 LEISTUNGS-FEATURES:
   ✅ Multi-Browser-Fallback (APT → Snap → Flatpak)
   ✅ Service-Recovery bei Fehlern
   ✅ Session-Monitoring mit Auto-Restart
   ✅ Resource-Monitoring und Logging
   ✅ Automatische Backups mit Rotation
   ✅ Health-Checks mit Auto-Fix
   ✅ Emergency-Recovery-System

══════════════════════════════════════════════════════════════

Installation abgeschlossen: $(date)
Installationslog: $INSTALL_LOG

SYSTEM BEREIT FÜR PRODUKTIONS-KIOSK-BETRIEB! 🚀

══════════════════════════════════════════════════════════════

EOF
}

# ========================== HAUPTPROGRAMM ==========================
main() {
    log "🚀 MYP Kiosk-Installation gestartet: $(date)"
    
    check_root
    detect_system
    cleanup_system
    install_packages
    install_chromium
    create_users
    install_application
    configure_kiosk
    configure_autologin
    configure_multiple_autostart
    configure_autostart
    configure_security
    create_maintenance_tools
    finalize_installation
    
    show_installation_report
    
    # Abschließende Frage
    echo
    read -p "🔄 System jetzt neustarten für Kiosk-Modus? (j/N): " reboot_choice
    if [[ "$reboot_choice" =~ ^[jJ]$ ]]; then
        log "🚀 Neustart für Kiosk-Modus..."
        sleep 3
        reboot
    else
        log "⚠️ Manueller Neustart erforderlich: sudo reboot"
    fi
}

# ========================== PROGRAMMSTART ==========================
# Starte Installation
main "$@"