#!/usr/bin/env bash
# WWS installieren oder aktualisieren (Linux mit systemd, x86_64 oder aarch64):
#
#   curl -fsSL https://kassier.eu/install.sh | sudo bash
#
# Erster Lauf: legt Dienstbenutzer, /srv/wws/<instanz>, Umgebung (mit neuem ERP_SECRET_KEY), systemd-Dienst und
# den ersten Administrator an und startet WWS hinter 127.0.0.1:<port>. Jeder weitere Lauf aktualisiert auf die
# angegebene oder neueste Version. Startet sie nicht und hat sie noch keine Migration angewandt, geht der Dienst
# auf die vorherige zurück. Die Umgebung und die Daten bleiben unverändert.
#
# Einstellungen als Umgebung oder Abfrage (bei `curl | bash` über das Terminal):
#   WWS_URL          öffentliche Adresse, z. B. https://wws.firma.de (nur erster Lauf)
#   WWS_ADMIN_EMAIL  erster Administrator (nur erster Lauf)
#   WWS_S3_ENDPOINT, WWS_S3_BUCKET, WWS_S3_REGION, WWS_S3_ACCESS_KEY_ID, WWS_S3_SECRET_ACCESS_KEY
#                    Dateiablage (Anhänge, Druck, Medien) in einem S3-kompatiblen Speicher, z. B. Hetzner Object
#                    Storage, Cloudflare R2 oder Garage/MinIO auf dem eigenen Server (nur erster Lauf)
#   WWS_TUNNEL_TOKEN Token eines Cloudflare-Tunnels im Konto des Kunden (optional, statt Reverse Proxy und offener
#                    Ports): installiert cloudflared aus der Paketquelle von Cloudflare (Debian/Ubuntu) als Dienst.
#                    Hostname und Ziel http://127.0.0.1:<port> stehen im Cloudflare-Dashboard.
#   WWS_LICENSE_FILE Lizenzdatei (optional, jeder Lauf): wird geprüft und nach <daten>/lizenz.json übernommen
#   WWS_VERSION      Version, Vorgabe: neueste
#   WWS_INSTANCE     Instanzname, Vorgabe: prod
#   WWS_PORT         lokaler Port, Vorgabe: 8080
#   WWS_RELEASES     Bezugsquelle, Vorgabe: https://kassier.eu/releases
#   WWS_ARCHIVE      lokales Release-Archiv statt Download (Rechner ohne Internet); SHA256SUMS daneben
set -euo pipefail

RELEASES="${WWS_RELEASES:-https://kassier.eu/releases}"
INSTANCE="${WWS_INSTANCE:-prod}"
PORT="${WWS_PORT:-8080}"
ROOT="/srv/wws/$INSTANCE"

say() { printf '\033[1m==\033[0m %s\n' "$*"; }
die() { printf 'Fehler: %s\n' "$*" >&2; exit 1; }
ask() { # ask VAR "Frage" [Vorgabe]
  local var="$1" prompt="$2" def="${3:-}" val="${!1:-}"
  if [ -z "$val" ]; then
    [ -r /dev/tty ] || die "$var fehlt (kein Terminal für die Abfrage)"
    read -r -p "$prompt${def:+ [$def]}: " val < /dev/tty
    val="${val:-$def}"
  fi
  [ -n "$val" ] || die "$var fehlt"
  printf -v "$var" '%s' "$val"
}

# --- Voraussetzungen ---------------------------------------------------------------------------------------------
[ "$(id -u)" = 0 ] || die "bitte als root ausführen (sudo)"
[ "$(uname -s)" = Linux ] || die "nur Linux wird unterstützt"
command -v systemctl >/dev/null || die "systemd fehlt"
for c in curl tar sha256sum openssl runuser; do command -v "$c" >/dev/null || die "$c fehlt"; done
case "$(uname -m)" in
  x86_64 | amd64) ARCH=x86_64 ;;
  aarch64 | arm64) ARCH=aarch64 ;;
  *) die "Architektur $(uname -m) wird nicht unterstützt" ;;
esac
case "$INSTANCE" in *[!a-z0-9-]* | "") die "WWS_INSTANCE: nur a-z, 0-9 und -" ;; esac

# --- Release holen und prüfen ------------------------------------------------------------------------------------
WORK="$(mktemp -d)"
trap 'rm -rf "$WORK"' EXIT
if [ -n "${WWS_ARCHIVE:-}" ]; then
  ARCHIVE="$WWS_ARCHIVE"
  SUMS="$(dirname "$ARCHIVE")/SHA256SUMS"
  [ -f "$ARCHIVE" ] && [ -f "$SUMS" ] || die "$ARCHIVE oder SHA256SUMS daneben fehlt"
  VERSION="${WWS_VERSION:-$(basename "$ARCHIVE" | sed -E 's/^wws-(.+)-linux-.*$/\1/')}"
