#!/bin/bash
#
# SHIFTDECK - Installations-Script
# Lädt SHIFTDECK von shiftdeck.de herunter und installiert es
#
# Verwendung: curl -fsSLk https://shiftdeck.de/download/install.sh | bash
#

set -e

# Konfiguration
SHIFTDECK_VERSION="7.83"
SHIFTDECK_CHANNEL="stable"
CHANNEL_LABEL="Stable-Kanal"
SHIFTDECK_VERSION_DISPLAY="${SHIFTDECK_VERSION}"
FTP_HOST="shiftdeck.de"
# v7.243: Hauptkanal — Pakete aus /download/ (Stable-Releases)
DOWNLOAD_BASE="https://shiftdeck.de/download"
DOWNLOAD_URL="${DOWNLOAD_BASE}/shiftdeck-${SHIFTDECK_VERSION}.tar.gz"
FTP_BASE="ftp://202.61.233.195"
FTP_CREDS="shiftdeck:East873wolf411!!"
INSTALL_DIR="${SHIFTDECK_INSTALL_DIR:-/opt/shiftdeck}"

# Split-Pakete URLs
CORE_URL="${DOWNLOAD_BASE}/shiftdeck-core-${SHIFTDECK_VERSION}.tar.gz"
ASSETS_URL="${DOWNLOAD_BASE}/shiftdeck-assets-${SHIFTDECK_VERSION}.tar.gz"
DOCS_URL="${DOWNLOAD_BASE}/shiftdeck-docs-${SHIFTDECK_VERSION}.tar.gz"

# Farben und Styling
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'

# Unicode-Zeichen
CHECK="✓"
CROSS="✗"
ARROW="→"
STAR="★"
ROCKET="🚀"
ANCHOR="⚓"

# Terminal-Breite
TERM_WIDTH=$(tput cols 2>/dev/null || echo 80)

# Hilfsfunktionen
print_header() {
    local text="$1"
    local width=$((TERM_WIDTH - 4))
    echo ""
    echo -e "${BLUE}${BOLD}"
    printf '╔%.0s' $(seq 1 $width)
    echo "╗"
    printf "║ %-$((width-2))s ║\n" "$text"
    printf '╚%.0s' $(seq 1 $width)
    echo "╝${NC}"
}

print_section() {
    echo ""
    echo -e "${CYAN}${BOLD}$1${NC}"
    echo -e "${CYAN}$(printf '─%.0s' $(seq 1 ${#1}))${NC}"
}

print_step() {
    echo -e "${BLUE}${ARROW}${NC} $1"
}

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"
}

# Banner
show_banner() {
    clear
    # 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 "        ${GREEN}${BOLD}● ${CHANNEL_LABEL:-Stable}${NC}   ${DIM}│${NC}   ${CYAN}${BOLD}v${SHIFTDECK_VERSION_DISPLAY}${NC}   ${DIM}│${NC}   ${DIM}shiftdeck.de${NC}"
    echo -e "        ${DIM}────────────────────────────────────────────────────${NC}"
    echo ""
}

# System erkennen
detect_system() {
    print_section "System-Erkennung"

    if [[ -f /etc/os-release ]]; then
        . /etc/os-release
        OS=$ID
        VER=$VERSION_ID
        print_info "Betriebssystem: $PRETTY_NAME"
    else
        print_error "Betriebssystem kann nicht erkannt werden"
        exit 1
    fi

    print_info "Architektur: $(uname -m)"
    print_info "Kernel: $(uname -r)"
}

# Root-Rechte prüfen
check_root() {
    if [[ $EUID -eq 0 ]]; then
        print_warning "Läuft als Root. Das ist OK für die Installation."
        IS_ROOT=true
    else
        print_info "Läuft als normaler Benutzer. Sudo wird bei Bedarf verwendet."
        IS_ROOT=false
        if ! sudo -n true 2>/dev/null; then
            print_error "Dieses Script benötigt sudo-Rechte"
            exit 1
        fi
    fi
}

