#!/bin/bash

# MYP Frontend Installations-Skript
# Dieses Skript installiert das Frontend mit Docker und Host-Netzwerkanbindung

# Farbcodes für Ausgabe
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Funktion zur Ausgabe mit Zeitstempel
log() {
  echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')]${NC} $1"
}

error_log() {
  echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] FEHLER:${NC} $1" >&2
}

# Funktion zum Bereinigen vorhandener Installationen
cleanup_existing_installation() {
  log "${YELLOW}Bereinige vorhandene Installation...${NC}"
  
  # Stoppe und entferne existierende Container
  if docker ps -a | grep -q "myp-frontend"; then
    log "Stoppe und entferne existierenden Frontend-Container..."
    docker stop myp-frontend &>/dev/null || true
    docker rm myp-frontend &>/dev/null || true
  fi
  
  # Entferne Docker Images
  if docker images | grep -q "myp-frontend"; then
    log "Entferne existierendes Frontend-Image..."
    docker rmi myp-frontend &>/dev/null || true
  fi
  
  log "${GREEN}Bereinigung abgeschlossen.${NC}"
}

# Pfade definieren
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
FRONTEND_DIR="$SCRIPT_DIR/packages/reservation-platform"

# Prüfen ob Verzeichnis existiert
if [ ! -d "$FRONTEND_DIR" ]; then
  error_log "Frontend-Verzeichnis '$FRONTEND_DIR' nicht gefunden."
  exit 1
fi

# Bereinige existierende Installation
cleanup_existing_installation

# Funktion zur Installation von Docker und Docker Compose für Raspberry Pi
install_docker() {
  log "${YELLOW}Docker ist nicht installiert. Installation wird gestartet...${NC}"
  
  # Erkenne Raspberry Pi
  if [ -f /proc/device-tree/model ] && grep -q "Raspberry Pi" /proc/device-tree/model; then
    log "${GREEN}Raspberry Pi erkannt. Installiere Docker für ARM-Architektur...${NC}"
    IS_RASPBERRY_PI=true
  else
    IS_RASPBERRY_PI=false
  fi
  
  # Aktualisiere Paketindex
  if ! sudo apt-get update; then
    error_log "Konnte Paketindex nicht aktualisieren. Bitte manuell installieren."
    exit 1
  fi
  
  # Installiere erforderliche Pakete
  if ! sudo apt-get install -y apt-transport-https ca-certificates curl gnupg software-properties-common; then
    error_log "Konnte erforderliche Pakete nicht installieren. Bitte manuell installieren."
    exit 1
  fi
  
  # Raspberry Pi-spezifische Installation
  if [ "$IS_RASPBERRY_PI" = true ]; then
    # Setze Systemarchitektur für Raspberry Pi (armhf oder arm64)
    ARCH=$(dpkg --print-architecture)
    log "Erkannte Systemarchitektur: ${ARCH}"
    
    # Installiere Docker mit convenience script (für Raspberry Pi empfohlen)
    log "${YELLOW}Installiere Docker mit dem convenience script...${NC}"
    curl -fsSL https://get.docker.com -o get-docker.sh
    sudo sh get-docker.sh
    
    if [ $? -ne 0 ]; then
      error_log "Docker-Installation fehlgeschlagen. Bitte manuell installieren."
      exit 1
    fi
  else
    # Standard-Installation für andere Systeme
    # Füge Docker's offiziellen GPG-Schlüssel hinzu
    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
    
    # Füge Docker-Repository hinzu
    if ! sudo add-apt-repository "deb [arch=$(dpkg --print-architecture)] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"; then
      error_log "Konnte Docker-Repository nicht hinzufügen. Prüfen Sie, ob Ihr System unterstützt wird."
      exit 1
    fi
    
    # Aktualisiere Paketindex erneut
    sudo apt-get update
    
    # Installiere Docker
    if ! sudo apt-get install -y docker-ce docker-ce-cli containerd.io; then
      error_log "Konnte Docker nicht installieren. Bitte manuell installieren."
      exit 1
    fi
  fi
  
  # Füge aktuellen Benutzer zur Docker-Gruppe hinzu
  sudo usermod -aG docker "$USER"
  
  log "${GREEN}Docker wurde installiert.${NC}"
  log "${YELLOW}WICHTIG: Möglicherweise müssen Sie sich neu anmelden, damit die Gruppenänderung wirksam wird.${NC}"
  
  # Prüfen, ob Docker Compose v2 Plugin verfügbar ist (bevorzugt, da moderner)
  log "${YELLOW}Prüfe Docker Compose Version...${NC}"
  
  if docker compose version &> /dev/null; then
    log "${GREEN}Docker Compose v2 Plugin ist bereits installiert.${NC}"
    DOCKER_COMPOSE_V2=true
  else
    log "${YELLOW}Docker Compose v2 Plugin nicht gefunden. Versuche Docker Compose v1 zu installieren...${NC}"
    DOCKER_COMPOSE_V2=false
    
    if [ "$IS_RASPBERRY_PI" = true ]; then
      # Für Raspberry Pi ist es besser, die richtige Architektur zu verwenden
      if [ "$ARCH" = "armhf" ]; then
        log "Installiere Docker Compose für armhf (32-bit)..."
        sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-armv7" -o /usr/local/bin/docker-compose
      elif [ "$ARCH" = "arm64" ]; then
        log "Installiere Docker Compose für arm64 (64-bit)..."
        sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-aarch64" -o /usr/local/bin/docker-compose
      else
        # Fallback auf v1.29.2 für unbekannte ARM-Architekturen
        log "Verwende automatische Architekturerkennung für Docker Compose v1.29.2..."
        sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
      fi
    else
      # Für andere Systeme versuche zuerst v2, dann v1.29.2 als Fallback
      log "Installiere Docker Compose v2 für $(uname -s)/$(uname -m)..."
      if ! sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose; then
        log "${YELLOW}Konnte Docker Compose v2 nicht herunterladen. Versuche v1.29.2...${NC}"
        sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
      fi
    fi
    
    if [ $? -ne 0 ]; then
      error_log "Konnte Docker Compose nicht herunterladen. Bitte manuell installieren."
      exit 1
    fi
    
    sudo chmod +x /usr/local/bin/docker-compose
    
    log "${GREEN}Docker Compose wurde installiert.${NC}"
  fi
  
  # Starte Docker-Dienst
  if command -v systemctl &> /dev/null; then
    sudo systemctl enable docker
    sudo systemctl start docker
  elif command -v service &> /dev/null; then
    sudo service docker enable
    sudo service docker start
  fi
}

