#!/bin/bash
#
# SHIFTDECK - Update-Manager v2
# Erkennt automatisch die neueste Version und aktualisiert SHIFTDECK
#
# Verwendung:
#   curl -fsSLk https://shiftdeck.de/download/update.sh | bash   # Auto-Update
#   ./update.sh                                                    # Auto-Update
#   ./update.sh --version 6.01                                     # Bestimmte Version
#   ./update.sh --rebuild                                          # Nur Docker neu bauen
#   ./update.sh --status                                           # Status anzeigen
#

set -e

# ═══════════════════════════════════════════════════════════════
# KONFIGURATION
# ═══════════════════════════════════════════════════════════════

# Auto-Detect Installationspfad
auto_detect_install_dir() {
    # 1. Umgebungsvariable
    [ -n "$SHIFTDECK_INSTALL_DIR" ] && echo "$SHIFTDECK_INSTALL_DIR" && return
    # 2. Bekannte Pfade prüfen
    for dir in /opt/shiftdeck /root/shiftdeck /root/admin-customer /root/admin-server \
               /home/*/shiftdeck /home/*/admin-customer /srv/shiftdeck \
               /opt/admin-customer /opt/webwi; do
        if [ -f "$dir/docker-compose.yml" ] || [ -f "$dir/docker-compose.prod.yml" ]; then
            echo "$dir" && return
        fi
    done
    # 3. Suche nach docker-compose.yml mit SHIFTDECK/shiftdeck in /root und /opt
    for base in /root /opt /home/*; do
        found=$(find "$base" -maxdepth 2 -name "docker-compose.yml" -exec grep -l -i "shiftdeck\|admin-server\|webwi" {} \; 2>/dev/null | head -1)
        if [ -n "$found" ]; then
            echo "$(dirname "$found")" && return
        fi
    done
    # 4. Aktuelles Verzeichnis prüfen
    if [ -f "./docker-compose.yml" ] || [ -f "./docker-compose.prod.yml" ]; then
        pwd && return
    fi
    # 5. Default
    echo "/opt/shiftdeck"
}

INSTALL_DIR="$(auto_detect_install_dir)"
# v7.243: Hauptkanal — Pakete aus /download/ (Stable-Releases)
SHIFTDECK_CHANNEL="beta"
DOWNLOAD_BASE="https://shiftdeck.de/download/Beta-Tester"
FTP_HOST="202.61.233.195"
FTP_USER="shiftdeck"
FTP_PASS="East873wolf411!!"
BACKUP_DIR="/opt/shiftdeck-backups"

# Farben
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
CYAN='\033[0;36m'
BOLD='\033[1m'
DIM='\033[2m'
NC='\033[0m'

CHECK="✓"
CROSS="✗"
ARROW="→"
ROCKET="🚀"

print_success() { echo -e "${GREEN}${CHECK}${NC} $1"; }
print_error()   { echo -e "${RED}${CROSS}${NC} $1"; }
print_warning() { echo -e "${YELLOW}!${NC} $1"; }
print_info()    { echo -e "${CYAN}ℹ${NC} $1"; }
print_step()    { echo -e "${BLUE}${ARROW}${NC} $1"; }

# ═══════════════════════════════════════════════════════════════
# BANNER
# ═══════════════════════════════════════════════════════════════
show_banner() {
    # SHIFTDECK-Wortmarke im Marken-Verlauf Gold→Orange (linear-gradient 135°, #f5b82e → #d97706)
    local g1='\033[38;2;245;184;46m' g2='\033[38;2;239;171;38m' g3='\033[38;2;234;158;30m'
    local g4='\033[38;2;228;145;22m' g5='\033[38;2;223;132;14m' g6='\033[38;2;217;119;6m'
    local gold='\033[38;2;245;184;46m'
    echo ""
    echo -e "${g1}    ███████╗██╗  ██╗██╗███████╗████████╗██████╗ ███████╗ ██████╗██╗  ██╗${NC}"
    echo -e "${g2}    ██╔════╝██║  ██║██║██╔════╝╚══██╔══╝██╔══██╗██╔════╝██╔════╝██║ ██╔╝${NC}"
    echo -e "${g3}    ███████╗███████║██║█████╗     ██║   ██║  ██║█████╗  ██║     █████╔╝${NC}"
    echo -e "${g4}    ╚════██║██╔══██║██║██╔══╝     ██║   ██║  ██║██╔══╝  ██║     ██╔═██╗${NC}"
    echo -e "${g5}    ███████║██║  ██║██║██║        ██║   ██████╔╝███████╗╚██████╗██║  ██╗${NC}"
    echo -e "${g6}    ╚══════╝╚═╝  ╚═╝╚═╝╚═╝        ╚═╝   ╚═════╝ ╚══════╝ ╚═════╝╚═╝  ╚═╝${NC}"
    echo ""
    echo -e "        ${gold}${BOLD}Zeiterfassung für moderne Teams${NC}"
    echo ""
    echo -e "        ${YELLOW}${BOLD}● Beta-Kanal${NC}   ${DIM}│${NC}   ${BOLD}Update-Manager${NC}   ${DIM}│${NC}   ${DIM}${DOWNLOAD_BASE}${NC}"
    echo -e "        ${DIM}Installationspfad: ${INSTALL_DIR}${NC}"
    echo -e "        ${DIM}────────────────────────────────────────────────────${NC}"
    echo ""
}

# ═══════════════════════════════════════════════════════════════
# HILFSFUNKTIONEN
# ═══════════════════════════════════════════════════════════════

get_current_version() {
    if [ -f "$INSTALL_DIR/VERSION" ]; then
        cat "$INSTALL_DIR/VERSION" | tr -d '[:space:]'
    else
        echo "0.00"
    fi
}

# Neueste Version vom Server ermitteln (3 Methoden)
get_latest_version() {
    local latest=""

    # Methode 1: VERSION-Datei auf dem Server
    latest=$(curl -fsSLk "${DOWNLOAD_BASE}/VERSION" 2>/dev/null | tr -d '[:space:]')
    if [ -n "$latest" ] && [[ "$latest" =~ ^[0-9]+\.[0-9]+$ ]]; then
        echo "$latest"
        return 0
    fi

    # Methode 2: install.sh auf dem Server parsen
    latest=$(curl -fsSLk "${DOWNLOAD_BASE}/install.sh" 2>/dev/null | grep 'SHIFTDECK_VERSION=' | head -1 | sed 's/.*"\(.*\)".*/\1/')
    if [ -n "$latest" ] && [[ "$latest" =~ ^[0-9]+\.[0-9]+$ ]]; then
        echo "$latest"
        return 0
    fi

    # Methode 3: FTP Verzeichnis nach höchster shiftdeck-core-X.XX durchsuchen
    latest=$(curl -fsSL "ftp://${FTP_HOST}/" --user "${FTP_USER}:${FTP_PASS}" 2>/dev/null \
        | grep -oP "shiftdeck-core-\K[0-9]+\.[0-9]+" | sort -t. -k1,1n -k2,2n | tail -1)
    if [ -n "$latest" ]; then
        echo "$latest"
        return 0
    fi

    echo ""
}

