#!/usr/bin/env bash
# LiveTalking + Wav2Lip: Testaufbau auf Quadro P2000 (Karte 2)
# Stufe 0 (Prüfung) und Stufe 1 (Installation, Start, FPS-Auswertung)
#
# Benutzung:
#   bash livetalking-setup.sh check     # nur prüfen (Treiber, Karte, Ollama-Belegung)
#   bash livetalking-setup.sh install   # Umgebung + PyTorch + LiveTalking installieren
#   bash livetalking-setup.sh run       # Avatar starten (Karte 2), Log nach livetalking.log
#   bash livetalking-setup.sh fps       # FPS-Werte aus dem Log zusammenfassen
#   bash livetalking-setup.sh service   # als Dienst einrichten (startet mit dem Server, startet sich nach Fehlern neu)
#   bash livetalking-setup.sh firewall  # Firewall dauerhaft und nur fürs eigene Netz öffnen
#   bash livetalking-setup.sh status    # Zustand des Dienstes und die letzten Log-Zeilen
#
# Einstellungen (vorher mit export ändern, falls nötig):
#   GPU_INDEX=2          Nummer der Karte laut nvidia-smi (PCI-Reihenfolge)
#   BASE=/srv/livetalking
#   TORCH_CUDA=cu126     (Pascal-Karten wie die P2000 brauchen cu126; cu128 enthält sie nicht mehr)
#   AVATAR=wav2lip256_avatar1
set -euo pipefail

GPU_INDEX="${GPU_INDEX:-2}"
BASE="${BASE:-/srv/livetalking}"
TORCH_CUDA="${TORCH_CUDA:-cu126}"
AVATAR="${AVATAR:-wav2lip256_avatar1}"
PORT="${PORT:-8010}"
VENV="$BASE/venv"
REPO="$BASE/LiveTalking"
LOG="$BASE/livetalking.log"

say() { printf '\n== %s ==\n' "$*"; }
die() { printf 'FEHLER: %s\n' "$*" >&2; exit 1; }

do_check() {
  say "Treiber und Karten"
  command -v nvidia-smi >/dev/null || die "nvidia-smi nicht gefunden"
  nvidia-smi --query-gpu=index,name,pci.bus_id,driver_version,memory.used,memory.total --format=csv
  local name
  name=$(nvidia-smi -i "$GPU_INDEX" --query-gpu=name --format=csv,noheader) || die "Karte $GPU_INDEX gibt es nicht"
  echo "Gewählt: Karte $GPU_INDEX = $name"

  say "Belegung durch Ollama"
  local used
  used=$(nvidia-smi -i "$GPU_INDEX" --query-gpu=memory.used --format=csv,noheader,nounits | tr -d ' ')
  if [ "$used" -gt 300 ]; then
    echo "WARNUNG: Karte $GPU_INDEX belegt schon $used MiB. Läuft dort Ollama? Andere freie Karte wählen (GPU_INDEX=3)."
  else
    echo "Karte $GPU_INDEX ist frei ($used MiB)."
  fi
  echo "Hinweis: Ist Ollama gerade entladen, sind alle Karten leer. Dann vorher eine Frage an Aura stellen und nochmal prüfen."

  say "Treiber-Paket gegen Updates sperren (Pascal braucht Treiber 580)"
  if command -v dpkg >/dev/null 2>&1; then
    local pkg
    pkg=$(dpkg -l 2>/dev/null | awk '/^ii +(nvidia-driver|nvidia-dkms|nvidia-kernel-source|libnvidia-compute)/ {print $2}' | tr '\n' ' ' || true)
    if [ -n "$pkg" ]; then echo "Sperren mit:  sudo apt-mark hold $pkg"
    else echo "Kein apt-Treiberpaket gefunden (evtl. per .run-Datei installiert, dann nichts zu tun)."; fi
  elif command -v rpm >/dev/null 2>&1; then
    local pkg
    pkg=$(rpm -qa 2>/dev/null | grep -Ei '^(nvidia-driver|kmod-nvidia|akmod-nvidia|xorg-x11-drv-nvidia)' | tr '\n' ' ' || true)
    echo "RPM-System. Gefundene Pakete: ${pkg:-keine}"
    echo "Sperren mit:  sudo dnf install -y python3-dnf-plugin-versionlock && sudo dnf versionlock add ${pkg:-<nvidia-Pakete>}"
  else
    echo "Weder dpkg noch rpm gefunden. Prüfe selbst, wie der Treiber installiert wurde, und sperre ihn gegen Updates."
  fi
  echo "Grund: Treiber 580 ist die letzte Version mit Pascal-Unterstützung."

  say "Werkzeuge"
  for t in git curl ffmpeg; do
    command -v "$t" >/dev/null && echo "ok: $t" || echo "FEHLT: $t  (mit dem Paketmanager installieren)"
  done
  command -v uv >/dev/null && echo "ok: uv" || echo "uv fehlt, wird bei 'install' automatisch installiert"
}