# Docker installieren
install_docker() {
    print_section "Docker-Installation"

    if command -v docker &> /dev/null; then
        DOCKER_VERSION=$(docker --version | cut -d ' ' -f3 | cut -d ',' -f1)
        print_success "Docker bereits installiert (v$DOCKER_VERSION)"
        return 0
    fi

    print_step "Installiere Docker (dauert 2-3 Minuten)..."
    echo ""

    case "$OS" in
        ubuntu|debian)
            print_info "Aktualisiere Paket-Index..."
            sudo apt-get update -qq 2>&1 | grep -v "^Get:" || true

            print_info "Installiere Voraussetzungen..."
            sudo apt-get install -y -qq ca-certificates curl gnupg lsb-release 2>&1 | grep -v "^Selecting\|^Preparing\|^Unpacking\|^Setting up" || true
            print_success "Voraussetzungen installiert"

            print_info "Füge Docker GPG-Schlüssel hinzu..."
            sudo mkdir -p /etc/apt/keyrings
            curl -fsSL https://download.docker.com/linux/$OS/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg 2>/dev/null
            print_success "Docker GPG-Schlüssel hinzugefügt"

            print_info "Füge Docker-Repository hinzu..."
            echo \
                "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/$OS \
                $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
            print_success "Docker-Repository hinzugefügt"

            print_info "Aktualisiere Paket-Index..."
            sudo apt-get update -qq 2>&1 | grep -v "^Get:" || true

            print_info "Installiere Docker Engine (dauert ~2 Minuten)..."
            sudo apt-get install -y -qq docker-ce docker-ce-cli containerd.io docker-compose-plugin 2>&1 | grep -v "^Selecting\|^Preparing\|^Unpacking\|^Setting up" || true
            print_success "Docker Engine installiert"
            ;;

        centos|rhel|rocky|almalinux)
            print_info "Installiere yum-utils..."
            sudo yum install -y -q yum-utils 2>&1 | grep -v "^Loaded\|^Installing\|^Running" || true
            print_success "yum-utils installiert"

            print_info "Füge Docker-Repository hinzu..."
            sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo 2>&1 | grep -v "^Loaded" || true
            print_success "Docker-Repository hinzugefügt"

            print_info "Installiere Docker Engine (dauert ~2 Minuten)..."
            sudo yum install -y -q docker-ce docker-ce-cli containerd.io docker-compose-plugin 2>&1 | grep -v "^Loaded\|^Installing\|^Running" || true
            print_success "Docker Engine installiert"

            print_info "Starte Docker-Dienst..."
            sudo systemctl start docker
            sudo systemctl enable docker 2>&1 | grep -v "^Created" || true
            print_success "Docker-Dienst gestartet"
            ;;

        *)
            print_error "Nicht unterstütztes Betriebssystem: $OS"
            print_info "Bitte installieren Sie Docker manuell: https://docs.docker.com/get-docker/"
            exit 1
            ;;
    esac

    if [[ $IS_ROOT == false ]]; then
        sudo usermod -aG docker $USER
        print_success "Benutzer $USER zur docker-Gruppe hinzugefügt"
        print_warning "Sie müssen sich möglicherweise ab- und wieder anmelden"
    fi

    echo ""
    print_success "Docker erfolgreich installiert!"
}