# Versionsvergleich: 0 wenn $1 > $2
version_gt() {
    local v1_major=$(echo "$1" | cut -d. -f1)
    local v1_minor=$(echo "$1" | cut -d. -f2)
    local v2_major=$(echo "$2" | cut -d. -f1)
    local v2_minor=$(echo "$2" | cut -d. -f2)
    if [ "$v1_major" -gt "$v2_major" ] 2>/dev/null; then return 0; fi
    if [ "$v1_major" -eq "$v2_major" ] && [ "$v1_minor" -gt "$v2_minor" ] 2>/dev/null; then return 0; fi
    return 1
}

# Docker Compose finden
find_compose() {
    if [ -f "$INSTALL_DIR/docker-compose.prod.yml" ]; then
        COMPOSE_FILE="docker-compose.prod.yml"
    elif [ -f "$INSTALL_DIR/docker-compose.yml" ]; then
        COMPOSE_FILE="docker-compose.yml"
    else
        print_error "Keine docker-compose Datei gefunden in $INSTALL_DIR"
        echo ""
        print_info "Mögliche Lösungen:"
        echo -e "  ${CYAN}1.${NC} Pfad angeben:  ${BOLD}SHIFTDECK_INSTALL_DIR=/pfad/zur/installation bash update.sh${NC}"
        echo -e "  ${CYAN}2.${NC} In Verzeichnis wechseln:  ${BOLD}cd /pfad/zur/installation && bash update.sh${NC}"
        echo ""
        # Suche nach möglichen Installationen
        local possible=""
        for dir in /root/* /opt/* /home/*/*; do
            [ -f "$dir/docker-compose.yml" ] 2>/dev/null && possible="$possible  $dir\n"
        done
        if [ -n "$possible" ]; then
            print_info "Gefundene docker-compose.yml Verzeichnisse:"
            echo -e "$possible"
        fi
        exit 1
    fi

    if docker compose version &>/dev/null; then
        DOCKER_COMPOSE="docker compose"
    elif command -v docker-compose &>/dev/null; then
        DOCKER_COMPOSE="docker-compose"
    else
        print_error "Docker Compose nicht gefunden!"
        exit 1
    fi
}

