#!/bin/bash
# The Linux runtime's session. Bannerlator execs this under proot with the output size and mode;
# the first pass starts gamescope, which execs this script again inside it for the program:
#   bannerlator-session desktop            the file manager
#   bannerlator-session run <path>         a Linux program (AppImage, script or ELF)
#   bannerlator-session steam [steam-url]  the native Steam client
# BL_WIDTH / BL_HEIGHT size the output, BL_FPS limits it, BL_LOG collects everything said here.
set -u
export HOME=${HOME:-/root}
mode=${1:-desktop}
shift || true
# One line per milestone, greppable as "== STEP", so a first run reads as a narrative rather than
# something to be reconstructed from Steam's own chatter. The app shows these while it waits.
step() { echo "== STEP $(date -u +%H:%M:%S) $*"; }
if [ -n "${BL_LOG:-}" ] && [ -z "${BL_INSIDE:-}" ]; then
  mkdir -p "$(dirname "$BL_LOG")" 2>/dev/null
  # The client alone writes megabytes an hour; one earlier log is kept, not every session's.
  if [ "$(stat -c %s "$BL_LOG" 2>/dev/null || echo 0)" -gt 8388608 ]; then
    mv -f "$BL_LOG" "$BL_LOG.1"
  fi
  exec >>"$BL_LOG" 2>&1
  echo "== bannerlator-session $(date) mode=$mode $*"
  echo "== uid=$(id -u) size=${BL_WIDTH:-?}x${BL_HEIGHT:-?} fps=${BL_FPS:-0} icd=${VK_ICD_FILENAMES:-none}"
  echo "== gamescope: $(gamescope --version 2>&1 | head -1)"
  echo "== rootfs: $(cat /.version 2>/dev/null || echo unversioned)"
fi

# Until the runtime is stable, Steam's own logs are copied beside the session log at exit so a
# failed launch can be handed over as one folder.
collect_steam_logs() {
  [ -n "${BL_DEBUG_DIR:-}" ] || return 0
  local steam_root=${XDG_DATA_HOME:-$HOME/.local/share}/Steam
  mkdir -p "$BL_DEBUG_DIR" 2>/dev/null || return 0
  [ -d "$steam_root/logs" ] && cp -r "$steam_root/logs" "$BL_DEBUG_DIR/steam-logs" 2>/dev/null
  [ -f "$HOME/.steam/steam/logs/steamwebhelper.log" ] && cp "$HOME/.steam/steam/logs/steamwebhelper.log" "$BL_DEBUG_DIR/" 2>/dev/null
  [ -f "$steam_root/steam.pid" ] && cp "$steam_root/steam.pid" "$BL_DEBUG_DIR/" 2>/dev/null
  echo "== steam logs copied to $BL_DEBUG_DIR"
}
export XDG_DATA_HOME=${XDG_DATA_HOME:-$HOME/.local/share}
export XDG_CONFIG_HOME=${XDG_CONFIG_HOME:-$HOME/.config}
export XDG_CACHE_HOME=${XDG_CACHE_HOME:-$HOME/.cache}
mkdir -p "$XDG_DATA_HOME" "$XDG_CONFIG_HOME" "$XDG_CACHE_HOME"

if [ -z "${BL_INSIDE:-}" ]; then
  # The compositor may still be starting, and a socket left by an earlier session is not
  # a compositor: probe until a connection succeeds.
  for _ in $(seq 1 100); do
    wayland-info >/dev/null 2>&1 && break
    sleep 0.1
  done
  width=${BL_WIDTH:-1280}
  height=${BL_HEIGHT:-720}
  args=(--backend wayland --expose-wayland -f -W "$width" -H "$height" -w "$width" -h "$height")
  # -r is what gamescope advertises as the refresh rate, and what a game reads as the display's.
  # Left unset it defaults to 60, so a 120 Hz panel offers only 60 Hz in game settings. The FPS
  # limiter wins when it is on (it is a deliberate cap); otherwise use the panel's own rate.
  if [ "${BL_FPS:-0}" -gt 0 ]; then
    args+=(-r "$BL_FPS")
  elif [ "${BL_REFRESH:-0}" -gt 0 ]; then
    args+=(-r "$BL_REFRESH")
  fi
  [ "$mode" = steam ] && args+=(-e)
  export BL_INSIDE=1
  exec gamescope "${args[@]}" -- "$0" "$mode" "$@"
fi