# Prüfen ob Docker installiert ist
if ! command -v docker &> /dev/null; then
  log "${YELLOW}Docker ist nicht installiert.${NC}"
  read -p "Möchten Sie Docker installieren? (j/n): " install_docker_choice
  if [[ "$install_docker_choice" == "j" ]]; then
    install_docker
  else
    error_log "Docker wird für die Installation benötigt. Bitte installieren Sie Docker manuell."
    log "Siehe: https://docs.docker.com/get-docker/"
    exit 1
  fi
fi

# Prüfen ob Docker Daemon läuft
if ! docker info &> /dev/null; then
  log "${YELLOW}Docker-Daemon läuft nicht. Versuche, den Dienst zu starten...${NC}"
  
  # Versuche, Docker zu starten
  if command -v systemctl &> /dev/null; then
    sudo systemctl start docker
  elif command -v service &> /dev/null; then
    sudo service docker start
  else
    error_log "Konnte Docker-Daemon nicht starten. Bitte starten Sie den Docker-Dienst manuell."
    log "Starten mit: sudo systemctl start docker oder sudo service docker start"
    exit 1
  fi
  
  # Prüfe erneut, ob Docker läuft
  if ! docker info &> /dev/null; then
    error_log "Docker-Daemon konnte nicht gestartet werden. Bitte starten Sie den Docker-Dienst manuell."
    exit 1
  fi
  
  log "${GREEN}Docker-Daemon wurde erfolgreich gestartet.${NC}"
fi

# Prüfen ob Docker Compose installiert ist
if docker compose version &> /dev/null; then
  log "${GREEN}Docker Compose v2 Plugin ist bereits installiert.${NC}"
  DOCKER_COMPOSE_V2=true
elif command -v docker-compose &> /dev/null; then
  log "${GREEN}Docker Compose v1 ist bereits installiert.${NC}"
  DOCKER_COMPOSE_V2=false
