#!/usr/bin/env bash
# Installiert Docker + NVIDIA Container Toolkit, lädt Ollama/Open WebUI,
# lädt das konfigurierte Modell und erzeugt den internen Docker-Stack.
#
# Verwendung:
#   sudo bash 02-install-llm-stack.sh ./local-llm.env
# Bereits installierten Stack nur netzwerktechnisch reparieren:
#   sudo bash 02-install-llm-stack.sh ./local-llm.env --repair-only

set -euo pipefail

CONFIG="${1:-./local-llm.env}"
MODE="${2:-}"
[[ -z "$MODE" || "$MODE" == "--repair-only" ]] || { echo "Unbekannte Option: $MODE"; exit 1; }
[[ -r "$CONFIG" ]] || { echo "Konfiguration fehlt: $CONFIG"; exit 1; }
# shellcheck disable=SC1090
source "$CONFIG"

for v in DATA_ROOT OLLAMA_MODEL OLLAMA_IMAGE OPEN_WEBUI_IMAGE OPEN_WEBUI_PORT; do
  [[ -n "${!v:-}" && "${!v}" != __*__ ]] || { echo "Bitte $v in $CONFIG setzen."; exit 1; }
done
[[ "${EUID}" -eq 0 ]] || { echo "Bitte mit sudo/root ausführen."; exit 1; }

echo "== NVIDIA-GPU auf Ubuntu prüfen =="
command -v nvidia-smi >/dev/null || { echo "ABBRUCH: nvidia-smi fehlt."; exit 1; }
nvidia-smi >/dev/null || { echo "ABBRUCH: NVIDIA-Treiber/GPU funktioniert nicht."; exit 1; }

if [[ "$MODE" != "--repair-only" ]]; then
echo "== Docker installieren =="
install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
chmod a+r /etc/apt/keyrings/docker.asc
. /etc/os-release
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu ${VERSION_CODENAME} stable" > /etc/apt/sources.list.d/docker.list
apt update
DEBIAN_FRONTEND=noninteractive apt install -y \
  docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
systemctl enable --now docker

echo "== NVIDIA Container Toolkit installieren =="
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey \
  | gpg --dearmor --yes -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -fsSL https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list \
  | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#' \
  > /etc/apt/sources.list.d/nvidia-container-toolkit.list
apt update
DEBIAN_FRONTEND=noninteractive apt install -y nvidia-container-toolkit
nvidia-ctk runtime configure --runtime=docker
systemctl restart docker

echo "== GPU in Docker testen =="
docker pull ubuntu:24.04
docker run --rm --gpus all ubuntu:24.04 bash -c 'test -e /dev/nvidia0 && test -e /dev/nvidiactl'
echo "GPU ist für Docker verfügbar."

echo "== Container-Images laden =="
docker pull "$OLLAMA_IMAGE"
docker pull "$OPEN_WEBUI_IMAGE"

echo "== Ollama-Modell einmalig laden: $OLLAMA_MODEL =="
docker rm -f knp-ai-ollama-setup >/dev/null 2>&1 || true
docker run -d --name knp-ai-ollama-setup \
  -v "$DATA_ROOT/ollama:/root/.ollama" \
  "$OLLAMA_IMAGE"

ready=0
for _ in {1..60}; do
  if docker exec knp-ai-ollama-setup ollama list >/dev/null 2>&1; then
    ready=1
    break
  fi
  sleep 1
done
[[ "$ready" -eq 1 ]] || { docker logs knp-ai-ollama-setup; exit 1; }

docker exec knp-ai-ollama-setup ollama pull "$OLLAMA_MODEL"
docker rm -f knp-ai-ollama-setup

else
  echo "== Reparaturmodus: bestehende Docker-/Modellinstallation beibehalten =="
  command -v docker >/dev/null || { echo "ABBRUCH: Docker fehlt."; exit 1; }
  docker compose version >/dev/null || { echo "ABBRUCH: Docker Compose fehlt."; exit 1; }
  [[ -d "$DATA_ROOT/ollama" ]] || { echo "ABBRUCH: Modelldaten fehlen in $DATA_ROOT/ollama."; exit 1; }
fi

echo "== Nur-lokales API-Gateway vorbereiten =="
mkdir -p "$DATA_ROOT/stack"
# Gateway hat eine interne Verbindung zu Ollama und eine getrennte Bridge
# fuer den Loopback-Port. Ollama selbst behaelt ausschliesslich ai-internal.
cat >"$DATA_ROOT/stack/nginx-gateway.conf" <<'NGINX'
# Docker-DNS zur Laufzeit aufloesen, damit die optionale Test-UI
# noch nicht gestartet sein muss, wenn das Gateway hochfaehrt.
resolver 127.0.0.11 ipv6=off valid=10s;