# gamescope manages X windows: toolkits go through Xwayland, not gamescope's own Wayland socket.
export GDK_BACKEND=x11 QT_QPA_PLATFORM=xcb SDL_VIDEODRIVER=x11
# gamescope's reaper waits for every process left under it before the compositor comes down. A
# process a game left behind - a Wine service blocked on a server that is already gone - is
# reparented there when the client exits, and the screen stays black on it for good. Nothing of
# the session outlives the program it was started for.
reap_orphans() {
  local round p stat pid left
  for round in 1 2 3 4 5; do
    left=
    for p in /proc/[0-9]*; do
      pid=${p#/proc/}
      [ "$pid" = "$$" ] && continue
      stat=$(cat "$p/stat" 2>/dev/null) || continue
      stat=${stat##*) }
      set -- $stat
      [ "${2:-}" = "$PPID" ] && left="$left $pid"
    done
    [ -n "$left" ] || return 0
    echo "== leaving behind:$left"
    kill -9 $left 2>/dev/null
    sleep 0.2
  done
}

case $mode in
  desktop)
    exec pcmanfm
    ;;
  run)
    target=${1:?program path}
    shift
    case ${target,,} in
      *.appimage)
        export APPIMAGE_EXTRACT_AND_RUN=1
        chmod +x "$target" 2>/dev/null
        exec "$target" "$@"
        ;;
      *.sh)
        exec bash "$target" "$@"
        ;;
      *)
        chmod +x "$target" 2>/dev/null
        cd "$(dirname "$target")" && exec "$target" "$@"
        ;;
    esac
    ;;
  steam)
    step "checking the Steam client (first run downloads it, ~1-2 min with nothing on screen)"
    bannerlator-steam-install || exit $?
    step "Steam client ready"
    steam_root=$XDG_DATA_HOME/Steam
    # Register the card library (bound at /mnt/bannerlator-sd) with the client - internal storage is
    # its main library already - and the ARM64 Proton that lets it launch the Windows ones.
    step "registering the app's game library with Steam"
    bannerlator-steam-library "$steam_root" || true
    step "setting up the ARM64 Proton compatibility tool"
    bannerlator-steam-compat "$steam_root" || true
    # Steam runs a game's shared redistributables inside its prefix on first launch; marking
    # them as already run keeps those x86 installers from starting under emulation at all.
    bannerlator-seed-redists "$steam_root" || true
    # The compatibility tool runs Valve's arm64 Proton, which the client fetches like any depot.
    # Asked for on the command line the first time, so a Windows title has it before it is needed.
    if [ ! -f "$steam_root/steamapps/appmanifest_4427310.acf" ]; then
      step "asking the client to fetch the ARM64 Proton"
      set -- "$@" steam://install/4427310
    fi
    # The tool is registered before the client starts and finds the depot at launch time, so
    # nothing here waits for a download. What can still change under a running client is which
    # titles are installed: a title installed this session gets the client's own per-app Proton
    # choice, which it cannot start. Refresh the per-app entries every so often; the registrar is
    # idempotent, so a repeat costs nothing.
    (
      for _ in $(seq 1 240); do
        sleep 15
        bannerlator-steam-compat "$steam_root" >/dev/null 2>&1 || true
      done
    ) &
    # Debug aid while the runtime is being brought up: an app id dropped in ~/.bl-autolaunch is
    # handed to the client as a rungameid URL, so a launch can be reproduced without touching the
    # screen. Removed once the runtime is stable.
    if [ -s "$HOME/.bl-autolaunch" ]; then
      _bl_app=$(cat "$HOME/.bl-autolaunch")
      # A bare app id runs the game; a full steam:// URL is passed through, which is how a
      # validate or an install is driven without touching the screen.
      case $_bl_app in
        steam://*) _bl_url=$_bl_app ;;
        *) _bl_url=steam://rungameid/$_bl_app ;;
      esac
      echo "== autolaunch $_bl_url"
      set -- "$@" "$_bl_url"
    fi
    export STEAM_RUNTIME=1
    export LD_LIBRARY_PATH=$steam_root/steamrtarm64:$steam_root/steamrtarm64/panorama${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}
    export SDL_VIDEO_X11_DGAMOUSE=0
    # Native-Linux x86 games go through Valve's FEX compat tool, which runs FEX with FEX_PORTABLE=1
    # - that makes FEX look for its config next to the binary, while the tool writes one into the
    # app's compatdata instead. FEX therefore starts with no rootfs, every x86_64 library lookup
    # falls through to the host, and the guest shell dies on libreadline before the game is reached.
    # FEX_ROOTFS names it outright and is read whatever the config situation.
    [ -d /usr/share/guestos/fex-mesa ] && export FEX_ROOTFS=/usr/share/guestos/fex-mesa
    # The client exits 42 when it has updated itself and wants a fresh start (steam.sh does this).
    while :; do
      step "starting the Steam client"
      "$steam_root/steamrtarm64/steam" -gamepadui -clientbeta publicbeta \
        -no-cef-sandbox -cef-force-gpu -cef-ozone-platform=x11 \
        -cef-use-gl=angle -cef-use-angle=vulkan "$@"
      rc=$?
      echo "== steam exited rc=$rc"
      collect_steam_logs
      [ "$rc" -eq 42 ] || break
    done
    reap_orphans
    exit "$rc"
    ;;
  *)
    echo "bannerlator-session: unknown mode '$mode'" >&2
    exit 64
    ;;
esac