else
  log "${YELLOW}Docker Compose ist nicht installiert.${NC}"
  DOCKER_COMPOSE_V2=false
  read -p "Möchten Sie Docker Compose installieren? (j/n): " install_compose_choice
  if [[ "$install_compose_choice" == "j" ]]; then
    log "${YELLOW}Installiere Docker Compose...${NC}"
    
    # Prüfe ob das Betriebssystem ARM-basiert ist (z.B. Raspberry Pi)
    if grep -q "arm" /proc/cpuinfo 2> /dev/null; then
      ARCH=$(dpkg --print-architecture 2> /dev/null || echo "unknown")
      IS_RASPBERRY_PI=true
    else 
      IS_RASPBERRY_PI=false
    fi
    
    # Versuche zuerst Docker Compose v2 zu installieren
    if [ "$IS_RASPBERRY_PI" = true ]; then
      if [ "$ARCH" = "armhf" ]; then
        log "Installiere Docker Compose für armhf (32-bit)..."
        sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-armv7" -o /usr/local/bin/docker-compose
      elif [ "$ARCH" = "arm64" ]; then
        log "Installiere Docker Compose für arm64 (64-bit)..."
        sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-linux-aarch64" -o /usr/local/bin/docker-compose
      else
        log "Verwende automatische Architekturerkennung für Docker Compose v1.29.2..."
        sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
      fi
    else
      log "Installiere Docker Compose v2 für $(uname -s)/$(uname -m)..."
      if ! sudo curl -L "https://github.com/docker/compose/releases/download/v2.6.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose; then
        log "${YELLOW}Konnte Docker Compose v2 nicht herunterladen. Versuche v1.29.2...${NC}"
        sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
      fi
    fi
    
    if [ $? -ne 0 ]; then
      error_log "Konnte Docker Compose nicht herunterladen. Bitte manuell installieren."
      exit 1
    fi
    
    sudo chmod +x /usr/local/bin/docker-compose
    
    log "${GREEN}Docker Compose wurde installiert.${NC}"
  else
    error_log "Docker Compose wird für die Installation benötigt. Bitte installieren Sie es manuell."
    log "Siehe: https://docs.docker.com/compose/install/"
    exit 1
  fi
fi

# Prüfen ob wget installiert ist (wird für healthcheck verwendet)
if ! command -v wget &> /dev/null; then
  error_log "wget ist nicht installiert, wird aber für den Container-Healthcheck benötigt."
  log "Installation mit: sudo apt-get install wget"
  exit 1
fi

# Wechsle ins Frontend-Verzeichnis
log "Wechsle ins Verzeichnis: $FRONTEND_DIR"
cd "$FRONTEND_DIR" || {
  error_log "Konnte nicht ins Verzeichnis $FRONTEND_DIR wechseln."
  exit 1
}

# Prüfe ob Dockerfile existiert
if [ ! -f "Dockerfile" ]; then
  error_log "Dockerfile nicht gefunden in $FRONTEND_DIR."
  exit 1
fi

# Prüfe ob docker-compose.yml existiert
if [ ! -f "docker-compose.yml" ]; then
  error_log "docker-compose.yml nicht gefunden in $FRONTEND_DIR."
  exit 1
fi

# Prüfe ob package.json existiert
if [ ! -f "package.json" ]; then
  error_log "package.json nicht gefunden in $FRONTEND_DIR."
  exit 1
fi

# Erstelle .env-Datei
log "${YELLOW}Erstelle .env Datei...${NC}"
cat > .env << EOL
# Basic Server Configuration
RUNTIME_ENVIRONMENT=prod
DB_PATH=db/sqlite.db

# OAuth Configuration (Bitte anpassen)
OAUTH_CLIENT_ID=client_id
OAUTH_CLIENT_SECRET=client_secret

# Backend-API URL (IP-Adresse oder Hostname des Backend-Servers)
NEXT_PUBLIC_API_URL=http://localhost:5000
EOL

if [ ! -f ".env" ]; then
  error_log "Konnte .env-Datei nicht erstellen. Prüfen Sie die Berechtigungen."
  exit 1
fi
log "${GREEN}.env Datei erfolgreich erstellt${NC}"
log "${YELLOW}HINWEIS: Bitte passen Sie die Backend-URL in der .env-Datei an, falls das Backend auf einem anderen Server läuft.${NC}"