# Docker Compose installieren
install_docker_compose() {
    print_section "Docker Compose Prüfung"

    if docker compose version &> /dev/null; then
        COMPOSE_VERSION=$(docker compose version --short)
        print_success "Docker Compose verfügbar (v$COMPOSE_VERSION)"
        DOCKER_COMPOSE="docker compose"
        return 0
    fi

    if command -v docker-compose &> /dev/null; then
        COMPOSE_VERSION=$(docker-compose version --short)
        print_success "Docker Compose verfügbar (v$COMPOSE_VERSION)"
        DOCKER_COMPOSE="docker-compose"
        return 0
    fi

    print_step "Installiere Docker Compose..."

    COMPOSE_VERSION=$(curl -s https://api.github.com/repos/docker/compose/releases/latest | grep '"tag_name":' | sed -E 's/.*"([^"]+)".*/\1/')
    sudo curl -L "https://github.com/docker/compose/releases/download/${COMPOSE_VERSION}/docker-compose-$(uname -s)-$(uname -m)" \
        -o /usr/local/bin/docker-compose
    sudo chmod +x /usr/local/bin/docker-compose

    print_success "Docker Compose installiert (v$COMPOSE_VERSION)"
    DOCKER_COMPOSE="docker-compose"
}

# Werkzeuge installieren
install_tools() {
    print_section "Benötigte Werkzeuge installieren"

    local tools=("curl" "wget" "tar" "openssl")
    local missing_tools=()

    for tool in "${tools[@]}"; do
        if ! command -v $tool &> /dev/null; then
            missing_tools+=($tool)
        fi
    done

    if [ ${#missing_tools[@]} -eq 0 ]; then
        print_success "Alle benötigten Werkzeuge sind installiert"
        return 0
    fi

    print_info "Installiere fehlende Werkzeuge: ${missing_tools[*]}"

    case "$OS" in
        ubuntu|debian)
            sudo apt-get update -qq 2>&1 | grep -v "^Get:" || true
            sudo apt-get install -y -qq "${missing_tools[@]}" 2>&1 | grep -v "^Selecting\|^Preparing\|^Unpacking\|^Setting up" || true
            ;;
        centos|rhel|rocky|almalinux)
            sudo yum install -y -q "${missing_tools[@]}" 2>&1 | grep -v "^Loaded\|^Installing\|^Running" || true
            ;;
    esac

    print_success "Werkzeuge installiert"
}

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

# Einzelnes Paket herunterladen (HTTPS → FTP Fallback)
download_package() {
    local PKG_NAME="$1"
    local HTTPS_URL="$2"
    local FTP_FILE="$3"
    local OUTPUT="$4"

    # 1. Versuch: HTTPS
    if curl -fL "$HTTPS_URL" -o "$OUTPUT" --progress-bar 2>&1 | tr '\r' '\n' | tail -1; then
        if verify_archive "$OUTPUT"; then
            print_success "$PKG_NAME heruntergeladen (HTTPS)"
            return 0
        fi
    fi
    rm -f "$OUTPUT"

    # 2. Versuch: FTP
    if curl -fL "${FTP_BASE}/${FTP_FILE}" --user "${FTP_CREDS}" -o "$OUTPUT" --progress-bar 2>&1 | tr '\r' '\n' | tail -1; then
        if verify_archive "$OUTPUT"; then
            print_success "$PKG_NAME heruntergeladen (FTP)"
            return 0
        fi
    fi
    rm -f "$OUTPUT"

    return 1
}

# Archiv entpacken und Unterverzeichnis auflösen
extract_and_flatten() {
    local ARCHIVE="$1"

    tar xzf "$ARCHIVE"
    rm -f "$ARCHIVE"

    # Dateien aus Unterverzeichnis (shiftdeck/) nach $INSTALL_DIR verschieben
    if [ -d "shiftdeck" ]; then
        rsync -a shiftdeck/ ./ 2>/dev/null || { cp -r shiftdeck/* . 2>/dev/null || true; cp -r shiftdeck/.* . 2>/dev/null || true; }
        rm -rf shiftdeck
    else
        # Fallback: Beliebiges shiftdeck-* Verzeichnis
        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; cp -r "$EXTRACTED_DIR"/.* . 2>/dev/null || true; }
            rm -rf "$EXTRACTED_DIR"
        fi
    fi
}

# SHIFTDECK herunterladen
download_shiftdeck() {
    print_section "SHIFTDECK von shiftdeck.de herunterladen"

    print_info "Erstelle Installations-Verzeichnis: $INSTALL_DIR"
    sudo mkdir -p "$INSTALL_DIR"
    sudo chown $(whoami):$(whoami) "$INSTALL_DIR" 2>/dev/null || true
    print_success "Installations-Verzeichnis erstellt"

    cd "$INSTALL_DIR"

    # ═══════════════════════════════════════════════════════════════
    # Strategie 1: Komplett-Paket (abwärtskompatibel)
    # ═══════════════════════════════════════════════════════════════
    print_info "Versuche Komplett-Paket (~24MB)..."

    if download_package "Komplett-Paket" "$DOWNLOAD_URL" "shiftdeck-${SHIFTDECK_VERSION}.tar.gz" "shiftdeck.tar.gz"; then
        print_info "Entpacke Komplett-Archiv..."
        extract_and_flatten "shiftdeck.tar.gz"
        print_success "SHIFTDECK nach $INSTALL_DIR entpackt (Komplett-Paket)"
        return 0
    fi

    # ═══════════════════════════════════════════════════════════════
    # Strategie 2: Split-Pakete (Core + Assets + Docs)
    # ═══════════════════════════════════════════════════════════════
    print_info "Komplett-Paket nicht verfügbar, lade Split-Pakete..."
    echo ""

    local SPLIT_OK=true

    # CORE-Paket (Pflicht – ohne das geht nichts)
    print_step "Lade Core-Paket (~1.6MB – Quellcode & Config)..."
    if ! download_package "Core-Paket" "$CORE_URL" "shiftdeck-core-${SHIFTDECK_VERSION}.tar.gz" "core.tar.gz"; then
        # FTP Fallback mit latest
        if ! download_package "Core-Paket" "" "shiftdeck-core-latest.tar.gz" "core.tar.gz"; then
            print_error "Core-Paket konnte nicht heruntergeladen werden!"
            SPLIT_OK=false
        fi
    fi

    # ASSETS-Paket (Pflicht – Logos, Public-Dateien)
    print_step "Lade Assets-Paket (~11MB – Logos & Public)..."
    if ! download_package "Assets-Paket" "$ASSETS_URL" "shiftdeck-assets-${SHIFTDECK_VERSION}.tar.gz" "assets.tar.gz"; then
        if ! download_package "Assets-Paket" "" "shiftdeck-assets-latest.tar.gz" "assets.tar.gz"; then
            print_warning "Assets-Paket nicht verfügbar – Frontend-Logos fehlen!"
            # Assets sind wichtig aber nicht kritisch für den Start
        fi
    fi

    # DOCS-Paket (Optional – Dokumentation)
    print_step "Lade Docs-Paket (~1MB – Dokumentation)..."
    if ! download_package "Docs-Paket" "$DOCS_URL" "shiftdeck-docs-${SHIFTDECK_VERSION}.tar.gz" "docs.tar.gz"; then
        if ! download_package "Docs-Paket" "" "shiftdeck-docs-latest.tar.gz" "docs.tar.gz"; then
            print_warning "Docs-Paket nicht verfügbar – Dokumentation fehlt (nicht kritisch)"
        fi
    fi

    if [ "$SPLIT_OK" = false ]; then
        print_error "Download fehlgeschlagen – Core-Paket ist zwingend erforderlich!"
        print_info "Bitte überprüfen Sie Ihre Internetverbindung"
        exit 1
    fi

    # Pakete in der richtigen Reihenfolge entpacken
    # Core zuerst (Grundstruktur), dann Assets (überschreibt/ergänzt), dann Docs
    # WICHTIG: extract_and_flatten verschiebt Dateien aus dem Unterverzeichnis nach $INSTALL_DIR
    print_info "Entpacke Pakete..."

    if [ -f "core.tar.gz" ]; then
        print_info "  → Core-Paket..."
        extract_and_flatten "core.tar.gz"
        print_success "  Core-Paket entpackt"
    fi

    if [ -f "assets.tar.gz" ]; then
        print_info "  → Assets-Paket..."
        extract_and_flatten "assets.tar.gz"
        print_success "  Assets-Paket entpackt"
    fi

    if [ -f "docs.tar.gz" ]; then
        print_info "  → Docs-Paket..."
        extract_and_flatten "docs.tar.gz"
        print_success "  Docs-Paket entpackt"
    fi

    print_success "SHIFTDECK nach $INSTALL_DIR entpackt (Split-Pakete)"

    # Verifikation: Sind die wichtigsten Dateien vorhanden?
    local MISSING=false
    for CHECK_FILE in "backend/server.py" "backend/Dockerfile" "frontend/Dockerfile" "docker-compose.prod.yml"; do
        if [ ! -f "$CHECK_FILE" ]; then
            print_warning "Datei fehlt: $CHECK_FILE"
            MISSING=true
        fi
    done
    if [ "$MISSING" = true ]; then
        print_warning "Einige Dateien fehlen – prüfe ob Unterverzeichnisse existieren..."
        # Nochmal nach shiftdeck-* Verzeichnissen suchen
        LEFTOVER=$(find . -maxdepth 1 -type d -name "shiftdeck*" | head -1)
        if [ -n "$LEFTOVER" ] && [ "$LEFTOVER" != "." ]; then
            print_info "Verschiebe Dateien aus $LEFTOVER..."
            cp -r "$LEFTOVER"/* . 2>/dev/null || true
            rm -rf "$LEFTOVER"
            print_success "Dateien verschoben"
        fi
    fi
}

# Secrets generieren
generate_secrets() {
    print_section "Sicherheits-Konfiguration"

    print_step "Generiere sichere Passwörter..."

    JWT_SECRET=$(openssl rand -base64 32 | tr -d "=+/" | cut -c1-32)
    MONGO_PASSWORD=$(openssl rand -base64 32 | tr -d "=+/" | cut -c1-32)
    # SECURITY: Superadmin-Passwort zufällig generieren (kein hartcodiertes Default mehr).
    SUPERADMIN_PASSWORD=$(openssl rand -base64 24 | tr -d "=+/" | cut -c1-24)
    # SECURITY: Auch das Standard-Admin-Passwort (admin@shiftdeck.de) je Installation
    # zufällig erzeugen — kein bekanntes Default-Passwort mehr. Wird am Ende angezeigt.
    ADMIN_PASSWORD=$(openssl rand -base64 18 | tr -dc 'A-Za-z0-9' | cut -c1-16)

    print_success "Sichere Passwörter generiert"
}

# Konfigurieren
configure_shiftdeck() {
    print_section "Konfiguration"

    if [[ -f .env ]]; then
        print_warning ".env-Datei existiert bereits"
        if [[ -t 0 ]]; then
            read -p "Überschreiben? (j/N): " -n 1 -r
            echo
            if [[ ! $REPLY =~ ^[JjYy]$ ]]; then
                print_info "Verwende bestehende Konfiguration"
                return 0
            fi
        else
            print_info "Verwende bestehende Konfiguration (nicht-interaktiver Modus)"
            return 0
        fi
    fi

    if [[ -f .env.example ]]; then
        cp .env.example .env
    else
        # .env direkt erstellen wenn kein .env.example vorhanden
        cat > .env << ENVEOF
# SHIFTDECK Konfiguration
VERSION=${SHIFTDECK_VERSION}
MONGO_USER=admin
MONGO_PASSWORD=${MONGO_PASSWORD}
DB_NAME=shiftdeck
JWT_SECRET=${JWT_SECRET}
SUPERADMIN_PASSWORD=${SUPERADMIN_PASSWORD}
LICENSE_KEY=
FRONTEND_BACKEND_URL=
FRONTEND_PORT=80
BACKEND_PORT=8001
CORS_ORIGINS=*
HOST_INSTALL_DIR=${INSTALL_DIR}
ENVEOF
        print_info ".env direkt erstellt (kein .env.example vorhanden)"
    fi

    sed -i "s/CHANGE_THIS_TO_SECURE_JWT_SECRET/$JWT_SECRET/" .env
    sed -i "s/CHANGE_THIS_TO_SECURE_PASSWORD/$MONGO_PASSWORD/" .env
    sed -i "s/^VERSION=.*/VERSION=${SHIFTDECK_VERSION}/" .env

    # Kanal-Marker: backend/CHANNEL=stable bei Hauptkanal (keine "-Beta"-Anzeige)
    mkdir -p backend
    echo "${SHIFTDECK_CHANNEL}" > backend/CHANNEL
    if ! grep -q "^CHANNEL=" .env; then
        echo "CHANNEL=${SHIFTDECK_CHANNEL}" >> .env
    else
        sed -i "s/^CHANNEL=.*/CHANNEL=${SHIFTDECK_CHANNEL}/" .env
    fi
    print_success "Kanal-Marker gesetzt (backend/CHANNEL=${SHIFTDECK_CHANNEL})"

    # Verwende Standardwerte im nicht-interaktiven Modus
    if [[ ! -t 0 ]]; then
        print_info "Verwende Standard-Konfiguration (nicht-interaktiver Modus)"
        DOMAIN="localhost"
        PORT="80"
        print_success "Konfiguration mit Standardwerten gespeichert"
        return 0
    fi

    echo ""
    print_info "Konfiguration (Enter für Standardwerte)"
    echo ""

    read -p "$(echo -e ${CYAN}Domain-Name ${NC})[localhost]: " DOMAIN
    DOMAIN=${DOMAIN:-localhost}

    if [[ "$DOMAIN" != "localhost" ]]; then
        sed -i "s|CORS_ORIGINS=.*|CORS_ORIGINS=https://$DOMAIN,http://$DOMAIN|" .env
        sed -i "s|FRONTEND_BACKEND_URL=.*|FRONTEND_BACKEND_URL=https://$DOMAIN/api|" .env
    fi

    read -p "$(echo -e ${CYAN}Frontend-Port ${NC})[80]: " PORT
    PORT=${PORT:-80}
    sed -i "s/FRONTEND_PORT=.*/FRONTEND_PORT=$PORT/" .env

    print_success "Konfiguration gespeichert"
}

# Frontend-Konfiguration vorbereiten
prepare_frontend_config() {
    print_section "Frontend-Konfiguration"

    print_info "Erstelle .env.production für Frontend..."

    # .env.production Datei erstellen
    cat > frontend/.env.production << 'EOF'
REACT_APP_API_URL=/api
GENERATE_SOURCEMAP=false
EOF

    print_success "Frontend-Konfiguration erstellt"
}

# Services starten
start_shiftdeck() {
    print_section "SHIFTDECK starten"

    # Compose-Datei erkennen
    if [ -f "docker-compose.prod.yml" ]; then
        COMPOSE_FILE="docker-compose.prod.yml"
        # Obsoletes version-Attribut entfernen (Docker Compose V2)
        sed -i '/^version:/d' "$COMPOSE_FILE" 2>/dev/null || true
    elif [ -f "docker-compose.yml" ]; then
        COMPOSE_FILE="docker-compose.yml"
        # Symlink erstellen damit beide Namen funktionieren
        ln -sf docker-compose.yml docker-compose.prod.yml
    else
        print_error "Keine docker-compose Datei gefunden!"
        ls -la *.yml 2>/dev/null
        exit 1
    fi
    print_info "Verwende: $COMPOSE_FILE (in $(pwd))"

    print_info "Baue Docker-Images (dauert 3-5 Minuten)..."

    # 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
    # WICHTIG: --no-cache für Frontend, um localhost:8001 Problem zu vermeiden
    if $DOCKER_COMPOSE -f $COMPOSE_FILE build --no-cache --build-arg REACT_APP_BACKEND_URL="" frontend 2>&1 | grep -E "building|naming|writing|pushing" || true; then
        echo ""
    fi
    # Backend normal bauen (mit Cache)
    if $DOCKER_COMPOSE -f $COMPOSE_FILE build backend 2>&1 | grep -E "building|naming|writing|pushing" || true; then
        echo ""
    fi
    print_success "Docker-Images gebaut"

    echo ""
    print_info "Starte Container..."
    $DOCKER_COMPOSE -f $COMPOSE_FILE up -d --remove-orphans
    print_success "Container gestartet"

    echo ""
    print_info "Warte auf Dienste..."

    for i in {1..30}; do
        if $DOCKER_COMPOSE -f $COMPOSE_FILE ps 2>/dev/null | grep -q "healthy"; then
            printf "\r[%s] 100%% ${GREEN}✓${NC}\n" "$(printf '=%.0s' {1..30})"
            break
        fi
        printf "\r["
        for ((j=1; j<=30; j++)); do
            if [ $j -le $i ]; then printf "="; else printf " "; fi
        done
        printf "] %d%%" $((i*100/30))
        sleep 1
    done
    echo ""

    print_success "SHIFTDECK läuft!"
}

# Admin-Benutzer erstellen
create_admin_user() {
    print_section "Admin-Benutzer erstellen"

    print_info "Erstelle Admin-Benutzer in der Datenbank..."

    # Python-Script für Admin-Erstellung (nutzt Backend-Umgebungsvariablen)
    cat > /tmp/create_admin.py << 'EOFPYTHON'
import asyncio
import os
import uuid
from datetime import datetime, timezone
from motor.motor_asyncio import AsyncIOMotorClient
import bcrypt

def hash_password(password):
    return bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')

async def create_admin():
    mongo_url = os.environ.get('MONGO_URL', 'mongodb://admin:shiftdeck2024!@database:27017')
    db_name = os.environ.get('DB_NAME', 'shiftdeck')
    client = AsyncIOMotorClient(mongo_url)
    db = client[db_name]

    # Prüfen ob Admin existiert
    existing = await db.users.find_one({'email': 'admin@shiftdeck.de'})
    if existing:
        # Wurde der Admin beim Backend-Start mit dem bekannten Standard-Passwort
        # (Regenbogen2025!) angelegt? Dann jetzt auf das zufällig generierte
        # Installations-Passwort umstellen und am Ende anzeigen.
        new_pw = os.environ.get('INIT_ADMIN_PASSWORD')
        is_default = False
        try:
            is_default = bcrypt.checkpw(b'Regenbogen2025!', existing['password'].encode('utf-8'))
        except Exception:
            is_default = False
        if is_default and new_pw:
            await db.users.update_one({'_id': existing['_id']}, {'$set': {'password': hash_password(new_pw)}})
            print('ADMIN_CREATED')
            return
        # Admin hat ein eigenes Passwort – NICHTS ändern (Passwort nicht überschreiben!)
        print('ADMIN_EXISTS')
        return

    # Nur bei Erstinstallation: Admin neu erstellen — Passwort kommt zufällig aus der Umgebung
    init_pw = os.environ.get('INIT_ADMIN_PASSWORD') or 'Regenbogen2025!'
    hashed = hash_password(init_pw)
    admin = {
        'id': str(uuid.uuid4()),
        'email': 'admin@shiftdeck.de',
        'password': hashed,
        'first_name': 'Admin',
        'last_name': 'Administrator',
        'role': 'admin',
        'vacation_days': 30,
        'vacation_days_used': 0,
        'weekly_hours': 40.0,
        'weekly_hours_distribution': {
            'monday': 8.0, 'tuesday': 8.0, 'wednesday': 8.0,
            'thursday': 8.0, 'friday': 8.0, 'saturday': 0, 'sunday': 0
        },
        'group_ids': [],
        'overtime_balance': 0.0,
        'max_negative_hours': 10.0,
        'is_super_admin': True,
        'has_completed_onboarding': True,
        'created_at': datetime.now(timezone.utc).isoformat()
    }

    await db.users.insert_one(admin)
    print('ADMIN_CREATED')

asyncio.run(create_admin())
EOFPYTHON

    # Script in Backend-Container kopieren und ausführen
    docker cp /tmp/create_admin.py admin-server-backend:/tmp/ >/dev/null 2>&1

    # ADMIN_CREATED steuert, ob am Ende das frisch generierte Passwort angezeigt wird.
    ADMIN_CREATED=false
    _admin_out=$(docker exec -e INIT_ADMIN_PASSWORD="$ADMIN_PASSWORD" admin-server-backend python3 /tmp/create_admin.py 2>/dev/null)
    if echo "$_admin_out" | grep -q "ADMIN_CREATED"; then
        ADMIN_CREATED=true
        print_success "Admin-Benutzer erstellt (eigenes Passwort generiert)"
    elif echo "$_admin_out" | grep -q "ADMIN_EXISTS"; then
        print_info "Admin-Benutzer existiert bereits – Passwort unverändert"
    else
        print_warning "Admin-Benutzer konnte nicht automatisch erstellt werden"
        print_info "Sie können sich nach dem ersten Login registrieren"
    fi

    # Aufräumen
    rm -f /tmp/create_admin.py
}

# Zusammenfassung
show_summary() {
    print_header "Installation abgeschlossen!"

    echo ""
    echo -e "${GREEN}${BOLD}${ROCKET} SHIFTDECK ist bereit!${NC}"
    echo ""

    FRONTEND_PORT=$(grep FRONTEND_PORT .env | cut -d '=' -f2)
    FRONTEND_PORT=${FRONTEND_PORT:-80}

    # Server-IP ermitteln
    SERVER_IP=$(hostname -I | awk '{print $1}')
    if [ -z "$SERVER_IP" ]; then
        SERVER_IP=$(ip route get 8.8.8.8 | awk -F"src " 'NR==1{split($2,a," ");print a[1]}')
    fi

    echo -e "${CYAN}${BOLD}Zugriffsinformationen:${NC}"
    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"

    if [[ "$FRONTEND_PORT" == "80" ]]; then
        echo -e "  ${BOLD}URL:${NC} http://$DOMAIN"
        if [[ "$DOMAIN" == "localhost" && -n "$SERVER_IP" ]]; then
            echo -e "  ${BOLD}Server-IP:${NC} http://$SERVER_IP"
        fi
    else
        echo -e "  ${BOLD}URL:${NC} http://$DOMAIN:$FRONTEND_PORT"
        if [[ "$DOMAIN" == "localhost" && -n "$SERVER_IP" ]]; then
            echo -e "  ${BOLD}Server-IP:${NC} http://$SERVER_IP:$FRONTEND_PORT"
        fi
    fi

    echo ""
    echo -e "  ${BOLD}Installation:${NC} $INSTALL_DIR"
    echo -e "  ${BOLD}Version:${NC} ${YELLOW}v${SHIFTDECK_VERSION_DISPLAY}${NC} ${DIM}(${CHANNEL_LABEL:-Stable-Kanal})${NC}"
    echo -e "  ${BOLD}Update:${NC}   ${DIM}curl -fsSLk ${DOWNLOAD_BASE}/update.sh | bash${NC}"
    echo ""

    if [[ "${ADMIN_CREATED:-false}" == "true" ]]; then
        echo -e "${YELLOW}${BOLD}╔══════════════════════════════════════════════════════════╗${NC}"
        echo -e "${YELLOW}${BOLD}║   🔐  IHRE ANMELDEDATEN — JETZT NOTIEREN!                 ║${NC}"
        echo -e "${YELLOW}${BOLD}╠══════════════════════════════════════════════════════════╣${NC}"
        printf "${YELLOW}${BOLD}║${NC}   ${BOLD}E-Mail:${NC}    ${GREEN}%-42s${NC}${YELLOW}${BOLD}║${NC}\n" "admin@shiftdeck.de"
        printf "${YELLOW}${BOLD}║${NC}   ${BOLD}Passwort:${NC}  ${GREEN}${BOLD}%-42s${NC}${YELLOW}${BOLD}║${NC}\n" "$ADMIN_PASSWORD"
        echo -e "${YELLOW}${BOLD}╠══════════════════════════════════════════════════════════╣${NC}"
        echo -e "${YELLOW}${BOLD}║${NC}   ${DIM}Dieses Passwort wird nur EINMAL angezeigt.${NC}             ${YELLOW}${BOLD}║${NC}"
        echo -e "${YELLOW}${BOLD}║${NC}   ${DIM}Nach dem ersten Login in den Einstellungen ändern.${NC}     ${YELLOW}${BOLD}║${NC}"
        echo -e "${YELLOW}${BOLD}╚══════════════════════════════════════════════════════════╝${NC}"
        echo ""
    else
        echo -e "${CYAN}${BOLD}Anmeldung:${NC}"
        echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
        echo -e "  ${BOLD}E-Mail:${NC}    ${GREEN}admin@shiftdeck.de${NC}"
        echo -e "  ${BOLD}Passwort:${NC}  ${DIM}unverändert (bei Erstinstallation gesetzt)${NC}"
        echo ""
    fi

    echo -e "${CYAN}${BOLD}Verwaltungsbefehle:${NC}"
    echo -e "${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo -e "  ${BOLD}Status:${NC}   shiftdeck status"
    echo -e "  ${BOLD}Update:${NC}   shiftdeck update"
    echo -e "  ${BOLD}Logs:${NC}     shiftdeck logs"
    echo -e "  ${BOLD}Stoppen:${NC}  shiftdeck stop"
    echo -e "  ${BOLD}Starten:${NC}  shiftdeck start"
    echo -e "  ${BOLD}Rebuild:${NC}  shiftdeck rebuild"
    echo ""

    echo -e "${GREEN}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo ""
    echo -e "${GREEN}${BOLD}          ${ANCHOR}   Vielen Dank für Ihr Vertrauen in SHIFTDECK!   ${ANCHOR}${NC}"
    echo ""
    echo -e "${GREEN}${BOLD}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
    echo ""
}

# Hauptprogramm
main() {
    show_banner

    # Prüfe ob SHIFTDECK bereits installiert ist
    if [ -f "$INSTALL_DIR/VERSION" ] && [ -f "$INSTALL_DIR/docker-compose.yml" ] || [ -f "$INSTALL_DIR/docker-compose.prod.yml" ]; then
        CURRENT_VERSION=$(cat "$INSTALL_DIR/VERSION" | tr -d '[:space:]')
        print_warning "SHIFTDECK v${CURRENT_VERSION} ist bereits installiert!"
        echo ""
        
        if [[ -t 0 ]]; then
            echo -e "  ${BOLD}1)${NC} Update auf v${SHIFTDECK_VERSION} (empfohlen)"
            echo -e "  ${BOLD}2)${NC} Komplett neu installieren (Daten bleiben erhalten)"
            echo -e "  ${BOLD}3)${NC} Abbrechen"
            echo ""
            read -p "Auswahl [1]: " -n 1 -r
            echo ""
            
            case "$REPLY" in
                2) print_info "Neuinstallation gewählt" ;;
                3|n|N) print_info "Abgebrochen"; exit 0 ;;
                *)
                    # Update-Modus
                    print_info "Starte Update v${CURRENT_VERSION} → v${SHIFTDECK_VERSION}..."
                    echo ""
                    
                    detect_system
                    check_root
                    install_tools
                    download_shiftdeck
                    
                    # .env NICHT überschreiben, nur VERSION updaten
                    if [ -f "$INSTALL_DIR/.env" ]; then
                        sed -i "s/^VERSION=.*/VERSION=${SHIFTDECK_VERSION}/" "$INSTALL_DIR/.env"
                        print_success ".env Version aktualisiert"
                    fi
                    
                    # Docker neu bauen
                    start_shiftdeck
                    # create_admin_user  # Nicht bei Updates – Admin-Daten nicht überschreiben
                    show_summary
                    exit 0
                    ;;
            esac
        else
            # Nicht-interaktiv: Automatisches Update
            print_info "Automatisches Update v${CURRENT_VERSION} → v${SHIFTDECK_VERSION}..."
            
            detect_system
            check_root
            install_tools
            download_shiftdeck
            
            if [ -f "$INSTALL_DIR/.env" ]; then
                sed -i "s/^VERSION=.*/VERSION=${SHIFTDECK_VERSION}/" "$INSTALL_DIR/.env"
            fi
            
            start_shiftdeck
            # create_admin_user  # Nicht bei Updates – Admin-Daten nicht überschreiben
            show_summary
            exit 0
        fi
    fi

    print_info "Starte Installation von shiftdeck.de..."
    echo ""

    # Überspringe Bestätigung im nicht-interaktiven Modus (gepipet von curl)
    if [[ -t 0 ]]; then
        read -p "Fortfahren? (J/n): " -n 1 -r
        echo ""
        if [[ $REPLY =~ ^[Nn]$ ]]; then
            print_info "Installation abgebrochen"
            exit 0
        fi
    else
        print_info "Automatischer Start (nicht-interaktiver Modus)"
        echo ""
        echo -e "${CYAN}${BOLD}Installations-Schritte:${NC}"
        echo -e "  1. System erkennen"
        echo -e "  2. Docker installieren (falls nötig)"
        echo -e "  3. Docker Compose installieren"
        echo -e "  4. Benötigte Werkzeuge installieren"
        echo -e "  5. SHIFTDECK herunterladen (~2-14MB je nach Paket)"
        echo -e "  6. Passwörter generieren"
        echo -e "  7. Frontend-Konfiguration vorbereiten"
        echo -e "  8. Container bauen & starten"
        echo -e "  9. Admin-Benutzer erstellen"
        echo ""
        print_warning "Dies dauert 5-10 Minuten. Bitte haben Sie Geduld..."
        echo ""
        sleep 2
    fi

    detect_system
    check_root
    install_docker
    install_docker_compose
    install_tools
    download_shiftdeck
    generate_secrets
    configure_shiftdeck
    prepare_frontend_config
    start_shiftdeck
    create_admin_user
    
    # CLI installieren
    if [ -f "$INSTALL_DIR/shiftdeck" ]; then
        chmod +x "$INSTALL_DIR/shiftdeck"
        ln -sf "$INSTALL_DIR/shiftdeck" /usr/local/bin/shiftdeck 2>/dev/null || true
        print_success "SHIFTDECK CLI installiert (Befehl: shiftdeck)"
    fi
    
    show_summary
}

main