#!/usr/bin/env bash
# =============================================================================
# java-install.sh – installiert alle Java-Versionen aus java.mycloudsrv.de
#                   nach /usr/lib/jvm und pflegt die Symlinks <name> → <JDK-Verzeichnis>
#
# Eigenschaften
#   • idempotent   – bereits aktuelle Versionen werden erkannt und übersprungen
#                    (Fingerabdruck = zwingend SHA256 aus dem freigegebenen API-Katalog)
#   • atomar       – erst herunterladen, prüfen, entpacken, testen – dann Symlink
#                    per rename() umschalten → kein Zeitfenster ohne lauffähiges Java
#   • dedupliziert – gleiche Datei unter mehreren Namen (latest = jdk-21) wird nur
#                    einmal geladen; beide Namen zeigen auf dasselbe Verzeichnis
#   • aufgeräumt  – entfernt automatisch ungenutzte, alte Corretto-/GraalVM-Verzeichnisse,
#                    alte Installer-Symlinks und liegengebliebene tar-Archive
#   • defensiv    – apt-JDKs und fremde Dateien bleiben erhalten; aktive Java-Prozesse,
#                    bekannte System-Java-Symlinks und vorhandene Aliase werden geschützt
#
# Aufruf:  java-install.sh [--prune | --no-prune]
#   --prune      Standard: nach erfolgreichem Update automatisch aufräumen
#   --no-prune   Aufräumen deaktivieren
#
# Umgebungsvariablen (optional):
#   JVM_DIR=/usr/lib/jvm   API_URL=…   EXCLUDE_NAMES="latest"
# =============================================================================
set -Eeuo pipefail
shopt -s nullglob

JVM_DIR="${JVM_DIR:-/usr/lib/jvm}"
API_URL="${API_URL:-https://java.mycloudsrv.de/?format=json}"
EXCLUDE_NAMES="${EXCLUDE_NAMES:-}"          # zu ignorierende Namen, durch Leerzeichen getrennt
MARKER=".java-install"                      # Fingerabdruck-Datei in jedem vom Script entpackten Verzeichnis
CURL_OPTS=(--fail --location --proto '=https' --proto-redir '=https'
           --retry 3 --retry-delay 3 --connect-timeout 20 --speed-limit 10240 --speed-time 60)
# Auch mitten in der Übertragung abgebrochene Downloads wiederholen (curl ≥ 7.71); zusammen mit
# --continue-at beim Download wird dann fortgesetzt statt neu begonnen (die API kann Range-Requests).
if curl --help all 2>&1 | grep -- '--retry-all-errors' >/dev/null; then CURL_OPTS+=(--retry-all-errors); fi
[[ -t 1 ]] && CURL_PROGRESS=(--progress-bar) || CURL_PROGRESS=(--silent --show-error)

log()  { printf '%s\n' "$*"; }
warn() { printf '⚠️  %s\n' "$*" >&2; }
err()  { printf '❌ %s\n' "$*" >&2; }
die()  { err "$@"; exit 1; }
usage() {
  cat <<EOF
Verwendung: ${0##*/} [--prune | --no-prune]
  --prune       (Standard) alte, unbenutzte Corretto-/GraalVM-Installationen,
                alte verwaltete Aliase und tar-Archive entfernen
  --no-prune    automatische Bereinigung unterdrücken
  -h, --help    Hilfe anzeigen
Umgebung:      JVM_DIR, API_URL, EXCLUDE_NAMES
Hinweis:       System-JDKs aus apt und laufende JVMs werden nicht entfernt.
EOF
}

# ─── Argumente ────────────────────────────────────────────────────────────────
PRUNE=1
for arg in "$@"; do
  case $arg in
    --prune)    PRUNE=1 ;;
    --no-prune) PRUNE=0 ;;
    -h|--help) usage; exit 0 ;;
    --purge)    die "--purge wurde aus Sicherheitsgruenden entfernt. Die gezielte Altversions-Bereinigung ist jetzt standardmaessig aktiv." ;;
    *)          usage >&2; die "Unbekannte Option: $arg" ;;
  esac
