#!/usr/bin/env bash
# Bouwt BlueGit uit de lokale bare repo en installeert dat pakket.
# Draait als root via bluegit-update.service. De bouw zelf doet bluegit-build.
# Bij een fout blijft het geïnstalleerde pakket staan. Journal houdt de uitvoer.
set -euo pipefail

: "${BLUEGIT_STATE_DIR:=/var/lib/bluegit}"
: "${BLUEGIT_UPDATE_URL:=http://127.0.0.1:8080}"
: "${BLUEGIT_BUILD_USER:=bluegit-build}"
: "${BLUEGIT_UPDATE_POLL:=2}"
: "${BLUEGIT_UPDATE_TIMEOUT:=1800}"

REQUEST="${BLUEGIT_STATE_DIR}/update-request"
STATUS="${BLUEGIT_STATE_DIR}/update-status.json"
LOG="${BLUEGIT_STATE_DIR}/update.log"
sha=""

valid_ref() {
  local ref="$1"
  if [[ -z "$ref" ]]; then
    return 0
  fi
  [[ "$ref" != *..* && "$ref" != *'@{'* ]] || return 1
  [[ "$ref" =~ ^[0-9A-Za-z][0-9A-Za-z._/-]{0,199}$ ]]
}

# git_repo DIR ARGS...
# De bare repo kan van een andere uid zijn. Git weigert die ook voor root.
git_repo() {
  local repo="$1"
  shift
  git -c safe.directory="$repo" -c "safe.directory=*" -C "$repo" "$@"
}

# Zelfde tijdstempel als scripts/aur-publish-local.sh: UTC-committertijd.
# Een falende git mag de stempel niet leeg laten: set -e stopt niet
# op een command substitution zonder ||.
pkgver_of() {
  local repo="$1" commit="$2" version
  version="$(TZ=UTC git_repo "$repo" show -s --date=format-local:%Y%m%d%H%M%S --format=%cd "$commit")" || return 1
  printf '%s\n' "$version"
}

resolve_sha() {
  local repo="$1" ref="$2"
  if [[ -z "$ref" ]]; then
    ref="HEAD"
  fi
  git_repo "$repo" rev-parse --verify "${ref}^{commit}"
}

# Leegt het log en stuurt stdout en stderr erheen én naar het journal.
# De bluegit-user leest dit bestand via GET; het journal niet.
open_log() {
  mkdir -p "$BLUEGIT_STATE_DIR"
  : > "$LOG"
  chmod 644 "$LOG"
  exec > >(tee -a "$LOG") 2>&1
}