# Datenbank-Verzeichnis erstellen
log "Erstelle Datenbankverzeichnis"
if ! mkdir -p db; then
  error_log "Konnte Verzeichnis 'db' nicht erstellen. Prüfen Sie die Berechtigungen."
  exit 1
fi

# Docker-Image bauen und starten
log "${YELLOW}Baue und starte Frontend-Container...${NC}"
log "${YELLOW}Dies kann auf einem Raspberry Pi mehrere Minuten dauern - bitte geduldig sein${NC}"

# Prüfe, ob Docker-Daemon läuft
if ! docker info &>/dev/null; then
  log "${YELLOW}Docker-Daemon scheint nicht zu laufen. Versuche zu starten...${NC}"
  
  # Versuche Docker zu starten
  if command -v systemctl &>/dev/null; then
    sudo systemctl start docker || true
    sleep 5
  elif command -v service &>/dev/null; then
    sudo service docker start || true
    sleep 5
  fi
  
  # Prüfe erneut, ob Docker jetzt läuft
  if ! docker info &>/dev/null; then
    error_log "Docker-Daemon konnte nicht gestartet werden."
    log "Führen Sie vor der Installation bitte folgende Befehle aus:"
    log "    sudo systemctl start docker"
    log "    sudo systemctl enable docker"
    log "Starten Sie dann das Installationsskript erneut."
    exit 1
  fi
fi

# Docker-Rechte prüfen
if ! docker ps &>/dev/null; then
  error_log "Sie haben keine Berechtigung, Docker ohne sudo zu verwenden."
  log "Bitte führen Sie folgenden Befehl aus und melden Sie sich danach neu an:"
  log "    sudo usermod -aG docker $USER"
  exit 1
fi

# Prüfen, ob erforderliche Basis-Images lokal verfügbar sind
if ! docker image inspect node:lts-alpine &>/dev/null; then
  log "${YELLOW}Prüfe und setze DNS-Server für Docker...${NC}"
  
  # DNS-Einstellungen prüfen und anpassen
  if [ -f /etc/docker/daemon.json ]; then
    log "Bestehende Docker-Konfiguration gefunden."
  else
    log "Erstelle Docker-Konfiguration mit Google DNS..."
    sudo mkdir -p /etc/docker
    echo '{
  "dns": ["8.8.8.8", "8.8.4.4"]
}' | sudo tee /etc/docker/daemon.json > /dev/null
    
    # Docker neu starten, damit die Änderungen wirksam werden
    if command -v systemctl &>/dev/null; then
      sudo systemctl restart docker
      sleep 5
    elif command -v service &>/dev/null; then
      sudo service docker restart
      sleep 5
    fi
  fi
  
  # Versuche Image explizit mit anderen Tags herunterzuladen
  log "${YELLOW}Versuche lokal vorhandene Node-Version zu finden...${NC}"
  
  # Suche nach allen verfügbaren Node-Images
  NODE_IMAGES=$(docker images --format "{{.Repository}}:{{.Tag}}" | grep "node:")
  
  if [ -n "$NODE_IMAGES" ]; then
    log "Gefundene Node-Images: $NODE_IMAGES"
    # Verwende das erste gefundene Node-Image
    FIRST_NODE=$(echo "$NODE_IMAGES" | head -n 1)
    log "${GREEN}Verwende vorhandenes Node-Image: $FIRST_NODE${NC}"
    
    # Aktualisiere den Dockerfile
    sed -i "s|FROM node:lts-alpine|FROM $FIRST_NODE|g" Dockerfile
    log "Dockerfile aktualisiert, um lokales Image zu verwenden."
  else
    # Versuche unterschiedliche Node-Versionen
    for NODE_VERSION in "node:20-alpine" "node:18-alpine" "node:16-alpine" "node:alpine" "node:slim"; do
      log "Versuche $NODE_VERSION zu laden..."
      if docker pull $NODE_VERSION; then
        log "${GREEN}Erfolgreich $NODE_VERSION heruntergeladen${NC}"
        # Aktualisiere den Dockerfile
        sed -i "s|FROM node:lts-alpine|FROM $NODE_VERSION|g" Dockerfile
        log "Dockerfile aktualisiert, um $NODE_VERSION zu verwenden."
        break
      fi
    done
  fi