else
  VERSION="${WWS_VERSION:-$(curl -fsSL "$RELEASES/latest" | tr -d '[:space:]')}"
  [ -n "$VERSION" ] || die "neueste Version unter $RELEASES/latest nicht lesbar"
  NAME="wws-$VERSION-linux-$ARCH.tar.gz"
  say "Lade WWS $VERSION ($ARCH)"
  curl -fsSL -o "$WORK/$NAME" "$RELEASES/$VERSION/$NAME"
  curl -fsSL -o "$WORK/SHA256SUMS" "$RELEASES/$VERSION/SHA256SUMS"
  ARCHIVE="$WORK/$NAME"
  SUMS="$WORK/SHA256SUMS"
fi
case "$VERSION" in *[!A-Za-z0-9._-]* | "") die "ungültige Version '$VERSION'" ;; esac
EXPECTED="$(awk -v n="$(basename "$ARCHIVE")" '$2 == n || $2 == "*"n { print $1 }' "$SUMS")"
[ -n "$EXPECTED" ] || die "$(basename "$ARCHIVE") steht nicht in SHA256SUMS"
[ "$(sha256sum "$ARCHIVE" | cut -d' ' -f1)" = "$EXPECTED" ] || die "Prüfsumme stimmt nicht"

# --- Benutzer, Verzeichnisse, Release ----------------------------------------------------------------------------
id wws >/dev/null 2>&1 || useradd --system --home-dir /srv/wws --shell /usr/sbin/nologin wws
install -d -m 755 /srv/wws "$ROOT" "$ROOT/releases"
install -d -o wws -g wws -m 700 "$ROOT/data"
RELEASE="$ROOT/releases/$VERSION"
rm -rf "$RELEASE.neu"
install -d -m 755 "$RELEASE.neu"
tar -xzf "$ARCHIVE" --no-same-owner -C "$RELEASE.neu"
[ -x "$RELEASE.neu/erp" ] || die "Archiv ohne erp"
rm -rf "$RELEASE"
mv "$RELEASE.neu" "$RELEASE"

install -m 644 "$RELEASE/deploy/wws@.service" /etc/systemd/system/wws@.service
for unit in "$RELEASE"/deploy/wws-bridge*@.service; do
  [ -f "$unit" ] && install -m 644 "$unit" /etc/systemd/system/
done
if [ -f "$RELEASE/deploy/journald-wws.conf" ]; then
  install -d /etc/systemd/journald.conf.d
  install -m 644 "$RELEASE/deploy/journald-wws.conf" /etc/systemd/journald.conf.d/wws.conf
fi
systemctl daemon-reload
# Ablage der Bridge-Umgebung (ADR-077): Die Datei kommt aus dem Kanal-Assistenten, sobald es einen Mandanten gibt.
install -d -m 750 -o root -g wws /srv/wws/bridges

# --- Erster Lauf: Umgebung und Administrator ---------------------------------------------------------------------
FIRST=""
PASSWORD=""
if [ ! -f "$ROOT/env" ]; then
  FIRST=1
  ask WWS_URL "Öffentliche Adresse (https://…)"
  ask WWS_ADMIN_EMAIL "E-Mail des ersten Administrators"
  ask WWS_S3_ENDPOINT "S3-Endpunkt (https://…)"
  ask WWS_S3_BUCKET "S3-Bucket"
  ask WWS_S3_REGION "S3-Region" auto
  ask WWS_S3_ACCESS_KEY_ID "S3-Zugriffsschlüssel"
  ask WWS_S3_SECRET_ACCESS_KEY "S3-Geheimnis"
  WWS_URL="${WWS_URL%/}"
  case "$WWS_URL" in https://* | http://localhost* | http://127.0.0.1*) ;; *) die "WWS_URL muss mit https:// beginnen" ;; esac
  umask 077
  cat > "$ROOT/env" <<EOF
