#!/usr/bin/env bash
# Fractured / AzerothCore — native VPS rolling update (git + compile).
#
# Run from anywhere; resolves the repository root from this script's location.
# Typical production layout: sources in ~/src/Fractured, install prefix in ~/azeroth-server
# (see docs/DEPLOY_LINUX_VPS.md).
#
# What this does:
#   1. Optionally kill running servers (tmux sessions)
#   2. git pull on the current branch (optional; can skip)
#   3. ./acore.sh compiler build  — or  compiler all  for a full clean rebuild
#   4. Optionally restart servers in tmux sessions
#
# Database migrations from data/sql/updates/ run when you next start worldserver/authserver
# (Updates.* / SourceDirectory in *.conf).
#
# Usage:
#   bash scripts/vps-update-server.sh                      # pull + compile only
#   bash scripts/vps-update-server.sh --restart             # pull + compile + restart servers in tmux
#   bash scripts/vps-update-server.sh --full --restart      # clean rebuild + restart
#   bash scripts/vps-update-server.sh --no-pull --restart   # compile current tree + restart
#   bash scripts/vps-update-server.sh --dry-run
#   bash scripts/vps-update-server.sh --run-after 'custom command here'
#
# Environment:
#   FRACTURED_GIT_REMOTE        — remote name (default: origin)
#   FRACTURED_POST_UPDATE_CMD   — shell command run after compile (used by bare --run-after)

set -euo pipefail

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"

NO_PULL=0
FULL_BUILD=0
COMPILE_ONLY=0
DRY_RUN=0
DO_RUN_AFTER=0
DO_RESTART=0
INSTALL_PREFIX=""
POST_UPDATE_CMD="${FRACTURED_POST_UPDATE_CMD:-}"
GIT_REMOTE="${FRACTURED_GIT_REMOTE:-origin}"

usage() {
  cat <<'EOF'
Fractured VPS update — git pull + compiler (see header in script for full notes).

Usage:
  bash scripts/vps-update-server.sh [options]

Options:
  --no-pull       Skip git pull (only compile current tree).
  --full          ./acore.sh compiler all (clean + configure + compile).
  --compile-only  ./acore.sh compiler compile (incremental).
  --prefix PATH   Override CMAKE_INSTALL_PREFIX (updates conf/config.sh BINPATH).
  --dry-run       Print commands without running them.
  --restart       Kill servers before compile, restart in tmux after.
  --run-after [CMD]  Run a custom shell command after successful compile.
                  If CMD is omitted, uses FRACTURED_POST_UPDATE_CMD.

Environment:
  FRACTURED_GIT_REMOTE         Git remote (default: origin).
  FRACTURED_POST_UPDATE_CMD    Used with bare --run-after.
EOF
}