do_install() {
  mkdir -p "$BASE"
  command -v git >/dev/null || die "git fehlt (mit dem Paketmanager installieren)"
  command -v ffmpeg >/dev/null || die "ffmpeg fehlt (mit dem Paketmanager installieren)"

  if ! command -v uv >/dev/null; then
    say "uv installieren"
    curl -LsSf https://astral.sh/uv/install.sh | sh
    export PATH="$HOME/.local/bin:$PATH"
  fi

  say "Python 3.12 Umgebung"
  [ -d "$VENV" ] || uv venv --python 3.12 "$VENV"
  # shellcheck disable=SC1091
  source "$VENV/bin/activate"

  say "PyTorch 2.9.1 ($TORCH_CUDA)"
  uv pip install "torch==2.9.1+$TORCH_CUDA" "torchvision==0.24.1+$TORCH_CUDA" "torchaudio==2.9.1+$TORCH_CUDA" \
    --index-url "https://download.pytorch.org/whl/$TORCH_CUDA"

  say "Pascal-Prüfung (sm_61 muss in der Liste stehen)"
  CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES="$GPU_INDEX" python - <<'PY'
import sys, torch
arch = torch.cuda.get_arch_list()
print("Architekturen:", arch)
print("CUDA verfügbar:", torch.cuda.is_available())
if not torch.cuda.is_available():
    sys.exit("CUDA nicht verfügbar")
print("Karte:", torch.cuda.get_device_name(0), "Compute", torch.cuda.get_device_capability(0))
if not any(a in arch for a in ("sm_61","sm_60","compute_61","compute_60")):
    sys.exit("PASCAL FEHLT in diesem PyTorch-Build -> TORCH_CUDA=cu126 bash livetalking-setup.sh install")
x = torch.randn(1024, 1024, device="cuda"); (x @ x).sum().item()
print("Rechentest ok")
PY

  say "LiveTalking holen"
  [ -d "$REPO/.git" ] || git clone https://github.com/lipku/LiveTalking.git "$REPO"
  cd "$REPO"
  uv pip install -r requirements.txt

  mkdir -p models data/avatars
  say "Fertig. Jetzt die Modelldateien von Hand ablegen"
  cat <<EOF
Die Dateien liegen auf Quark/Google Drive (Links im README von
https://github.com/lipku/LiveTalking), das lässt sich nicht automatisch laden.

  1. wav2lip256.pth           -> $REPO/models/wav2lip.pth   (umbenennen!)
  2. wav2lip256_avatar1.tar.gz -> entpacken, Ordner nach $REPO/data/avatars/

Danach:  bash $0 run
EOF
}

do_run() {
  [ -d "$REPO" ] || die "Erst 'install' ausführen"
  [ -f "$REPO/models/wav2lip.pth" ] || die "models/wav2lip.pth fehlt"
  [ -d "$REPO/data/avatars/$AVATAR" ] || die "data/avatars/$AVATAR fehlt"
  # shellcheck disable=SC1091
  source "$VENV/bin/activate"
  cd "$REPO"
  say "Start auf Karte $GPU_INDEX, Seite: http://<server>:$PORT/index.html (Log: $LOG)"
  echo "Beenden mit Strg+C. Danach: bash $0 fps"
  CUDA_DEVICE_ORDER=PCI_BUS_ID CUDA_VISIBLE_DEVICES="$GPU_INDEX" \
    python app.py --transport webrtc --model wav2lip --avatar_id "$AVATAR" --listenport "$PORT" 2>&1 | tee "$LOG"
}

do_fps() {
  [ -f "$LOG" ] || die "Kein Log ($LOG). Erst 'run'."
  say "FPS-Auswertung (Ziel: inferfps UND finalfps dauerhaft >= 25)"
  python3 - "$LOG" <<'PY'
import re, sys, statistics as st
t = open(sys.argv[1], errors="ignore").read()
for key in ("inferfps", "finalfps"):
    v = [float(x) for x in re.findall(key + r"[:=\s]+([0-9.]+)", t)]
    if not v:
        print(f"{key}: keine Werte im Log gefunden"); continue
    print(f"{key}: n={len(v)} min={min(v):.1f} median={st.median(v):.1f} max={max(v):.1f}")
    print("   ->", "REICHT" if st.median(v) >= 25 else "ZU LANGSAM")
PY
  echo
  echo "Wenn keine Werte erscheinen: im Log nach 'fps' suchen (grep -i fps $LOG | tail) und das Muster oben anpassen."
}

do_service() {
  [ -d "$REPO" ] || die "Erst 'install' ausführen"
  [ -f "$REPO/models/wav2lip.pth" ] || die "models/wav2lip.pth fehlt"
  [ -d "$REPO/data/avatars/$AVATAR" ] || die "data/avatars/$AVATAR fehlt"
  command -v systemctl >/dev/null || die "systemctl fehlt"
  local unit=/etc/systemd/system/livetalking.service
  say "Dienst anlegen: $unit (Benutzer $USER, Karte $GPU_INDEX, Avatar $AVATAR, Port $PORT)"
  sudo tee "$unit" >/dev/null <<EOF
[Unit]
Description=LiveTalking Avatar (Wav2Lip) fuer AuraChat
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=$USER
WorkingDirectory=$REPO
Environment=CUDA_DEVICE_ORDER=PCI_BUS_ID
Environment=CUDA_VISIBLE_DEVICES=$GPU_INDEX
Environment=PYTHONUNBUFFERED=1
ExecStart=$VENV/bin/python app.py --transport webrtc --model wav2lip --avatar_id $AVATAR --listenport $PORT
Restart=on-failure
RestartSec=5
# Das Log (inferfps / finalfps) steht im Journal: journalctl -u livetalking -f
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
EOF
  sudo systemctl daemon-reload
  # Läuft der Avatar noch von Hand (Vordergrund-Fenster)? Das belegt Port $PORT.
  if ss -tln 2>/dev/null | grep -q ":$PORT "; then
    echo "WARNUNG: Port $PORT ist belegt (läuft der Avatar noch im Fenster?). Dort mit Strg+C beenden, dann:"
    echo "  sudo systemctl enable --now livetalking"
    return 0
  fi
  sudo systemctl enable --now livetalking
  sleep 4
  do_status
}

do_status() {
  systemctl is-enabled livetalking 2>/dev/null || true
  systemctl --no-pager status livetalking 2>&1 | head -12 || true
  echo "--- letzte Log-Zeilen ---"
  journalctl -u livetalking --no-pager -n 8 2>/dev/null || true
  echo "Hinweis: Bei 'status=203/EXEC' blockiert SELinux die Dateien in $BASE:  sudo chcon -R -t bin_t $VENV/bin"
}

do_firewall() {
  command -v firewall-cmd >/dev/null || die "firewall-cmd fehlt (keine firewalld)"
  local ip net
  ip=$(ip -4 -o route get 1.1.1.1 2>/dev/null | sed -n 's/.* src \([0-9.]*\).*/\1/p' | head -1)
  net="${LAN:-}"
  [ -n "$net" ] || { [ -n "$ip" ] && net="${ip%.*}.0/24"; }
  [ -n "$net" ] || die "Eigenes Netz nicht erkannt. Mit LAN=10.0.55.0/24 bash $0 firewall angeben."
  say "Geplant (dauerhaft): Port $PORT/tcp und UDP 1024-65535 NUR für das Netz $net"
  echo "Das UDP-Fenster braucht WebRTC für das Video. Aus dem Internet ist der Avatar-Server damit nicht erreichbar."
  echo "Entfernt wird die frühere Freigabe von $PORT/tcp für alle (falls vorhanden)."
  read -r -p "Fortfahren? [j/N] " a
  [ "$a" = "j" ] || [ "$a" = "J" ] || { echo "Abgebrochen."; return 0; }
  sudo firewall-cmd --permanent --remove-port="$PORT/tcp" >/dev/null 2>&1 || true
  sudo firewall-cmd --permanent --add-rich-rule="rule family=\"ipv4\" source address=\"$net\" port port=\"$PORT\" protocol=\"tcp\" accept"
  sudo firewall-cmd --permanent --add-rich-rule="rule family=\"ipv4\" source address=\"$net\" port port=\"1024-65535\" protocol=\"udp\" accept"
  sudo firewall-cmd --reload
  sudo firewall-cmd --list-rich-rules
  echo "Hinweis: Der AuraChat-Container erreicht den Avatar über das Docker-Netz (Zone 'docker', erlaubt). Ob es klappt, zeigt im Admin Panel 'Verbindung testen'."
}

case "${1:-}" in
  check)   do_check ;;
  install) do_check; do_install ;;
  run)     do_run ;;
  fps)     do_fps ;;
  service) do_service ;;
  status)  do_status ;;
  firewall) do_firewall ;;
  *) sed -n '2,20p' "$0"; exit 1 ;;
esac