# WWS $INSTANCE, angelegt von install.sh am $(date -u +%Y-%m-%d). Handbuch: $WWS_URL/handbuch/betrieb/
ERP_ENV=production
ERP_PUBLIC_URL=$WWS_URL
# Eingebauter Anmeldedienst (Aussteller = eigene Adresse)
ERP_OIDC_ISSUER=$WWS_URL
ERP_SECRET_KEY=$(openssl rand -hex 32)
ERP_AGENT_TOKEN_KEY=$(openssl rand -hex 32)
ERP_BIND=127.0.0.1:$PORT
ERP_DATA_DIR=$ROOT/data
ERP_WEB_DIR=$ROOT/current/web
ERP_BACKUP_DIR=$ROOT/data/backup
ERP_REGISTRATION=off
# Metriken und API-Doku nur lokal
ERP_OPS_BIND=127.0.0.1:$((PORT + 1))
ERP_S3_ENDPOINT=$WWS_S3_ENDPOINT
ERP_S3_BUCKET=$WWS_S3_BUCKET
ERP_S3_REGION=$WWS_S3_REGION
ERP_S3_ACCESS_KEY_ID=$WWS_S3_ACCESS_KEY_ID
ERP_S3_SECRET_ACCESS_KEY=$WWS_S3_SECRET_ACCESS_KEY
# Tagesbericht an den Hersteller (Version, Zustand, Vorgänge und Speicher je Mandant, keine Geschäftsdaten), ADR-076;
# abschalten mit ERP_REPORT=off. Lizenzdatei: <daten>/lizenz.json (erp license install <datei>)
# Mailversand des Betriebs (Passwort vergessen, Einladungen), siehe Handbuch „Mailversand“
# ERP_SMTP_HOST=
EOF
  chown root:wws "$ROOT/env"
  chmod 640 "$ROOT/env"
  umask 022
fi

# Migrationsstand mit dem neuen Release lesen (Dienst gestoppt; Turso sperrt die Dateien)
migration_state() {
  (cd "$ROOT" && runuser -u wws -- env ERP_DATA_DIR="$ROOT/data" RUST_LOG=error "$RELEASE/erp" db migration-state)
}
PREVIOUS="$(readlink "$ROOT/current" || true)"
BEFORE=""
if [ -n "$PREVIOUS" ]; then
  [ "$PREVIOUS" = "$RELEASE" ] && say "Version $VERSION ist bereits installiert, starte neu"
  systemctl stop "wws@$INSTANCE" || true
  BEFORE="$(migration_state || true)"
fi
ln -sfn "$RELEASE" "$ROOT/current"

if [ -n "$FIRST" ]; then
  say "Lege Administrator $WWS_ADMIN_EMAIL an"
  PASSWORD="$(openssl rand -base64 24 | tr -d '/+=' | cut -c1-20)"
  # Umgebung im Kindprozess laden statt auf der Kommandozeile (Geheimnisse nicht in der Prozessliste)
  printf '%s\n' "$PASSWORD" | (cd "$ROOT" && runuser -u wws -- bash -c 'set -a; . "$1"; set +a; exec "$2" user add --email "$3" --admin' \
    _ "$ROOT/env" "$RELEASE/erp" "$WWS_ADMIN_EMAIL" >/dev/null)
fi

# --- Optional: Lizenzdatei (ADR-076; ohne Datei läuft WWS unverändert, mit Hinweis unter Nutzung) ------------------
if [ -n "${WWS_LICENSE_FILE:-}" ]; then
  [ -f "$WWS_LICENSE_FILE" ] || die "$WWS_LICENSE_FILE fehlt"
  (cd "$ROOT" && runuser -u wws -- env ERP_DATA_DIR="$ROOT/data" RUST_LOG=error "$RELEASE/erp" license install /dev/stdin) \
    < "$WWS_LICENSE_FILE" >/dev/null || die "Lizenzdatei ungültig"
  say "Lizenz übernommen"
fi

# --- Optional: Cloudflare-Tunnel ---------------------------------------------------------------------------------
# Eingang ohne offene Ports. Hinter dem Tunnel kommt jede Anfrage von Loopback; die Anmeldesperren lesen dann
# CF-Connecting-IP (ERP_TRUSTED_PROXIES, Vorgabe Loopback). Erneuter Lauf mit gleichem Token ändert nichts.
TUNNEL=""
if [ -n "${WWS_TUNNEL_TOKEN:-}" ]; then
  TUNNEL=1
  UNIT=/etc/systemd/system/cloudflared.service
  if ! command -v cloudflared >/dev/null; then
    command -v apt-get >/dev/null || die "cloudflared fehlt; ohne apt bitte nach Handbuch „Cloudflare-Tunnel“ installieren"
    say "Installiere cloudflared"
    CODENAME="$(. /etc/os-release && echo "${VERSION_CODENAME:-}")"
    [ -n "$CODENAME" ] || die "Distribution ohne VERSION_CODENAME; cloudflared bitte von Hand installieren"
    install -d -m 755 /usr/share/keyrings
    curl -fsSL https://pkg.cloudflare.com/cloudflare-main.gpg -o /usr/share/keyrings/cloudflare-main.gpg
    echo "deb [signed-by=/usr/share/keyrings/cloudflare-main.gpg] https://pkg.cloudflare.com/cloudflared $CODENAME main" \
      > /etc/apt/sources.list.d/cloudflared.list
    apt-get update -qq
    DEBIAN_FRONTEND=noninteractive apt-get install -y -qq cloudflared >/dev/null
  fi
  if [ -f "$UNIT" ] && grep -qF -- "$WWS_TUNNEL_TOKEN" "$UNIT"; then
    systemctl is-active --quiet cloudflared || systemctl start cloudflared
  else
    [ -f "$UNIT" ] && { say "Ersetze bestehenden Tunnel"; cloudflared service uninstall >/dev/null 2>&1 || true; }
    say "Richte Cloudflare-Tunnel ein"
    cloudflared service install "$WWS_TUNNEL_TOKEN" >/dev/null 2>&1 || die "cloudflared service install fehlgeschlagen (Token prüfen)"
  fi
  chmod 600 "$UNIT" 2>/dev/null || true # die Unit enthält das Token