fi

# Erhöhe Docker-Timeout für langsame Verbindungen und Raspberry Pi
export DOCKER_CLIENT_TIMEOUT=300
export COMPOSE_HTTP_TIMEOUT=300

# Verwende die richtige Docker Compose Version
if [ "${DOCKER_COMPOSE_V2:-false}" = true ]; then
  # Docker Compose V2 Plugin (docker compose)
  log "Baue lokales Image..."
  if ! docker compose build --no-cache; then
    error_log "Docker Compose Build (v2) fehlgeschlagen. Versuche mit v1 Format..."
    if ! docker-compose build --no-cache; then
      error_log "Docker Compose Build fehlgeschlagen. Siehe Fehlermeldung oben."
      exit 1
    fi
  fi
  
  log "Starte Container aus lokalem Image..."
  if ! docker compose up -d; then
    error_log "Docker Compose Up (v2) fehlgeschlagen. Versuche mit v1 Format..."
    if ! docker-compose up -d; then
      error_log "Docker Compose Up fehlgeschlagen. Siehe Fehlermeldung oben."
      exit 1
    fi
  fi
else
  # Docker Compose V1 (docker-compose)
  log "Baue lokales Image..."
  if ! docker-compose build --no-cache; then
    error_log "Docker Compose Build fehlgeschlagen. Siehe Fehlermeldung oben."
    exit 1
  fi
  
  log "Starte Container aus lokalem Image..."
  if ! docker-compose up -d; then
    error_log "Docker Compose Up fehlgeschlagen. Siehe Fehlermeldung oben."
    exit 1
  fi
fi

# Prüfe, ob der Container läuft
log "Warte 10 Sekunden, bis der Container gestartet ist..."
sleep 10

# Prüfe mehrmals, da der Container möglicherweise länger zum Starten braucht
MAX_ATTEMPTS=5
CURRENT_ATTEMPT=1

while [ $CURRENT_ATTEMPT -le $MAX_ATTEMPTS ]; do
  log "Prüfe Container-Status (Versuch $CURRENT_ATTEMPT von $MAX_ATTEMPTS)..."
  
  if docker ps | grep -q "myp-frontend"; then
    log "${GREEN}Frontend-Container läuft${NC}"
    break
  else
    CONTAINER_STATUS=$(docker ps -a | grep myp-frontend)
    CONTAINER_CREATED=$(echo "$CONTAINER_STATUS" | grep -q "Created" && echo "true" || echo "false")
    CONTAINER_EXITED=$(echo "$CONTAINER_STATUS" | grep -q "Exited" && echo "true" || echo "false")
    
    if [ "$CONTAINER_EXITED" = "true" ]; then
      log "${YELLOW}Container wurde beendet. Prüfe Logs...${NC}"
      docker logs myp-frontend
      
      log "${YELLOW}Starte Container neu mit besserer Debug-Ausgabe...${NC}"
      docker rm -f myp-frontend
      
      if [ "${DOCKER_COMPOSE_V2:-false}" = true ]; then
        docker compose up -d
      else
        docker-compose up -d
      fi
      
      sleep 10
    fi
    
    if [ $CURRENT_ATTEMPT -eq $MAX_ATTEMPTS ]; then
      error_log "Frontend-Container läuft nach mehreren Versuchen nicht. Container-Status:"
      docker ps -a | grep myp-frontend
      log "Container-Logs:"
      docker logs myp-frontend
      exit 1
    fi
  fi
  
  CURRENT_ATTEMPT=$((CURRENT_ATTEMPT + 1))
  sleep 20
done

# Teste ob der Server erreichbar ist
log "${YELLOW}Teste ob Frontend-Server erreichbar ist...${NC}"
log "${YELLOW}HINWEIS: Bei der Erstinstallation kann es einige Minuten dauern, bis der Server erreichbar ist${NC}"
log "${YELLOW}Bei anhaltenden Problemen kann ein Neustart des Systems helfen${NC}"

MAX_ATTEMPTS=3
ATTEMPT=1