server {
    listen 8080;
    location / {
        set $ollama_backend "ollama:11434";
        proxy_pass http://$ollama_backend;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_buffering off;
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
    }
}

server {
    listen 8081;
    client_max_body_size 100m;
    location / {
        set $webui_backend "open-webui:8080";
        proxy_pass http://$webui_backend;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_buffering off;
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
    }
}
NGINX

echo "== Produktions-Compose-Datei erzeugen =="
mkdir -p "$DATA_ROOT/stack"
cat >"$DATA_ROOT/stack/compose.yml" <<EOF
services:
  ollama:
    image: ${OLLAMA_IMAGE}
    restart: unless-stopped
    gpus: all
    environment:
      - OLLAMA_NO_CLOUD=true
    volumes:
      - ${DATA_ROOT}/ollama:/root/.ollama
    # Keine Host-Ports: Ollama selbst darf nur das interne Docker-Netz nutzen.
    networks:
      - ai-internal

  # Einziger lokaler Zugang aus Ubuntu; kein direkter Ollama-WAN-Zugriff.
  api-gateway:
    image: nginx:stable-alpine
    restart: unless-stopped
    depends_on:
      - ollama
    security_opt:
      - no-new-privileges:true
    volumes:
      - ${DATA_ROOT}/stack/nginx-gateway.conf:/etc/nginx/conf.d/default.conf:ro
    ports:
      - "127.0.0.1:11434:8080"
      - "127.0.0.1:${OPEN_WEBUI_PORT}:8081"
    networks:
      - ai-internal
      - gateway-network

  # Nur temporäre Testoberfläche; nicht Teil der späteren Produktionsarchitektur.
  open-webui:
    profiles: ["test-ui"]
    image: ${OPEN_WEBUI_IMAGE}
    restart: unless-stopped
    depends_on:
      - ollama
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
      - WEBUI_NAME=knp.bauphysik AI
      - 'WEBUI_BANNERS=[{"id":"knp-internal-ai","type":"success","content":"<img src=\"/knp-brand/knp-wordmark.svg\" width=\"170\" height=\"42\"> <span style=\"color:#8fbf3f;font-weight:700;\">Interne KI-Testoberfläche</span><br><small>Technische Testoberfläche auf Basis von Open WebUI. Produktiv ist später die eigene KNP Office-AI-Webapp vorgesehen.</small>","dismissible":true,"timestamp":1791380000}]'
    volumes:
      - ${DATA_ROOT}/openwebui:/app/backend/data
    # Lokaler Hostzugang ausschließlich über api-gateway.
    networks:
      - ai-internal

networks:
  ai-internal:
    internal: true
  gateway-network:
    driver: bridge
EOF

cd "$DATA_ROOT/stack"
# Erzwingt auch bei wiederholtem Skriptlauf die aktuelle Port-/GPU-Konfiguration.
docker compose up -d --force-recreate ollama api-gateway

echo "== Host-Port und Ollama-API testen =="
success=0
for _ in {1..60}; do
  if curl -fsS http://127.0.0.1:11434/api/tags >/dev/null 2>&1; then
    success=1
    break
  fi
  sleep 1
done

if [[ "$success" -ne 1 ]]; then
  echo "ABBRUCH: Ollama ist über 127.0.0.1:11434 nicht erreichbar."
  docker compose ps
  docker compose logs --tail=100 ollama api-gateway
  exit 1
fi

if ! docker compose port api-gateway 8080 | grep -q '127.0.0.1:11434'; then
  echo "ABBRUCH: Gateway-Port 127.0.0.1:11434 wurde nicht veröffentlicht."
  docker compose ps
  exit 1
fi

echo "== Modell und GPU-Pfad testen =="
docker compose exec -T ollama ollama list
# API-Test ohne interaktive Ollama-Shell; vermeidet haengende Installer.
curl --fail --silent --show-error --max-time 120 \
  http://127.0.0.1:11434/api/generate \
  -H 'Content-Type: application/json' \
  --data-binary @- <<EOF_API | python3 -c 'import json,sys; data=json.load(sys.stdin); assert data.get("done") is True and "response" in data, data; print("Ollama-Antwort:",data["response"].strip())'
{"model":"${OLLAMA_MODEL}","prompt":"Antworte ausschließlich mit OK.","stream":false,"options":{"num_ctx":2048}}
EOF_API
docker compose exec -T ollama ollama ps || true

echo
echo "LLM-Stack vorbereitet."
echo "Ollama laeuft intern mit GPU-Unterstuetzung; API auf Ubuntu nur via lokalem Gateway."
echo "Open WebUI ist vorbereitet, aber nicht gestartet."
echo "Modell: $OLLAMA_MODEL"