# ═══════════════════════════════════════════════════════════════
# DOWNLOAD – HTTPS mit FTP-Fallback
# ═══════════════════════════════════════════════════════════════
download_file() {
    local filename="$1"
    local output="$2"
    local label="$3"

    # Prüfe ob Download ein gültiges gzip/tar ist
    verify_archive() {
        local f="$1"
        [ ! -f "$f" ] && return 1
        [ ! -s "$f" ] && return 1
        # Methode 1: file-Befehl
        if command -v file &>/dev/null; then
            file "$f" 2>/dev/null | grep -q "gzip\|tar" && return 0
        fi
        # Methode 2: gzip magic bytes (1f 8b)
        local magic=$(od -A n -t x1 -N 2 "$f" 2>/dev/null | tr -d ' ')
        [ "$magic" = "1f8b" ] && return 0
        # Methode 3: tar test
        tar tzf "$f" &>/dev/null && return 0
        return 1
    }

    # 1. HTTPS
    if curl -fSLk "${DOWNLOAD_BASE}/${filename}" -o "$output" --progress-bar 2>/dev/null; then
        if verify_archive "$output"; then
            print_success "$label (HTTPS)"
            return 0
        fi
    fi
    rm -f "$output"

    # 2. FTP Fallback
    if curl -fSL "ftp://${FTP_HOST}/${filename}" --user "${FTP_USER}:${FTP_PASS}" -o "$output" --progress-bar 2>/dev/null; then
        if verify_archive "$output"; then
            print_success "$label (FTP-Fallback)"
            return 0
        fi
    fi
    rm -f "$output"

    return 1
}

