#!/usr/bin/env bash
set -euo pipefail

REPO_ID="umer07/vllm-deployement-backup"
WORKDIR="${PWD}"
DOWNLOAD_LATEST=0
START_SERVICES=0
HF_TOKEN="${HF_TOKEN:-}"

usage() {
  cat <<'EOF'
Usage:
  restore_fathom_vm.sh [--download-latest] [--start] [--workdir DIR] [--repo-id ID] [--hf-token TOKEN]

What it does:
  1. Finds the latest matching backup set
  2. Extracts the application archive at /
  3. Recreates and restores Docker volumes
  4. Optionally starts /root/serve.py and docker compose

Examples:
  HF_TOKEN=hf_xxx sudo ./restore_fathom_vm.sh --download-latest --start
  sudo ./restore_fathom_vm.sh --workdir /root/backups --start

Expected files in workdir when not using --download-latest:
  vllm_deployement_backup_<timestamp>.tar.gz
  fathom_minio_data_<timestamp>.tar.gz
  fathom_neo4j_data_<timestamp>.tar.gz
  fathom_neo4j_logs_<timestamp>.tar.gz
EOF
}

while [[ $# -gt 0 ]]; do
  case "$1" in
    --download-latest)
      DOWNLOAD_LATEST=1
      shift
      ;;
    --start)
      START_SERVICES=1
      shift
      ;;
    --workdir)
      WORKDIR="$2"
      shift 2
      ;;
    --repo-id)
      REPO_ID="$2"
      shift 2
      ;;
    --hf-token)
      HF_TOKEN="$2"
      shift 2
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      echo "Unknown argument: $1" >&2
      usage
      exit 1
      ;;
  esac
done

if [[ ${EUID} -ne 0 ]]; then
  echo "Run this script as root." >&2
  exit 1
fi

mkdir -p "${WORKDIR}"
cd "${WORKDIR}"

if [[ ${DOWNLOAD_LATEST} -eq 1 ]]; then
  if [[ -z "${HF_TOKEN}" ]]; then
    echo "HF_TOKEN is required with --download-latest." >&2
    exit 1
  fi

  export REPO_ID HF_TOKEN WORKDIR
  python3 - <<'PY'
import os
import re
import sys
from collections import defaultdict
from huggingface_hub import HfApi, hf_hub_download

repo_id = os.environ["REPO_ID"]
token = os.environ["HF_TOKEN"]
workdir = os.environ["WORKDIR"]
api = HfApi(token=token)
files = api.list_repo_files(repo_id=repo_id, repo_type="dataset")

patterns = {
    "app": re.compile(r"^vllm_deployement_backup_(\d{8}_\d{6})\.tar\.gz$"),
    "minio": re.compile(r"^fathom_minio_data_(\d{8}_\d{6})\.tar\.gz$"),
    "neo4j_data": re.compile(r"^fathom_neo4j_data_(\d{8}_\d{6})\.tar\.gz$"),
    "neo4j_logs": re.compile(r"^fathom_neo4j_logs_(\d{8}_\d{6})\.tar\.gz$"),
}

groups = defaultdict(set)
for name in files:
    base = name.rsplit("/", 1)[-1]
    for key, pattern in patterns.items():
        match = pattern.match(base)
        if match:
            groups[match.group(1)].add(key)

complete = [ts for ts, keys in groups.items() if set(patterns) <= keys]
if not complete:
    print("No complete backup set found in dataset.", file=sys.stderr)
    sys.exit(1)

ts = sorted(complete)[-1]
targets = [
    f"vllm_deployement_backup_{ts}.tar.gz",
    f"fathom_minio_data_{ts}.tar.gz",
    f"fathom_neo4j_data_{ts}.tar.gz",
    f"fathom_neo4j_logs_{ts}.tar.gz",
]

for name in targets:
    path = hf_hub_download(
        repo_id=repo_id,
        repo_type="dataset",
        filename=name,
        token=token,
        local_dir=workdir,
    )
    print(path)
PY
fi

latest_file() {
  local pattern="$1"
  ls -1 ${pattern} 2>/dev/null | sort | tail -n 1
}

APP_ARCHIVE="$(latest_file 'vllm_deployement_backup_*.tar.gz')"
MINIO_ARCHIVE="$(latest_file 'fathom_minio_data_*.tar.gz')"
NEO4J_DATA_ARCHIVE="$(latest_file 'fathom_neo4j_data_*.tar.gz')"
NEO4J_LOGS_ARCHIVE="$(latest_file 'fathom_neo4j_logs_*.tar.gz')"

for required in "${APP_ARCHIVE}" "${MINIO_ARCHIVE}" "${NEO4J_DATA_ARCHIVE}" "${NEO4J_LOGS_ARCHIVE}"; do
  if [[ -z "${required}" || ! -f "${required}" ]]; then
    echo "Missing required backup file in ${WORKDIR}." >&2
    exit 1
  fi
done

echo "Using backup set:"
printf '  %s\n' "${APP_ARCHIVE}" "${MINIO_ARCHIVE}" "${NEO4J_DATA_ARCHIVE}" "${NEO4J_LOGS_ARCHIVE}"

echo "Extracting application archive at /"
tar -xzf "${APP_ARCHIVE}" -C /

echo "Recreating Docker volumes"
docker volume create fathom_minio_data >/dev/null
docker volume create fathom_neo4j_data >/dev/null
docker volume create fathom_neo4j_logs >/dev/null

echo "Restoring MinIO volume"
docker run --rm -v fathom_minio_data:/restore -v "${WORKDIR}:/backup" alpine \
  sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${MINIO_ARCHIVE}")"

echo "Restoring Neo4j data volume"
docker run --rm -v fathom_neo4j_data:/restore -v "${WORKDIR}:/backup" alpine \
  sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${NEO4J_DATA_ARCHIVE}")"

echo "Restoring Neo4j logs volume"
docker run --rm -v fathom_neo4j_logs:/restore -v "${WORKDIR}:/backup" alpine \
  sh -c "cd /restore && rm -rf ./* ./.??* 2>/dev/null || true && tar -xzf /backup/$(basename "${NEO4J_LOGS_ARCHIVE}")"

if [[ ${START_SERVICES} -eq 1 ]]; then
  echo "Starting host-side model server"
  nohup python3 /root/serve.py > /root/serve.log 2>&1 &
  sleep 10

  echo "Starting Docker stack"
  cd /opt/fathom
  docker compose up -d --build
fi

echo "Restore complete."