write_status() {
  local result="$1" commit="$2" err="${3:-}"
  local now tmp
  now="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  err="${err//$'\n'/ }"
  err="${err//\"/}"
  mkdir -p "$BLUEGIT_STATE_DIR"
  tmp="$(mktemp "${BLUEGIT_STATE_DIR}/.update-status.XXXXXX")"
  printf '{"time":"%s","sha":"%s","result":"%s","error":"%s"}\n' "$now" "$commit" "$result" "$err" > "$tmp"
  chmod 644 "$tmp"
  mv -f "$tmp" "$STATUS"
}

# running komt uit de API. Elke job met status running telt mee.
wait_until_idle() {
  local deadline body n poll
  poll="$BLUEGIT_UPDATE_POLL"
  deadline=$((SECONDS + BLUEGIT_UPDATE_TIMEOUT))
  while (( SECONDS < deadline )); do
    body="$(curl -fsS -H "Authorization: Bearer ${BLUEGIT_UPDATE_TOKEN}" "${BLUEGIT_UPDATE_URL}/api/v1/admin/self-update" || true)"
    n="$(printf '%s' "$body" | sed -n 's/.*"running":[[:space:]]*\([0-9][0-9]*\).*/\1/p' | head -n 1)"
    if [[ "$n" == "0" ]]; then
      return 0
    fi
    # Een beheerder heeft geforceerd: niet langer wachten.
    if printf '%s' "$body" | grep -q '"force":[[:space:]]*true'; then
      echo "Geforceerd: installeren ondanks ${n} lopende jobs."
      return 0
    fi
    echo "Steve heeft nog ${n:-onbekend} lopende jobs."
    sleep "$poll"
  done
  echo "Timeout: Steve heeft nog lopende jobs." >&2
  return 1
}

prepare_build() {
  local repo="$1" commit="$2" dest="$3" version sum
  version="$(pkgver_of "$repo" "$commit")" || return 1
  [[ "$version" =~ ^[0-9]{14}$ ]] || { echo "pkgver is geen tijdstempel: $version" >&2; return 1; }
  mkdir -p "$dest"
  git_repo "$repo" archive --format=tar.gz --prefix="bluegit-${commit}/" -o "$dest/bluegit-${commit}.tar.gz" "$commit"
  git_repo "$repo" show "${commit}:packaging/aur/PKGBUILD" > "$dest/PKGBUILD"
  git_repo "$repo" show "${commit}:packaging/aur/bluegit.install" > "$dest/bluegit.install"
  sum="$(sha256sum "$dest/bluegit-${commit}.tar.gz" | awk '{print $1}')"
  sed -i "s/^pkgver=.*/pkgver=${version}/" "$dest/PKGBUILD"
  sed -i "s/^pkgrel=.*/pkgrel=1/" "$dest/PKGBUILD"
  sed -i "s/^_commit=.*/_commit=${commit}/" "$dest/PKGBUILD"
  sed -i "s|^sha256sums=.*|sha256sums=('${sum}')|" "$dest/PKGBUILD"
  sed -i "s|^source=.*|source=('bluegit-${commit}.tar.gz')|" "$dest/PKGBUILD"
  printf '%s\n' "$version"
}

# runuser houdt de cwd van de unit. Die is /, dus makepkg meldt
# "PKGBUILD does not exist" tenzij we eerst naar de werkmap gaan.
# sysusers zet de homedir alleen in passwd. Zolang tmpfiles die map niet
# heeft aangemaakt, mag go daar geen cache schrijven.
build_package() {
  local work="$1"
  cd "$work"
  runuser -u "$BLUEGIT_BUILD_USER" -- env \
    HOME="/var/lib/${BLUEGIT_BUILD_USER}" \
    GOCACHE="$work/gocache" \
    GOPATH="$work/gopath" \
    BUILDDIR="$work/build" \
    SRCDEST="$work" \
    PKGDEST="$work/pkg" \
    makepkg --noconfirm --nosign
}

main() {
  local ref repo work version built
  : "${BLUEGIT_UPDATE_TOKEN:?BLUEGIT_UPDATE_TOKEN ontbreekt}"
  : "${BLUEGIT_UPDATE_REPO:?BLUEGIT_UPDATE_REPO ontbreekt}"
  repo="$BLUEGIT_UPDATE_REPO"
  [[ -d "$repo" ]] || { echo "Bare repo niet gevonden: $repo" >&2; exit 1; }
  command -v git >/dev/null
  command -v curl >/dev/null
  command -v makepkg >/dev/null
  command -v pacman >/dev/null
  command -v runuser >/dev/null
  id "$BLUEGIT_BUILD_USER" >/dev/null 2>&1 || { echo "Bouwgebruiker $BLUEGIT_BUILD_USER ontbreekt." >&2; exit 1; }

  mkdir -p "$BLUEGIT_STATE_DIR"
  exec 9>"${BLUEGIT_STATE_DIR}/update.lock"
  if ! flock -n 9; then
    echo "Er loopt al een self-update." >&2
    exit 1
  fi
  open_log
  trap on_exit EXIT

  ref=""
  if [[ -f "$REQUEST" ]]; then
    ref="$(tr -d '[:space:]' < "$REQUEST")"
  fi
  valid_ref "$ref" || { echo "Ongeldige ref." >&2; exit 1; }
  sha="$(resolve_sha "$repo" "$ref")" || exit 1
  echo "Self-update naar $sha"
  write_status running "$sha" ""

  if ! wait_until_idle; then
    write_status failed "$sha" "jobs still running"
    exit 1
  fi

  work="$(mktemp -d /var/tmp/bluegit-update.XXXXXX)"
  chmod 755 "$work"
  version="$(prepare_build "$repo" "$sha" "$work")" || { write_status failed "$sha" "prepare"; exit 1; }
  echo "pkgver $version"
  mkdir -p "$work/pkg"
  chown -R "$BLUEGIT_BUILD_USER:$BLUEGIT_BUILD_USER" "$work"
  build_package "$work"
  chown -R root:root "$work/pkg"

  if ! wait_until_idle; then
    write_status failed "$sha" "jobs still running"
    exit 1
  fi

  shopt -s nullglob
  built=("$work"/pkg/bluegit-*.pkg.tar.*)
  shopt -u nullglob
  if [[ ${#built[@]} -ne 1 ]]; then
    echo "Geen uniek pakket in $work/pkg" >&2
    write_status failed "$sha" "package missing"
    exit 1
  fi
  pacman -U --noconfirm "${built[0]}"
  write_status ok "$sha" ""
  trap - EXIT
  rm -rf "$work" || true
  work=""
  echo "Self-update geïnstalleerd: $sha ($version)"
}

on_exit() {
  local rc=$?
  if [[ "$rc" -ne 0 ]]; then
    write_status failed "${sha:-}" "exit ${rc}" || true
  fi
  if [[ -n "${work:-}" && -d "${work:-}" ]]; then
    rm -rf "$work" || true
  fi
  exit "$rc"
}

if [[ "${BASH_SOURCE[0]}" == "$0" ]]; then
  main "$@"
fi