run() {
  if [[ "$DRY_RUN" -eq 1 ]]; then
    printf '[dry-run] '
    printf '%q ' "$@"
    printf '\n'
  else
    "$@"
  fi
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    -h | --help)
      usage
      exit 0
      ;;
    --no-pull)
      NO_PULL=1
      shift
      ;;
    --full)
      FULL_BUILD=1
      shift
      ;;
    --compile-only)
      COMPILE_ONLY=1
      shift
      ;;
    --prefix)
      shift
      if [[ $# -eq 0 || "$1" == -* ]]; then
        echo "error: --prefix requires a path argument" >&2
        exit 2
      fi
      INSTALL_PREFIX="$1"
      shift
      ;;
    --dry-run)
      DRY_RUN=1
      shift
      ;;
    --restart)
      DO_RESTART=1
      shift
      ;;
    --run-after)
      DO_RUN_AFTER=1
      shift
      if [[ $# -gt 0 && "$1" != -* ]]; then
        POST_UPDATE_CMD="$1"
        shift
      fi
      ;;
    *)
      echo "error: unknown option: $1" >&2
      echo "Try: bash scripts/vps-update-server.sh --help" >&2
      exit 2
      ;;
  esac
done

if [[ "$FULL_BUILD" -eq 1 && "$COMPILE_ONLY" -eq 1 ]]; then
  echo "error: use only one of --full or --compile-only" >&2
  exit 2
fi

if [[ ! -d "$ROOT/.git" ]]; then
  echo "error: not a git clone: $ROOT" >&2
  exit 1
fi

if [[ ! -f "$ROOT/acore.sh" ]]; then
  echo "error: acore.sh not found under $ROOT" >&2
  exit 1
fi

if [[ ! -f "$ROOT/conf/config.sh" ]]; then
  echo "error: missing $ROOT/conf/config.sh — copy conf/dist/config.sh and edit (see DEPLOY_LINUX_VPS.md)." >&2
  exit 1
fi

cd "$ROOT"

KILL_SCRIPT="${SCRIPT_DIR}/kill-azeroth-servers.sh"
START_SCRIPT="${SCRIPT_DIR}/start-azeroth-servers.sh"

if [[ "$DO_RESTART" -eq 1 ]]; then
  if [[ ! -f "$KILL_SCRIPT" || ! -f "$START_SCRIPT" ]]; then
    echo "error: --restart requires kill-azeroth-servers.sh and start-azeroth-servers.sh in scripts/" >&2
    exit 1
  fi
  echo "==> stopping servers before compile"
  run bash "$KILL_SCRIPT"
fi

if [[ -n "$INSTALL_PREFIX" ]]; then
  echo "==> updating conf/config.sh BINPATH to: $INSTALL_PREFIX"
  if grep -q '^BINPATH=' conf/config.sh; then
    run sed -i "s|^BINPATH=.*|BINPATH=\"$INSTALL_PREFIX\"|" conf/config.sh
  else
    echo "BINPATH=\"$INSTALL_PREFIX\"" >> conf/config.sh
  fi
  export BINPATH="$INSTALL_PREFIX"
fi

if [[ "$DO_RUN_AFTER" -eq 1 && -z "${POST_UPDATE_CMD// }" ]]; then
  echo "error: --run-after needs a command or FRACTURED_POST_UPDATE_CMD set in the environment." >&2
  exit 2
fi

current_branch() {
  git symbolic-ref -q --short HEAD || git rev-parse --short HEAD
}

if [[ "$NO_PULL" -eq 0 ]]; then
  ref="$(current_branch)"
  if [[ "$ref" == "HEAD" ]]; then
    echo "error: detached HEAD; checkout a branch or use --no-pull." >&2
    exit 1
  fi
  echo "==> git pull $GIT_REMOTE $ref"
  run git pull "$GIT_REMOTE" "$ref"
else
  echo "==> skipping git pull (--no-pull)"
fi

echo "==> ensuring acore.sh and JSONPath are executable"
if [[ "$DRY_RUN" -eq 1 ]]; then
  run chmod +x acore.sh deps/jsonpath/JSONPath.sh
else
  chmod +x acore.sh deps/jsonpath/JSONPath.sh 2>/dev/null || true
fi

if [[ "$FULL_BUILD" -eq 1 ]]; then
  echo "==> ./acore.sh compiler all  (clean, configure, compile)"
  run ./acore.sh compiler all
elif [[ "$COMPILE_ONLY" -eq 1 ]]; then
  echo "==> ./acore.sh compiler compile  (incremental; build dir must exist)"
  run ./acore.sh compiler compile
else
  echo "==> ./acore.sh compiler build  (configure + compile)"
  run ./acore.sh compiler build
fi

if [[ "$DO_RESTART" -eq 1 ]]; then
  echo "==> restarting servers in tmux sessions"
  run bash "$START_SCRIPT"
fi

if [[ "$DO_RUN_AFTER" -eq 1 ]]; then
  echo "==> post-update: $POST_UPDATE_CMD"
  if [[ "$DRY_RUN" -eq 1 ]]; then
    printf '[dry-run] eval %q\n' "$POST_UPDATE_CMD"
  else
    # shellcheck disable=SC2086
    eval "$POST_UPDATE_CMD"
  fi
fi

if [[ "$DO_RESTART" -eq 0 && "$DO_RUN_AFTER" -eq 0 ]]; then
  echo "Done. Run 'bash scripts/start-azeroth-servers.sh' to (re)start servers in tmux."
else
  echo "Done."
fi