# ═══════════════════════════════════════════════════════════════
# BACKUP
# ═══════════════════════════════════════════════════════════════
create_backup() {
    local current_version=$(get_current_version)
    local backup_name="shiftdeck-backup-v${current_version}-$(date +%Y%m%d_%H%M%S)"

    print_step "Erstelle Backup..."
    mkdir -p "$BACKUP_DIR"

    # .env sichern
    [ -f "$INSTALL_DIR/.env" ] && cp "$INSTALL_DIR/.env" "$BACKUP_DIR/${backup_name}.env"
    [ -f "$INSTALL_DIR/VERSION" ] && cp "$INSTALL_DIR/VERSION" "$BACKUP_DIR/${backup_name}.version"

    # Alte Backups aufräumen (nur letzte 5)
    ls -t "$BACKUP_DIR"/*.env 2>/dev/null | tail -n +6 | xargs rm -f 2>/dev/null || true

    print_success "Backup erstellt: ${backup_name}"
}

# ═══════════════════════════════════════════════════════════════
# PAKETE HERUNTERLADEN & INSTALLIEREN
# ═══════════════════════════════════════════════════════════════
download_and_install() {
    local target_version="$1"
    local tmpdir="/tmp/shiftdeck-update-$$"
    mkdir -p "$tmpdir"

    echo ""
    print_step "Lade SHIFTDECK v${target_version} herunter..."
    echo ""

    local CORE_OK=false

    # ── Core-Paket (Pflicht) ──
    print_info "Core-Paket (~1.4 MB)..."
    if download_file "shiftdeck-core-${target_version}.tar.gz" "$tmpdir/core.tar.gz" "Core-Paket"; then
        CORE_OK=true
    elif download_file "shiftdeck-${target_version}.tar.gz" "$tmpdir/core.tar.gz" "Komplett-Paket"; then
        CORE_OK=true
    fi

    if [ "$CORE_OK" = false ]; then
        print_error "Core-Paket konnte nicht heruntergeladen werden!"
        print_info "Prüfen Sie ob v${target_version} auf shiftdeck.de/download/ verfügbar ist"
        rm -rf "$tmpdir"
        exit 1
    fi

    # ── Docs-Paket (Optional) ──
    print_info "Docs-Paket (~30 KB)..."
    download_file "shiftdeck-docs-${target_version}.tar.gz" "$tmpdir/docs.tar.gz" "Docs-Paket" || \
        print_warning "Docs-Paket nicht verfügbar (nicht kritisch)"

    echo ""

    # ── Entpacken ──
    print_step "Entpacke Pakete..."
    cd "$tmpdir"

    tar xzf core.tar.gz
    rm -f core.tar.gz

    # Unterverzeichnis auflösen
    EXTRACTED_DIR=$(find . -maxdepth 1 -type d -name "shiftdeck*" | head -1)
    if [ -n "$EXTRACTED_DIR" ] && [ "$EXTRACTED_DIR" != "." ]; then
        rsync -a "$EXTRACTED_DIR/" ./ 2>/dev/null || cp -r "$EXTRACTED_DIR"/* . 2>/dev/null || true
        rm -rf "$EXTRACTED_DIR"
    fi

    # Docs entpacken
    if [ -f "docs.tar.gz" ]; then
        tar xzf docs.tar.gz
        rm -f docs.tar.gz
        DOCS_DIR=$(find . -maxdepth 1 -type d -name "shiftdeck-docs*" | head -1)
        if [ -n "$DOCS_DIR" ] && [ "$DOCS_DIR" != "." ]; then
            rsync -a "$DOCS_DIR/" ./ 2>/dev/null || cp -r "$DOCS_DIR"/* . 2>/dev/null || true
            rm -rf "$DOCS_DIR"
        fi
    fi

    print_success "Pakete entpackt"

    # ── Dateien installieren ──
    echo ""
    print_step "Installiere Dateien..."

    # Backend
    if [ -d "backend" ]; then
        rsync -a --delete "backend/" "$INSTALL_DIR/backend/"
        print_success "  Backend aktualisiert"
    fi

    # Frontend (ohne node_modules/build)
    if [ -d "frontend" ]; then
        rsync -a --delete --exclude='node_modules' --exclude='build' "frontend/" "$INSTALL_DIR/frontend/"
        print_success "  Frontend aktualisiert"
    fi

    # Optionale Verzeichnisse
    [ -d "config" ] && rsync -a "config/" "$INSTALL_DIR/config/"
    [ -d "templates" ] && rsync -a "templates/" "$INSTALL_DIR/templates/"

    # Einzelne Dateien — VERSION aber NICHT, weil im tar.gz oft nur in backend/ vorliegt
    for f in CHANGELOG.md docker-compose.yml docker-compose.prod.yml Dockerfile \
             requirements.txt install.sh update.sh index.html changelog.html QUICKSTART.md; do
        [ -f "$f" ] && cp "$f" "$INSTALL_DIR/$f"
    done

    # v7.00: VERSION ableitend aus backend/VERSION setzen (autoritativ — wird ins Image kopiert).
    # Verhindert Race wo Top-Level-VERSION fehlt/alt ist und die korrekte backend/VERSION überschreibt.
    if [ -f "$INSTALL_DIR/backend/VERSION" ]; then
        cp "$INSTALL_DIR/backend/VERSION" "$INSTALL_DIR/VERSION"
    elif [ -f "$INSTALL_DIR/VERSION" ]; then
        # Fallback: backend/VERSION fehlt — Top-Level einsetzen
        cp "$INSTALL_DIR/VERSION" "$INSTALL_DIR/backend/VERSION"
    fi

    # Beta-Kanal-Marker setzen (Backend zeigt v${VERSION}-Beta in der UI)
    mkdir -p "$INSTALL_DIR/backend"
    echo "${SHIFTDECK_CHANNEL}" > "$INSTALL_DIR/backend/CHANNEL"
    if [ -f "$INSTALL_DIR/.env" ]; then
        if grep -q "^CHANNEL=" "$INSTALL_DIR/.env"; then
            sed -i "s/^CHANNEL=.*/CHANNEL=${SHIFTDECK_CHANNEL}/" "$INSTALL_DIR/.env"
        else
            echo "CHANNEL=${SHIFTDECK_CHANNEL}" >> "$INSTALL_DIR/.env"
        fi
    fi

    # Scripts ausführbar
    chmod +x "$INSTALL_DIR/update.sh" 2>/dev/null || true
    chmod +x "$INSTALL_DIR/install.sh" 2>/dev/null || true
    chmod +x "$INSTALL_DIR/shiftdeck" 2>/dev/null || true
    ln -sf "$INSTALL_DIR/shiftdeck" /usr/local/bin/shiftdeck 2>/dev/null || true

    print_success "  Alle Dateien installiert"

    # .env Version aktualisieren (Datei NICHT überschreiben!)
    if [ -f "$INSTALL_DIR/.env" ]; then
        sed -i "s/^VERSION=.*/VERSION=${target_version}/" "$INSTALL_DIR/.env"
        print_success "  .env Version → ${target_version}"
        
        # HOST_INSTALL_DIR hinzufügen wenn nicht vorhanden (für Auto-Updates)
        if ! grep -q "^HOST_INSTALL_DIR=" "$INSTALL_DIR/.env"; then
            echo "HOST_INSTALL_DIR=${INSTALL_DIR}" >> "$INSTALL_DIR/.env"
            print_success "  HOST_INSTALL_DIR → ${INSTALL_DIR} (für Auto-Updates)"
        fi

        # SECURITY: SUPERADMIN_PASSWORD generieren, falls in der .env nicht vorhanden.
        if ! grep -q "^SUPERADMIN_PASSWORD=" "$INSTALL_DIR/.env"; then
            SA_PW=$(openssl rand -base64 24 2>/dev/null | tr -d "=+/" | cut -c1-24)
            if [ -n "$SA_PW" ]; then
                echo "SUPERADMIN_PASSWORD=${SA_PW}" >> "$INSTALL_DIR/.env"
                print_success "  SUPERADMIN_PASSWORD generiert (in .env gesichert)"
            fi
        fi
    fi

    # Aufräumen
    rm -rf "$tmpdir"
}