done

# ─── Voraussetzungen ──────────────────────────────────────────────────────────
for cmd in curl tar flock sha256sum readlink mktemp stat; do
  command -v "$cmd" >/dev/null 2>&1 || die "Benötigtes Programm fehlt: $cmd"
done
if   command -v jq      >/dev/null 2>&1; then PARSER=jq
elif command -v python3 >/dev/null 2>&1; then PARSER=python3
else die "jq oder python3 wird zum Parsen der API benötigt (apt install jq)"; fi

mkdir -p "$JVM_DIR" 2>/dev/null || die "Kann $JVM_DIR nicht anlegen – als root ausführen."
[[ -w $JVM_DIR ]]               || die "Keine Schreibrechte auf $JVM_DIR – als root ausführen."
JVM_DIR=$(readlink -f "$JVM_DIR")   # kanonischer Pfad – wird unten mit readlink -f verglichen

exec 9>"$JVM_DIR/.lock"
flock -n 9 || die "Es läuft bereits eine Instanz dieses Scripts (Lock: $JVM_DIR/.lock)."

# Reste abgebrochener Läufe entsorgen (wir halten das Lock) und eigenes Arbeitsverzeichnis anlegen.
# Es liegt bewusst in $JVM_DIR: gleiches Dateisystem → das finale mv ist ein atomares rename,
# und ein tmpfs unter /tmp wird nicht mit 200–400 MB pro JDK gefüllt.
find "$JVM_DIR" -mindepth 1 -maxdepth 1 -name '.tmp.*' -exec rm -rf {} +
WORK=$(mktemp -d "$JVM_DIR/.tmp.XXXXXX")
trap 'rm -rf "$WORK"' EXIT
trap 'err "Abbruch in Zeile $LINENO: $BASH_COMMAND"' ERR