fi

# --- Starten und prüfen ------------------------------------------------------------------------------------------
say "Starte wws@$INSTANCE"
systemctl enable --quiet "wws@$INSTANCE"
systemctl restart "wws@$INSTANCE"
RESTARTS="$(systemctl show -p NRestarts --value "wws@$INSTANCE")"
for _ in $(seq 1 1800); do
  if curl -fsS -m 2 "http://127.0.0.1:$PORT/health" >/dev/null 2>&1; then
    # Die letzten fünf Stände behalten, den aktiven und den vorherigen immer
    ls -1t "$ROOT/releases" | tail -n +6 | while read -r old; do
      [ "$ROOT/releases/$old" = "$PREVIOUS" ] || [ "$old" = "$VERSION" ] || rm -rf "${ROOT:?}/releases/$old"
    done
    URL="$(sed -n 's/^ERP_PUBLIC_URL=//p' "$ROOT/env")"
    say "WWS $VERSION läuft"
    # Bridge mit dem neuen Programm, sofern eingerichtet (Umgebung aus dem Kanal-Assistenten)
    if [ -f "/srv/wws/bridges/$INSTANCE.env" ]; then
      systemctl enable --quiet "wws-bridge@$INSTANCE" && systemctl restart "wws-bridge@$INSTANCE" \
        && say "Bridge wws-bridge@$INSTANCE neu gestartet"
    fi
    if [ -n "$FIRST" ]; then
      cat <<EOF

  Adresse:        $URL
  Anmeldung:      $WWS_ADMIN_EMAIL
  Passwort:       $PASSWORD   (nach der ersten Anmeldung ändern)
  Umgebung:       $ROOT/env
  Handbuch:       $URL/handbuch/

  Shops und Marktplätze: unter „Kanäle“ führt ein Assistent durch die Anbindung; die Datei für die Bridge
  kommt nach /srv/wws/bridges/$INSTANCE.env, Start mit: systemctl enable --now wws-bridge@$INSTANCE
EOF
    fi
    if [ -n "$FIRST" ] && [ -n "$TUNNEL" ]; then
      cat <<EOF

  Tunnel läuft. Im Cloudflare-Dashboard den öffentlichen Hostnamen ${URL#https://} auf
  http://127.0.0.1:$PORT zeigen lassen.
EOF
    elif [ -n "$FIRST" ]; then
      cat <<EOF

  Reverse Proxy mit TLS auf 127.0.0.1:$PORT, z. B. Caddy (/etc/caddy/Caddyfile):
    ${URL#https://} {
      reverse_proxy 127.0.0.1:$PORT
    }
EOF
    fi
    exit 0
  fi
  if [ "$(systemctl show -p NRestarts --value "wws@$INSTANCE")" != "$RESTARTS" ] || systemctl is-failed --quiet "wws@$INSTANCE"; then
    break
  fi
  sleep 1
done

journalctl -u "wws@$INSTANCE" -n 30 --no-pager >&2 || true
if [ -z "$PREVIOUS" ] || [ "$PREVIOUS" = "$RELEASE" ]; then
  systemctl stop "wws@$INSTANCE" || true
  die "WWS $VERSION startet nicht (siehe Protokoll oben)"
fi
systemctl stop "wws@$INSTANCE" || true
if [ -n "$BEFORE" ] && [ "$(migration_state || true)" = "$BEFORE" ]; then
  ln -sfn "$PREVIOUS" "$ROOT/current"
  systemctl start "wws@$INSTANCE"
  die "WWS $VERSION startet nicht; zurück auf $(basename "$PREVIOUS") (keine Migration angewandt)"
fi
systemctl start "wws@$INSTANCE" || true
die "WWS $VERSION startet nicht und hat Migrationen angewandt; kein Rückfall möglich, bitte Support kontaktieren"