while [ $ATTEMPT -le $MAX_ATTEMPTS ]; do
  log "Versuch $ATTEMPT/$MAX_ATTEMPTS..."
  if curl -s -o /dev/null -w "%{http_code}" http://localhost:3000 2>/dev/null | grep -q "200\|304"; then
    log "${GREEN}Frontend-Server ist erreichbar!${NC}"
    break
  else
    # Prüfe, ob der Container noch läuft oder Fehler aufweist
    CONTAINER_STATUS=$(docker inspect --format='{{.State.Status}}' myp-frontend 2>/dev/null || echo "nicht gefunden")
    
    if [ "$CONTAINER_STATUS" != "running" ]; then
      log "${YELLOW}Container ist nicht aktiv (Status: $CONTAINER_STATUS). Prüfe Logs...${NC}"
      docker logs myp-frontend --tail 20
      
      # Wenn der Container gestoppt wurde, starte ihn neu
      if [ "$CONTAINER_STATUS" = "exited" ] || [ "$CONTAINER_STATUS" = "created" ]; then
        log "${YELLOW}Versuche, den Container neuzustarten...${NC}"
        docker start myp-frontend
        sleep 10
      fi
    fi
    
    if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
      log "${YELLOW}Server noch nicht erreichbar. Das ist bei der Erstinstallation normal.${NC}"
      log "${GREEN}Der Container ist installiert und sollte nach einem System-Neustart korrekt funktionieren.${NC}"
      log "${GREEN}Beim ersten Start kann die Datenbank-Migration und der Build länger dauern.${NC}"
      log "Überprüfen Sie später den Container-Status mit: docker logs myp-frontend"
    else
      log "Server noch nicht erreichbar. Warte 10 Sekunden..."
      sleep 10
    fi
  fi
  ATTEMPT=$((ATTEMPT+1))
done

# Stellen Sie sicher, dass Verzeichnis- und Datei-Berechtigungen korrekt gesetzt sind
log "${YELLOW}Bereite Datenbank vor...${NC}"
mkdir -p db
touch db/sqlite.db
chmod 666 db/sqlite.db
log "${GREEN}Datenbank vorbereitet${NC}"

# Führe bei Bedarf SQLite-Rebuild im Container aus
log "${YELLOW}Führe SQLite-Rebuild im Container durch...${NC}"
docker exec myp-frontend npm_config_build_from_source=true pnpm rebuild better-sqlite3 || {
  log "${YELLOW}Rebuild im laufenden Container nicht möglich. Wird beim nächsten Start automatisch ausgeführt.${NC}"
}

# Prüfe ob die Datenbank-Migration erfolgt ist
log "${YELLOW}Prüfe Datenbank-Migration...${NC}"
log "${YELLOW}Hinweis: Die Migration wird beim ersten Start nach dem Systemneustart automatisch ausgeführt${NC}"

if [ -f "db/sqlite.db" ]; then
  log "${GREEN}Datenbank existiert${NC}"
  
  # Setze Berechtigungen
  chmod 666 db/sqlite.db
  
  # Prüfe Datenbankgröße
  DB_SIZE=$(du -b db/sqlite.db 2>/dev/null | cut -f1 || echo "0")
  if [ "$DB_SIZE" -gt 1000 ]; then
    log "${GREEN}Datenbank scheint initialisiert zu sein (Größe: $DB_SIZE Bytes)${NC}"
  else
    log "${YELLOW}Datenbank ist leer oder sehr klein. Die Migration wird beim ersten Start ausgeführt.${NC}"
  fi
else
  log "${YELLOW}Konnte Datenbank-Datei nicht finden. Wird beim Neustart automatisch erstellt.${NC}"
fi

log "${GREEN}=== Installation abgeschlossen ===${NC}"
log "${YELLOW}WICHTIG: Nach der Erstinstallation ist ein Systemneustart erforderlich${NC}"
log "${YELLOW}Danach ist das Frontend unter http://localhost:3000 erreichbar${NC}"
log "Anzeigen der Logs: docker logs -f myp-frontend"

# Verwende die richtige Docker Compose Version für Hinweis
if [ "${DOCKER_COMPOSE_V2:-false}" = true ]; then
  log "Frontend stoppen: docker compose -f $FRONTEND_DIR/docker-compose.yml down"
else
  log "Frontend stoppen: docker-compose -f $FRONTEND_DIR/docker-compose.yml down"
fi