# ─── API ──────────────────────────────────────────────────────────────────────
# Gibt pro Version eine Zeile aus:  name␟filename␟download_url␟sha256␟size_bytes
# (␟ = ASCII 0x1F, damit leere Felder nicht verschluckt werden). Findet die Einträge
# unabhängig von der JSON-Struktur (Objekt mit Schlüsseln oder Array). $1 = JSON-Datei
parse_versions() {
  if [[ $PARSER == jq ]]; then
    jq -r '[.. | objects | select(has("name") and has("filename") and has("download_url"))][]
           | [.name, .filename, .download_url, (.sha256 // .checksum // ""), (.size_bytes // "")]
           | map(tostring) | join("\u001f")' "$1"
  else
    python3 -I - "$1" <<'PY'
import json, sys
def walk(o):
    if isinstance(o, dict):
        if {"name", "filename", "download_url"} <= o.keys():
            yield o
        for v in o.values():
            yield from walk(v)
    elif isinstance(o, list):
        for v in o:
            yield from walk(v)
with open(sys.argv[1], encoding="utf-8") as fh:
    data = json.load(fh)
for e in walk(data):
    f = [e.get("name"), e.get("filename"), e.get("download_url"),
         e.get("sha256") or e.get("checksum") or "", e.get("size_bytes") or ""]
    print("\x1f".join("" if v is None else str(v) for v in f))
PY
  fi
}

log "📡 Hole Versionsliste von $API_URL ..."
curl "${CURL_OPTS[@]}" --silent --show-error -o "$WORK/api.json" "$API_URL" || die "API nicht erreichbar."
parse_versions "$WORK/api.json" > "$WORK/versions.lst" || die "API-Antwort konnte nicht geparst werden."
[[ -s $WORK/versions.lst ]] || die "Keine Versionen in der API-Antwort gefunden."

# ─── Hilfsfunktionen ──────────────────────────────────────────────────────────
is_excluded() { local x; for x in $EXCLUDE_NAMES; do [[ $1 == "$x" ]] && return 0; done; return 1; }

# Verzeichnis, auf das der verwaltete Symlink $1 aktuell zeigt (nur mit Marker)
current_dir() {
  local link="$JVM_DIR/$1" t
  [[ -L $link ]] || return 1
  t=$(readlink -f "$link") || return 1
  [[ -f $t/$MARKER ]] || return 1
  printf '%s\n' "$t"
}

# Bereits vorhandenes verwaltetes Verzeichnis mit Fingerabdruck $1
find_by_fingerprint() {
  local m
  for m in "$JVM_DIR"/*/"$MARKER"; do
    [[ -L ${m%/*} ]] && continue                       # nur echte Verzeichnisse, keine Symlinks
    [[ $(<"$m") == "$1" ]] && { printf '%s\n' "${m%/*}"; return 0; }
  done
  return 1
}

# Symlink $JVM_DIR/$1 → $2 atomar setzen (rename über den alten Link)
link_version() {
  local link="$JVM_DIR/$1" tmp="$JVM_DIR/.tmp.link.$1.$$"
  if [[ -e $link && ! -L $link ]]; then
    err "$link ist ein echtes Verzeichnis/eine Datei und wird nicht vom Script verwaltet – bitte manuell prüfen"
    return 1
  fi
  ln -s "$2" "$tmp" && mv -Tf "$tmp" "$link" || { rm -f "$tmp"; return 1; }
}

# Archiv laden, prüfen, entpacken, testen und nach $JVM_DIR verschieben; Ergebnis in NEW_DIR.
# Wird in einer ||-Liste aufgerufen → set -e gilt hier NICHT, daher wird jeder Schritt explizit geprüft.
install_archive() {
  local name=$1 filename=$2 url=$3 sha=$4 size=$5 fp=$6
  local archive="$WORK/$filename" extract="$WORK/extract.$name" top base dir have

  log "   ⬇️  Download: $url"
  curl "${CURL_OPTS[@]}" "${CURL_PROGRESS[@]}" --continue-at - -o "$archive" "$url" || { err "Download fehlgeschlagen"; return 1; }

  have=$(sha256sum "$archive" | cut -d' ' -f1)
  [[ ${have,,} == "${sha,,}" ]] || { err "SHA256 falsch (erwartet $sha, erhalten $have)"; return 1; }
  have=$(stat -c %s "$archive")
  [[ $have == "$size" ]] || { err "Dateigroesse falsch (erwartet $size, erhalten $have Bytes)"; return 1; }
  log "   🔒 SHA256 und Dateigroesse geprueft"

  log "   📂 Entpacke ..."
  mkdir -p "$extract" || return 1
  # --no-same-owner: Dateien gehören root, nicht der UID aus dem Archiv (sonst könnte ein
  # lokaler Nutzer mit dieser UID das JDK manipulieren); --no-same-permissions: umask anwenden
  tar -xf "$archive" -C "$extract" --no-same-owner --no-same-permissions || { err "Entpacken fehlgeschlagen"; return 1; }
  rm -f "$archive"

  local entries=("$extract"/*)
  if (( ${#entries[@]} == 1 )) && [[ -d ${entries[0]} ]]; then
    top=${entries[0]}; base=${top##*/}                            # übliches Layout: ein Wurzelverzeichnis
  else
    top=$extract; base=${filename%.tgz}; base=${base%.tar*}        # Archiv ohne Wurzelverzeichnis
  fi
  [[ -x $top/bin/java ]] || { err "Archiv enthält kein bin/java"; return 1; }
  "$top/bin/java" -version >/dev/null 2>&1 || { err "bin/java startet nicht (falsche Architektur/libc?)"; return 1; }
  printf '%s\n' "$fp" > "$top/$MARKER" || return 1

  # SHA-spezifischer, unveraenderlicher Ordner: ein laufender JVM-Prozess
  # verliert nie seine Dateien, bevor der Symlink atomar umgeschaltet ist.
  dir="$JVM_DIR/$base-${sha:0:16}"
  if [[ -e $dir || -L $dir ]]; then
    err "Ziel existiert bereits; verweigere unsicheres Ueberschreiben: $dir"
    return 1
  fi
  mv -T "$top" "$dir" || return 1
  NEW_DIR=$dir
}

# ─── Hauptschleife ────────────────────────────────────────────────────────────
declare -A DIR_OF_FP=()        # Fingerabdruck → Verzeichnis (Dedupe innerhalb dieses Laufs)
declare -A API_NAMES=()
ORDER=() OLD_DIRS=()
INSTALLED=0 SKIPPED=0 ERRORS=0

while IFS=$'\x1f' read -r -u 3 NAME FILENAME URL SHA SIZE; do
  is_excluded "$NAME" && continue

  # API-Daten validieren – sie landen in Pfaden, die als root angelegt und gelöscht werden
  if [[ ! $NAME =~ ^[A-Za-z0-9][A-Za-z0-9._+-]*$ ]]; then
    warn "Ungültiger Name '$NAME' – übersprungen"; ERRORS=$((ERRORS+1)); continue; fi
  if [[ ! $FILENAME =~ ^[A-Za-z0-9][A-Za-z0-9._+-]*\.(tgz|tar(\.(gz|xz|bz2|zst))?)$ ]]; then
    warn "$NAME: ungültiger Dateiname '$FILENAME' – übersprungen"; ERRORS=$((ERRORS+1)); continue; fi
  if [[ ! $URL =~ ^https://java\.mycloudsrv\.de/ ]]; then
    warn "$NAME: ungültige URL '$URL' – übersprungen"; ERRORS=$((ERRORS+1)); continue; fi

  API_NAMES[$NAME]=1; ORDER+=("$NAME")
  if [[ ! $SHA =~ ^[a-fA-F0-9]{64}$ || ! $SIZE =~ ^[1-9][0-9]*$ ]]; then
    err "$NAME: API muss verifizierten SHA256 und Dateigroesse liefern."; ERRORS=$((ERRORS+1)); continue
  fi
  FP=${SHA,,}                              # IMMER den SHA256 als Fingerabdruck

  log "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
  log "📦 $NAME  ($FILENAME)"

  CUR=$(current_dir "$NAME" || true)
  if [[ -n $CUR ]]; then
    CUR_FP=$(<"$CUR/$MARKER")
    if [[ $CUR_FP == "$FP" ]]; then
      log "   ✅ bereits aktuell → ${CUR##*/}"; SKIPPED=$((SKIPPED+1)); continue
    fi
  fi

  if [[ -n ${DIR_OF_FP[$FP]:-} ]]; then
    DIR=${DIR_OF_FP[$FP]}; log "   ♻️  gleiche Datei wie ein anderer Name → ${DIR##*/}"
  elif DIR=$(find_by_fingerprint "$FP"); then
    log "   ♻️  bereits vorhanden → ${DIR##*/}"
  else
    NEW_DIR=""
    install_archive "$NAME" "$FILENAME" "$URL" "$SHA" "$SIZE" "$FP" || {
      err "   $NAME konnte nicht installiert werden – bisherige Version bleibt unverändert"
      ERRORS=$((ERRORS+1)); continue; }
    DIR=$NEW_DIR; log "   📁 Installiert als ${DIR##*/}"
  fi
  DIR_OF_FP[$FP]=$DIR

  link_version "$NAME" "$DIR" || { ERRORS=$((ERRORS+1)); continue; }
  log "   🔗 $JVM_DIR/$NAME → $DIR"
  INSTALLED=$((INSTALLED+1))
  [[ -n $CUR && $CUR != "$DIR" ]] && OLD_DIRS+=("$CUR")
done 3< "$WORK/versions.lst"

# ─── Aufräumen ────────────────────────────────────────────────────────────────
# Nur freigegebene und erfolgreich installierte API-Versionen dürfen die
# Bereinigung auslösen. Bei einem einzelnen Fehler bleibt der gesamte Bestand.
CLEANED_DIRS=0 CLEANED_LINKS=0 CLEANED_ARCHIVES=0 KEPT_BUSY=0

# Die alten Vorgänger-Skripte haben Runtime-Verzeichnisse ohne .java-install-
# Marker und tar.gz-Dateien direkt unter /usr/lib/jvm zurückgelassen.
# Erkenne ausschließlich die eigenen bekannten Distributionsnamen, NICHT
# beliebige Dateien oder das vom Paketmanager verwaltete OpenJDK.
is_legacy_runtime_name() {
  local n=$1
  [[ $n =~ ^amazon-corretto-[0-9][A-Za-z0-9.+_-]*-linux-x64(-[a-fA-F0-9]{16})?$ ||
     $n =~ ^graalvm(-community)?-jdk-[0-9][A-Za-z0-9.+_-]*$ ]]
}
is_legacy_archive_name() {
  local n=$1
  [[ $n =~ ^amazon-corretto-[0-9][A-Za-z0-9.+_-]*-linux-x64\.(tar\.(gz|xz)|tgz)$ ||
     $n =~ ^graalvm(-community)?-jdk-[0-9][A-Za-z0-9.+_-]*\.(tar\.(gz|xz)|tgz)$ ]]
}
is_legacy_alias_name() {
  local n=$1
  [[ $n =~ ^(latest|jdk-[0-9]+|graalvm(-ce)?-[0-9]+|jdk-[0-9]+-graalvm(-ce)?)$ ]]
}

# Laufende JVMs gegen Löschen schützen; /proc/PID/exe zeigt auf den
# tatsächlich ausgeführten Java-Binary-Pfad, auch wenn Java per Symlink
# gestartet wurde. Erkanntes aktives Verzeichnis wird vollständig belassen.
runtime_in_use() {
  local directory=$1 exe real
  for exe in /proc/[0-9]*/exe; do
    real=$(readlink "$exe" 2>/dev/null) || continue
    [[ $real == "$directory"/* ]] && return 0
  done
  return 1
}

# Die Standard-System-Java-Auswahl kann auf einen alten Runtime-Ordner zeigen.
# Solange sie umgestellt werden muss, nicht aufräumen.
external_java_reference() {
  local directory=$1 f resolved
  for f in /usr/bin/java /usr/bin/javac /etc/alternatives/java /etc/alternatives/javac; do
    resolved=$(readlink -f -- "$f" 2>/dev/null) || continue
    [[ $resolved == "$directory"/* ]] && return 0
  done
  [[ -n ${JAVA_HOME:-} ]] &&
    { resolved=$(readlink -f -- "$JAVA_HOME" 2>/dev/null) || resolved=""; [[ $resolved == "$directory" ]]; } && return 0
  return 1
}

# Schützt sämtliche Verzeichnisse, die weiterhin von einem Symlink IN
# /usr/lib/jvm referenziert werden (auch unbekannten, nutzereigenen Links).
declare -A REFERENCED=()
scan_refs() {
  REFERENCED=()
  local l t
  for l in "$JVM_DIR"/*; do
    [[ -L $l ]] || continue
    t=$(readlink -f -- "$l" 2>/dev/null) || continue
    [[ $t == "$JVM_DIR"/* ]] && REFERENCED[$t]=1
  done
}

if (( ERRORS > 0 )); then
  warn "Installationsfehler: automatische Bereinigung komplett ausgesetzt."
elif (( PRUNE )); then
  log ""
  log "🧹 Automatische Bereinigung alter Java-Versionen ..."

  # Zuerst verwaiste, bekannte Java-Aliase aus alten Installern entfernen.
  # Keine Alias- oder Runtime-Namen löschen, die weiterhin in der API stehen.
  for l in "$JVM_DIR"/*; do
    [[ -L $l ]] || continue
    n=${l##*/}
    [[ -n ${API_NAMES[$n]:-} ]] && continue
    is_excluded "$n" && continue
    t=$(readlink -f -- "$l" 2>/dev/null || true)
    [[ -n $t && $t == "$JVM_DIR"/* ]] || continue
    # Entweder Marker des aktuellen Installers oder ein bekannter Alt-Runtime-Name.
    [[ -f $t/$MARKER ]] || is_legacy_runtime_name "${t##*/}" || continue
    # Nicht irgendwelche benutzerdefinierten Symlinks entfernen.
    is_legacy_alias_name "$n" || continue
    if runtime_in_use "$t" || external_java_reference "$t"; then
      warn "Alias $n zeigt auf noch benutzte Runtime ${t##*/}; bleibt vorerst erhalten"
      KEPT_BUSY=$((KEPT_BUSY+1))
      continue
    fi
    log "   🗑️  Alter Symlink: $n"
    rm -f -- "$l" || die "Konnte $l nicht entfernen"
    CLEANED_LINKS=$((CLEANED_LINKS+1))
  done

  # Nun sämtliche nicht mehr referenzierten alten Verzeichnisse entfernen,
  # auch solche von früheren Skriptversionen ohne .java-install-Marker.
  scan_refs
  for d in "$JVM_DIR"/*; do
    [[ -d $d && ! -L $d ]] || continue
    n=${d##*/}
    # Alte Aliasnamen aus frueheren Installern koennen auch echte Ordner
    # statt Symlinks sein; nur mit lauffaehigem bin/java beruecksichtigen.
    if [[ -f $d/$MARKER ]]; then
      :
    elif [[ -x $d/bin/java ]] && { is_legacy_runtime_name "$n" || { is_legacy_alias_name "$n" && [[ -z ${API_NAMES[$n]:-} ]]; }; }; then
      :
    else
      continue
    fi
    [[ -z ${REFERENCED[$d]:-} ]] || continue
    if runtime_in_use "$d" || external_java_reference "$d"; then
      warn "Alte Runtime $n ist noch in Benutzung/als System-Java eingetragen; bleibt erhalten"
      KEPT_BUSY=$((KEPT_BUSY+1))
      continue
    fi
    log "   🗑️  Alte Runtime: $n"
    rm -rf -- "$d" || die "Konnte $d nicht entfernen"
    CLEANED_DIRS=$((CLEANED_DIRS+1))
  done

  # Alte Java-Tarballs aus Vorgängerinstallationen sind nach dem Entpacken
  # überflüssig. Nur eindeutig erkennbare Herstellerarchive löschen.
  for f in "$JVM_DIR"/*; do
    [[ -f $f && ! -L $f ]] || continue
    n=${f##*/}
    is_legacy_archive_name "$n" || continue
    log "   🗑️  Alter Download: $n"
    rm -f -- "$f" || die "Konnte $f nicht entfernen"
    CLEANED_ARCHIVES=$((CLEANED_ARCHIVES+1))
  done

  log "   Bereinigt: $CLEANED_DIRS Verzeichnisse · $CLEANED_LINKS Links · $CLEANED_ARCHIVES Archive"
  (( KEPT_BUSY == 0 )) || warn "$KEPT_BUSY alte Eintraege wegen laufender JVM/System-Java vorerst behalten"
else
  log "🧹 Bereinigung mit --no-prune deaktiviert"
fi

# ─── Ergebnis ─────────────────────────────────────────────────────────────────
log ""
log "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
log "📊 $INSTALLED installiert/aktualisiert · $SKIPPED bereits aktuell · $ERRORS Fehler · $CLEANED_DIRS Runtime(s), $CLEANED_LINKS Links, $CLEANED_ARCHIVES Archive bereinigt"
for n in "${ORDER[@]}"; do
  if t=$(readlink -f "$JVM_DIR/$n" 2>/dev/null) && [[ -x $t/bin/java ]]; then
    v=$("$t/bin/java" -version 2>&1 | sed -n '1p')
    printf '   %-12s → %-45s %s\n' "$n" "${t##*/}" "$v"
  else
    printf '   %-12s → FEHLT\n' "$n"
  fi
done
exit $(( ERRORS > 0 ))