# ═══════════════════════════════════════════════════════════════
# DOCKER REBUILD
# ═══════════════════════════════════════════════════════════════
rebuild_docker() {
    cd "$INSTALL_DIR"

    echo ""
    print_step "Stoppe Container..."
    # v7.04: längeres Timeout damit `down` synchron auf Container-Removal wartet —
    # vorher konnte `up --force-recreate` parallel zur Removal laufen ("removal is already in progress")
    $DOCKER_COMPOSE -f $COMPOSE_FILE down --remove-orphans -t 60 2>/dev/null || true

    # Sicherheits-Wartebusy: warten bis keine shiftdeck-Container mehr existieren
    local waited=0
    while docker ps -a --filter "name=shiftdeck\|admin-ser" --format "{{.ID}}" 2>/dev/null | grep -q .; do
        sleep 1
        waited=$((waited+1))
        if [ $waited -ge 30 ]; then
            print_warning "Container hängen noch nach 30s — erzwinge Removal"
            docker ps -a --filter "name=shiftdeck\|admin-ser" --format "{{.ID}}" 2>/dev/null | xargs -r docker rm -f 2>/dev/null || true
            sleep 2
            break
        fi
    done
    print_success "Container gestoppt"

    echo ""
    print_step "Baue Docker-Images neu (2-5 Minuten)..."
    echo ""

    # Sicherheitsprüfung: Backend Dockerfile muss existieren
    if [ ! -f "backend/Dockerfile" ]; then
        print_warning "backend/Dockerfile fehlt – erstelle Standard-Dockerfile..."
        cat > backend/Dockerfile << 'DOCKERFILE'
FROM python:3.11-slim
WORKDIR /app
RUN apt-get update && apt-get install -y --no-install-recommends curl gcc libffi-dev && rm -rf /var/lib/apt/lists/*
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
RUN mkdir -p /app/data /app/backups /app/updates
EXPOSE 8001
HEALTHCHECK --interval=30s --timeout=10s --retries=3 --start-period=40s CMD curl -f http://localhost:8001/health || exit 1
CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "8001"]
DOCKERFILE
        print_success "Backend Dockerfile erstellt"
    fi

    # Obsoletes version-Attribut entfernen
    sed -i '/^version:/d' "$COMPOSE_FILE" 2>/dev/null || true

    # v7.00: Frontend MIT Cache bauen — auf 2-GB-Servern hängt --no-cache wegen
    # Webpack-OOM. Cache-Layer für node_modules bleibt erhalten, src/ ändert
    # sich eh per COPY und Build greift dort nicht ins Cache.
    print_info "Frontend wird gebaut..."
    if $DOCKER_COMPOSE -f $COMPOSE_FILE build frontend 2>&1 | grep -E "DONE|ERROR|exporting|error" | tail -5; then
        echo ""
    fi

    # Backend
    print_info "Backend wird gebaut..."
    if $DOCKER_COMPOSE -f $COMPOSE_FILE build backend 2>&1 | grep -E "DONE|ERROR|exporting|error" | tail -5; then
        echo ""
    fi

    print_success "Docker-Images gebaut"

    echo ""
    print_step "Starte Container..."
    # v7.04: --force-recreate raus — da `down` schon alle Container entfernt hat,
    # erzeugt `up -d` ohnehin frische Container mit aktuellem Image.
    # Verhindert die "removal is already in progress"-Race-Condition.
    $DOCKER_COMPOSE -f $COMPOSE_FILE up -d --remove-orphans

    print_info "Warte auf Start..."
    local attempts=0
    while [ $attempts -lt 60 ]; do
        if $DOCKER_COMPOSE -f $COMPOSE_FILE ps 2>/dev/null | grep -q "healthy\|running"; then
            break
        fi
        sleep 2
        attempts=$((attempts + 1))
        printf "."
    done
    echo ""

    print_success "Container gestartet"

    # Status
    echo ""
    $DOCKER_COMPOSE -f $COMPOSE_FILE ps
    echo ""

    # Aufräumen
    print_step "Räume alte Docker-Images auf..."
    docker image prune -f 2>/dev/null | grep -v "^$" || true
    print_success "Aufgeräumt"

    # v6.91: Host-Tools (Host-Updater + Watchdog) automatisch installieren,
    # falls noch nicht aktiv. Verhindert das 98%-Hänger-Problem bei künftigen
    # Updates, weil der Host-Updater außerhalb des Containers läuft.
    if [ -f "$INSTALL_DIR/bin/install-host-tools.sh" ]; then
        if ! systemctl is-active --quiet shiftdeck-watchdog.timer 2>/dev/null; then
            print_step "Installiere Host-Tools (Host-Updater + Watchdog) ..."
            bash "$INSTALL_DIR/bin/install-host-tools.sh" 2>&1 | tail -10 || true
        fi
    fi
}

# ═══════════════════════════════════════════════════════════════
# STATUS
# ═══════════════════════════════════════════════════════════════
show_status() {
    show_banner
    find_compose

    local current=$(get_current_version)
    local latest=$(get_latest_version)

    echo -e "  ${BOLD}Installiert:${NC}  v${current}"
    echo -e "  ${BOLD}Verzeichnis:${NC}  ${INSTALL_DIR}"
    echo -e "  ${BOLD}Compose:${NC}      ${COMPOSE_FILE}"

    if [ -n "$latest" ]; then
        if version_gt "$latest" "$current"; then
            echo -e "  ${BOLD}Verfügbar:${NC}    ${GREEN}v${latest}${NC} ${YELLOW}← Update verfügbar!${NC}"
        else
            echo -e "  ${BOLD}Verfügbar:${NC}    v${latest} ${GREEN}(aktuell)${NC}"
        fi
    else
        echo -e "  ${BOLD}Verfügbar:${NC}    ${DIM}Server nicht erreichbar${NC}"
    fi

    echo ""
    echo -e "  ${BOLD}Container:${NC}"
    cd "$INSTALL_DIR"
    $DOCKER_COMPOSE -f $COMPOSE_FILE ps 2>/dev/null | tail -n +2 | while read line; do
        if echo "$line" | grep -qi "healthy\|running\|up"; then
            echo -e "    ${GREEN}●${NC} $line"
        else
            echo -e "    ${RED}●${NC} $line"
        fi
    done
    echo ""
}

# ═══════════════════════════════════════════════════════════════
# ZUSAMMENFASSUNG
# ═══════════════════════════════════════════════════════════════
show_summary() {
    local new_version=$(get_current_version)
    local display_version="${new_version}"
    # v7.243: Im Stable-Kanal KEIN "-Beta"-Suffix anhängen. Falls fälschlicherweise
    # noch vorhanden (aus früherem Beta-Update), entfernen.
    display_version="${display_version%-Beta}"
    display_version="${display_version%-beta}"
    echo ""
    echo -e "${GREEN}${BOLD}╔══════════════════════════════════════════════╗${NC}"
    echo -e "${GREEN}${BOLD}║  ${ROCKET} Update erfolgreich abgeschlossen!         ║${NC}"
    echo -e "${GREEN}${BOLD}╚══════════════════════════════════════════════╝${NC}"
    echo ""
    echo -e "  ${BOLD}Version:${NC}  ${GREEN}v${display_version}${NC} ${DIM}(Stable-Kanal)${NC}"
    echo -e "  ${BOLD}Status:${NC}   ${GREEN}Läuft${NC}"
    echo ""
    echo -e "  ${CYAN}${BOLD}Tipp:${NC} Im Browser ${BOLD}Ctrl+Shift+R${NC} für Hard Refresh"
    echo ""
}

# ═══════════════════════════════════════════════════════════════
# HAUPTPROGRAMM
# ═══════════════════════════════════════════════════════════════
main() {
    show_banner

    local MODE="auto"
    local TARGET_VERSION=""

    # Argumente parsen
    while [ $# -gt 0 ]; do
        case "$1" in
            --version|-v)   TARGET_VERSION="$2"; MODE="download"; shift 2 ;;
            --rebuild|-r)   MODE="rebuild"; shift ;;
            --status|-s)    MODE="status"; shift ;;
            --help|-h)
                echo "Verwendung: update.sh [OPTION]"
                echo ""
                echo "  (keine)              Auto-Update auf neueste Version"
                echo "  --version, -v VER    Bestimmte Version installieren"
                echo "  --rebuild, -r        Nur Docker-Images neu bauen"
                echo "  --status,  -s        Aktuellen Status anzeigen"
                echo "  --help,    -h        Diese Hilfe"
                echo ""
                exit 0
                ;;
            *) shift ;;
        esac
    done

    # Status
    if [ "$MODE" = "status" ]; then
        show_status
        exit 0
    fi

    find_compose

    local CURRENT_VERSION=$(get_current_version)
    print_info "Installierte Version: ${BOLD}v${CURRENT_VERSION}${NC}"
    print_info "Installationsverzeichnis: ${INSTALL_DIR}"
    print_info "Compose-Datei: ${COMPOSE_FILE}"

    # Rebuild
    if [ "$MODE" = "rebuild" ]; then
        echo ""
        print_warning "Nur Docker-Rebuild (keine Dateiänderungen)"
        rebuild_docker
        show_summary
        exit 0
    fi

    # ── Auto-Modus: Neueste Version ermitteln ──
    if [ "$MODE" = "auto" ]; then
        echo ""
        print_step "Suche nach Updates auf shiftdeck.de..."

        TARGET_VERSION=$(get_latest_version)

        if [ -z "$TARGET_VERSION" ]; then
            print_warning "Konnte neueste Version nicht automatisch ermitteln"
            print_info "Versuche bekannte Versionen..."
            for v in "6.70" "6.48" "6.47" "6.46" "6.45" "6.40" "6.39" "6.38" "6.37" "6.36" "6.35" "6.34" "6.33" "6.32" "6.31" "6.30" "6.29" "6.28" "6.27" "6.26" "6.25" "6.24" "6.23" "6.22" "6.21" "6.20" "6.19" "6.18" "6.17" "6.16" "6.15" "6.14" "6.13" "6.12" "6.11" "6.10" "6.09" "6.08" "6.07" "6.06"; do
                if curl -fsSLk --head "${DOWNLOAD_BASE}/shiftdeck-core-${v}.tar.gz" 2>/dev/null | grep -qi "200\|Content-Length"; then
                    TARGET_VERSION="$v"
                    break
                fi
                if curl -fsSL --head "ftp://${FTP_HOST}/shiftdeck-core-${v}.tar.gz" --user "${FTP_USER}:${FTP_PASS}" 2>/dev/null | grep -qi "Content-Length"; then
                    TARGET_VERSION="$v"
                    break
                fi
            done
            if [ -z "$TARGET_VERSION" ]; then
                print_error "Keine Version auf dem Server gefunden!"
                exit 1
            fi
        fi

        print_success "Neueste Version: ${BOLD}v${TARGET_VERSION}${NC}"

        # Schon aktuell?
        if [ "$TARGET_VERSION" = "$CURRENT_VERSION" ]; then
            echo ""
            print_success "Sie haben bereits die neueste Version (v${CURRENT_VERSION})!"
            echo ""
            if [[ -t 0 ]]; then
                read -p "$(echo -e "${CYAN}Trotzdem neu bauen? (j/N):${NC} ")" -n 1 -r
                echo ""
                if [[ $REPLY =~ ^[JjYy]$ ]]; then
                    rebuild_docker
                    show_summary
                fi
            fi
            exit 0
        fi

        # Installierte Version neuer als Server?
        if version_gt "$CURRENT_VERSION" "$TARGET_VERSION"; then
            print_warning "Installiert (v${CURRENT_VERSION}) ist neuer als Server (v${TARGET_VERSION})"
            if [[ -t 0 ]]; then
                read -p "$(echo -e "${CYAN}Trotzdem Downgrade? (j/N):${NC} ")" -n 1 -r
                echo ""
                [[ ! $REPLY =~ ^[JjYy]$ ]] && exit 0
            else
                exit 0
            fi
        fi
    fi

    # ── Update durchführen ──
    echo ""
    echo -e "${BOLD}  Update: v${CURRENT_VERSION} ${ARROW} v${TARGET_VERSION}${NC}"
    echo ""

    # Bestätigung (interaktiv)
    if [[ -t 0 ]]; then
        read -p "$(echo -e "${CYAN}Update jetzt starten? (J/n):${NC} ")" -n 1 -r
        echo ""
        [[ $REPLY =~ ^[Nn]$ ]] && { print_info "Abgebrochen"; exit 0; }
    fi

    echo ""
    create_backup
    download_and_install "$TARGET_VERSION"
    rebuild_docker
    show_summary
}

main "$@"