#!/usr/bin/env bash
#
# Launch a world simulation in single-trajectory playback mode. The
# SimpleDronePlugin reads one trajectory CSV, stops at every point, captures
# front/down/left/right images under that trajectory's subdirectory, writes
# captured yaw back to the CSV, then stops.
#
# Usage:
#   ./run.sh trajectory_0001_Reach-Avoid.csv
#   ./run.sh gui trajectory_0001_Reach-Avoid.csv
#   ./run.sh v2 trajectory_0001.csv
#   DATASET_ROOT=datasets/world_v2 ./run.sh trajectory_0001.csv
#   ./run.sh datasets/world_v1/trajectory/trajectory_0001_Reach-Avoid.csv
#   ./run.sh           # defaults to the first CSV in trajectory/
#
set -euo pipefail

echo "[run.sh] initializing..."

# Project layout, resolved from this script location.
PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
WORLD_DIR="${PROJECT_DIR}/world"
PLUGIN_BUILD="${PROJECT_DIR}/plugins/build"
DATASET_ROOT_WAS_SET=0
if [[ -n "${DATASET_ROOT:-}" ]]; then
  DATASET_ROOT_WAS_SET=1
fi

# --- load Gazebo's default paths (sun, ground_plane, system plugins, ...) ---
# (setup.sh references unset vars, so relax nounset while sourcing it)
set +u
# shellcheck disable=SC1091
source /usr/share/gazebo/setup.sh
set -u

# --- strip Anaconda from PATH / LD_LIBRARY_PATH (its protobuf clashes with Gazebo) ---
CLEAN_PATH=$(printf '%s' "${PATH}" | awk -v RS=: 'tolower($0) !~ /anaconda/ {printf "%s%s", sep, $0; sep=":"}')
CLEAN_LD=$(printf '%s' "${LD_LIBRARY_PATH:-}" | awk -v RS=: 'tolower($0) !~ /anaconda/ {printf "%s%s", sep, $0; sep=":"}')

export PATH="${CLEAN_PATH}"
export LD_LIBRARY_PATH="${CLEAN_LD}"
unset CONDA_PREFIX CONDA_DEFAULT_ENV CONDA_SHLVL CONDA_EXE _CONDA_EXE _CONDA_ROOT CONDA_PYTHON_EXE CONDA_PROMPT_MODIFIER
unset CMAKE_PREFIX_PATH Protobuf_DIR protobuf_DIR
# More stable rendering over remote X/RDP sessions. Camera sensors still need
# Gazebo's rendering backend even when running gzserver without the GUI.
export QT_X11_NO_MITSHM=1
if [[ "${SIMPLE_DRONE_RENDER_BACKEND:-system}" == "nvidia" ]]; then
  export LIBGL_ALWAYS_SOFTWARE=0
  export __NV_PRIME_RENDER_OFFLOAD=1
  export __GLX_VENDOR_LIBRARY_NAME=nvidia
elif [[ "${SIMPLE_DRONE_RENDER_BACKEND:-system}" == "software" ||
        "${SIMPLE_DRONE_RENDER_BACKEND:-system}" == "xvfb" ]]; then
  export LIBGL_ALWAYS_SOFTWARE=1
  unset __NV_PRIME_RENDER_OFFLOAD
  export __GLX_VENDOR_LIBRARY_NAME=mesa
  export MESA_LOADER_DRIVER_OVERRIDE="${MESA_LOADER_DRIVER_OVERRIDE:-swrast}"
else
  export LIBGL_ALWAYS_SOFTWARE=0
  unset __NV_PRIME_RENDER_OFFLOAD __GLX_VENDOR_LIBRARY_NAME MESA_LOADER_DRIVER_OVERRIDE
fi
# prepend our project paths to whatever setup.sh configured
export GAZEBO_PLUGIN_PATH="${PLUGIN_BUILD}:${GAZEBO_PLUGIN_PATH:-}"
export GAZEBO_MODEL_PATH="${PROJECT_DIR}/models:${GAZEBO_MODEL_PATH:-}"
# so Gazebo registers <proj>/media/materials/{scripts,textures} and loads our
# custom materials (e.g. Home/MutedWoodFloor used by the floor)
export GAZEBO_RESOURCE_PATH="${PROJECT_DIR}:${GAZEBO_RESOURCE_PATH:-}"

# Avoid colliding with a stale or separately running Gazebo master on 11345.
# Dataset capture defaults to an isolated master even if the shell exports
# GAZEBO_MASTER_URI. Set SIMPLE_DRONE_KEEP_MASTER_URI=1 to opt into reuse.
if [[ -n "${SIMPLE_DRONE_MASTER_PORT:-}" ]]; then
  export GAZEBO_MASTER_URI="http://127.0.0.1:${SIMPLE_DRONE_MASTER_PORT}"
elif [[ -z "${GAZEBO_MASTER_URI:-}" || "${SIMPLE_DRONE_KEEP_MASTER_URI:-0}" == "0" ]]; then
  GAZEBO_MASTER_PORT=""
  GAZEBO_MASTER_PORT="$(
    python3 - <<'PY' 2>/dev/null || true
import socket

for port in range(11345, 11446):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        try:
            sock.bind(("127.0.0.1", port))
        except OSError:
            continue
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        try:
            sock.settimeout(0.1)
            sock.connect(("localhost", port))
        except OSError:
            print(port)
            break
else:
    raise SystemExit("no free Gazebo master port in 11345..11445")
PY
  )"
  if [[ -z "${GAZEBO_MASTER_PORT}" ]]; then
    GAZEBO_MASTER_PORT="${SIMPLE_DRONE_DEFAULT_MASTER_PORT:-11345}"
    echo "[run.sh] warning: could not probe a free Gazebo master port; using ${GAZEBO_MASTER_PORT}" >&2
  fi
  export GAZEBO_MASTER_URI="http://127.0.0.1:${GAZEBO_MASTER_PORT}"
fi

# --- build the plugin if it is missing or out of date ---
PLUGIN_SO="${PLUGIN_BUILD}/libSimpleDronePlugin.so"
PLUGIN_SRC="${PROJECT_DIR}/plugins/SimpleDronePlugin.cc"
if [[ ! -f "${PLUGIN_SO}" || "${PLUGIN_SRC}" -nt "${PLUGIN_SO}" ]]; then
  echo "[run.sh] building plugin..."
  mkdir -p "${PLUGIN_BUILD}"
  ( cd "${PLUGIN_BUILD}" && cmake .. -DCMAKE_BUILD_TYPE=Release && make )
fi

# --- pick GUI vs headless ---
BIN="gzserver"
if [[ "${1:-}" == "gui" ]]; then
  BIN="gazebo"
  shift
fi

WORLD_ARG="${WORLD_FILE:-${WORLD_VERSION:-}}"
if [[ -n "${1:-}" ]]; then
  if [[ "${1}" =~ ^v[0-9]+$ || "${1}" =~ ^[0-9]+$ || "${1}" == *.world ]]; then
    WORLD_ARG="${1}"
    shift
  fi
fi

if [[ "${DATASET_ROOT_WAS_SET}" -eq 0 ]]; then
  if [[ "${WORLD_ARG}" =~ ^v?([0-9]+)$ ]]; then
    DATASET_ROOT="${PROJECT_DIR}/datasets/world_v${BASH_REMATCH[1]}"
  else
    DATASET_ROOT="${PROJECT_DIR}/datasets/world_v1"
  fi
else
  DATASET_ROOT_PARENT="$(dirname "${DATASET_ROOT}")"
  DATASET_ROOT_BASE="$(basename "${DATASET_ROOT}")"
  DATASET_ROOT="$(cd "${DATASET_ROOT_PARENT}" && pwd)/${DATASET_ROOT_BASE}"
fi

if [[ -z "${WORLD_ARG}" && "$(basename "${DATASET_ROOT}")" =~ ^world_v([0-9]+)$ ]]; then
  WORLD_ARG="v${BASH_REMATCH[1]}"
fi
WORLD_ARG="${WORLD_ARG:-v1}"

if [[ "${WORLD_ARG}" =~ ^v([0-9]+)$ ]]; then
  WORLD="${WORLD_DIR}/home_room_v${BASH_REMATCH[1]}.world"
elif [[ "${WORLD_ARG}" =~ ^[0-9]+$ ]]; then
  WORLD="${WORLD_DIR}/home_room_v${WORLD_ARG}.world"
else
  WORLD="${WORLD_ARG}"
fi

if [[ "${WORLD}" != /* ]]; then
  WORLD="$(cd "$(dirname "${WORLD}")" && pwd)/$(basename "${WORLD}")"
fi

if [[ ! -f "${WORLD}" ]]; then
  echo "[run.sh] world file not found: ${WORLD}" >&2
  exit 1
fi

mkdir -p \
  "${DATASET_ROOT}/images" \
  "${DATASET_ROOT}/trajectory"

TRAJECTORY_ARG="${1:-}"
if [[ -z "${TRAJECTORY_ARG}" ]]; then
  mapfile -t TRAJECTORY_CANDIDATES < <(
    find "${DATASET_ROOT}/trajectory" -maxdepth 1 -type f -name '*.csv' | sort
  )
  TRAJECTORY_FILE="${TRAJECTORY_CANDIDATES[0]:-}"
elif [[ -f "${TRAJECTORY_ARG}" ]]; then
  TRAJECTORY_FILE="$(cd "$(dirname "${TRAJECTORY_ARG}")" && pwd)/$(basename "${TRAJECTORY_ARG}")"
elif [[ -f "${DATASET_ROOT}/trajectory/${TRAJECTORY_ARG}" ]]; then
  TRAJECTORY_FILE="${DATASET_ROOT}/trajectory/${TRAJECTORY_ARG}"
else
  echo "[run.sh] trajectory CSV not found: ${TRAJECTORY_ARG}" >&2
  exit 1
fi

if [[ -z "${TRAJECTORY_FILE}" || ! -f "${TRAJECTORY_FILE}" ]]; then
  echo "[run.sh] no trajectory CSV found in ${DATASET_ROOT}/trajectory" >&2
  exit 1
fi

# The model.sdf may contain an absolute <image_dir>; the plugin lets this env
# var override it so paths stay project-relative.
export SIMPLE_DRONE_IMAGE_DIR="${DATASET_ROOT}/images"
export SIMPLE_DRONE_DATASET_ROOT="${DATASET_ROOT}"
export SIMPLE_DRONE_DATASET_TRAJECTORY_FILE="${TRAJECTORY_FILE}"

DONE_FILE=""
if [[ "${SIMPLE_DRONE_QUIT_ON_FINISH:-0}" != "0" ]]; then
  DONE_DIR="${DATASET_ROOT}/.run_done"
  mkdir -p "${DONE_DIR}"
  DONE_FILE="${DONE_DIR}/$(basename "${TRAJECTORY_FILE}" .csv).done"
  rm -f "${DONE_FILE}"
  export SIMPLE_DRONE_DONE_FILE="${DONE_FILE}"
fi

# --- start or reuse an X server for camera rendering ---
HEADLESS_XORG=""
XORG_CONF_DIR=""
if [[ "${BIN}" == "gzserver" ]]; then
  if [[ "${SIMPLE_DRONE_RENDER_BACKEND:-system}" != "xvfb" &&
        "${SIMPLE_DRONE_RENDER_BACKEND:-system}" != "nvidia" ]] &&
     [[ -n "${DISPLAY:-}" ]] &&
     xdpyinfo -display "${DISPLAY}" &>/dev/null; then
    echo "[run.sh] using existing DISPLAY=${DISPLAY}"
  else
    if [[ -n "${DISPLAY:-}" ]]; then
      echo "[run.sh] DISPLAY=${DISPLAY} is not usable; starting a private render display"
    fi
    unset DISPLAY

    XORG_CONF_DIR=$(mktemp -d /tmp/headless_xorg.XXXXXX)
    RENDER_LOG_DIR="${DATASET_ROOT}/.run_logs"
    mkdir -p "${RENDER_LOG_DIR}"
    XORG_LOG="${RENDER_LOG_DIR}/xorg.log"
    XVFB_LOG="${RENDER_LOG_DIR}/xvfb.log"

    # Find an available display number.
    HEADLESS_DISPLAY="${SIMPLE_DRONE_DISPLAY_NUMBER:-8}"
    while [[ -e "/tmp/.X${HEADLESS_DISPLAY}-lock" ]]; do
      HEADLESS_DISPLAY=$((HEADLESS_DISPLAY + 1))
    done

    NVIDIA_BUS_ID="${SIMPLE_DRONE_NVIDIA_BUS_ID:-}"
    if [[ -z "${NVIDIA_BUS_ID}" ]] && command -v lspci >/dev/null 2>&1; then
      NVIDIA_PCI_ADDR="$(lspci -D | awk '/NVIDIA/ && /VGA|3D|Display/ {print $1; exit}' || true)"
      if [[ "${NVIDIA_PCI_ADDR}" =~ ^[0-9a-fA-F]+:([0-9a-fA-F]+):([0-9a-fA-F]+)\.([0-9]+)$ ]]; then
        NVIDIA_BUS_ID="PCI:$((16#${BASH_REMATCH[1]})):$((16#${BASH_REMATCH[2]})):${BASH_REMATCH[3]}"
      fi
    fi

    STARTED_RENDER_SERVER=0
    if [[ "${SIMPLE_DRONE_RENDER_BACKEND:-system}" != "xvfb" ]] &&
       [[ -n "${NVIDIA_BUS_ID}" ]] &&
       nvidia-smi >/dev/null 2>&1; then
      cat > "${XORG_CONF_DIR}/xorg.conf" <<XORG
Section "ServerLayout"
    Identifier "HeadlessLayout"
    Screen 0 "Screen0" 0 0
EndSection

Section "Device"
    Identifier "nvidia"
    Driver "nvidia"
    BusID "${NVIDIA_BUS_ID}"
EndSection

Section "Screen"
    Identifier "Screen0"
    Device "nvidia"
    DefaultDepth 24
    SubSection "Display"
        Depth 24
        Modes "1024x768"
    EndSubSection
EndSection

Section "ServerFlags"
    Option "DontVTSwitch" "True"
    Option "AllowMouseOpenFail" "True"
EndSection
XORG

      echo "[run.sh] starting headless Xorg on :${HEADLESS_DISPLAY} (${NVIDIA_BUS_ID})"
      (
        cd "${XORG_CONF_DIR}"
        Xorg -noreset +extension GLX +extension RANDR +extension RENDER \
          -config xorg.conf ":${HEADLESS_DISPLAY}"
      ) >"${XORG_LOG}" 2>&1 &
      HEADLESS_XORG=$!

      for _ in $(seq 1 30); do
        if xdpyinfo -display ":${HEADLESS_DISPLAY}" &>/dev/null; then
          STARTED_RENDER_SERVER=1
          break
        fi
        if ! kill -0 "${HEADLESS_XORG}" 2>/dev/null; then
          break
        fi
        sleep 0.5
      done

      if [[ "${STARTED_RENDER_SERVER}" -eq 0 ]]; then
        echo "[run.sh] headless Xorg failed; log -> ${XORG_LOG}"
        kill "${HEADLESS_XORG}" 2>/dev/null || true
        wait "${HEADLESS_XORG}" 2>/dev/null || true
        HEADLESS_XORG=""
      fi
    fi

    if [[ "${STARTED_RENDER_SERVER}" -eq 0 ]]; then
      if ! command -v Xvfb >/dev/null 2>&1; then
        echo "[run.sh] neither usable DISPLAY nor Xvfb is available" >&2
        exit 1
      fi

      while [[ -e "/tmp/.X${HEADLESS_DISPLAY}-lock" ]]; do
        HEADLESS_DISPLAY=$((HEADLESS_DISPLAY + 1))
      done

      echo "[run.sh] starting Xvfb on :${HEADLESS_DISPLAY}"
      Xvfb ":${HEADLESS_DISPLAY}" -screen 0 1024x768x24 >"${XVFB_LOG}" 2>&1 &
      HEADLESS_XORG=$!

      for _ in $(seq 1 30); do
        if xdpyinfo -display ":${HEADLESS_DISPLAY}" &>/dev/null; then
          STARTED_RENDER_SERVER=1
          break
        fi
        if ! kill -0 "${HEADLESS_XORG}" 2>/dev/null; then
          break
        fi
        sleep 0.5
      done

      if [[ "${STARTED_RENDER_SERVER}" -eq 0 ]]; then
        echo "[run.sh] failed to start Xvfb; log -> ${XVFB_LOG}" >&2
        tail -n 40 "${XVFB_LOG}" >&2 || true
        ls -ld /tmp /tmp/.X11-unix >&2 || true
        rm -rf "${XORG_CONF_DIR}"
        exit 1
      fi

      export LIBGL_ALWAYS_SOFTWARE=1
      unset __NV_PRIME_RENDER_OFFLOAD
      export __GLX_VENDOR_LIBRARY_NAME=mesa
      export MESA_LOADER_DRIVER_OVERRIDE="${MESA_LOADER_DRIVER_OVERRIDE:-swrast}"
    fi

    export DISPLAY=":${HEADLESS_DISPLAY}"
  fi
fi

echo "[run.sh] launching ${BIN} on ${WORLD}"
echo "[run.sh] gazebo master -> ${GAZEBO_MASTER_URI}"
echo "[run.sh] dataset -> ${DATASET_ROOT}"
echo "[run.sh] trajectory -> ${TRAJECTORY_FILE}"
echo "[run.sh] images -> ${DATASET_ROOT}/images/<trajectory_name>/images_{front,down,left,right}"
echo "[run.sh] trajectories -> ${DATASET_ROOT}/trajectory"

cleanup() {
  if [[ -n "${GAZEBO_PID:-}" ]] && kill -0 "${GAZEBO_PID}" 2>/dev/null; then
    kill -- "-${GAZEBO_PID}" 2>/dev/null || kill "${GAZEBO_PID}" 2>/dev/null || true
    wait "${GAZEBO_PID}" 2>/dev/null || true
  fi
  if [[ -n "${HEADLESS_XORG:-}" ]] && kill -0 "${HEADLESS_XORG}" 2>/dev/null; then
    kill -- "-${HEADLESS_XORG}" 2>/dev/null || kill "${HEADLESS_XORG}" 2>/dev/null || true
    wait "${HEADLESS_XORG}" 2>/dev/null || true
  fi
  if [[ -n "${XORG_CONF_DIR:-}" ]] && [[ -d "${XORG_CONF_DIR}" ]]; then
    rm -rf "${XORG_CONF_DIR}"
  fi
}
trap cleanup EXIT INT TERM

if [[ -z "${DONE_FILE}" ]]; then
  "${BIN}" --verbose "${WORLD}"
  cleanup
  trap - EXIT INT TERM
  exit 0
fi

setsid "${BIN}" --verbose "${WORLD}" &
GAZEBO_PID=$!
RUN_START_TIME="$(date +%s)"
RUN_TIMEOUT="${SIMPLE_DRONE_RUN_TIMEOUT:-900}"

while kill -0 "${GAZEBO_PID}" 2>/dev/null; do
  if [[ -f "${DONE_FILE}" ]]; then
    echo "[run.sh] trajectory complete -> ${DONE_FILE}"
    cleanup
    trap - EXIT INT TERM
    exit 0
  fi
  if [[ "${RUN_TIMEOUT}" -gt 0 ]]; then
    NOW="$(date +%s)"
    if (( NOW - RUN_START_TIME > RUN_TIMEOUT )); then
      echo "[run.sh] timeout after ${RUN_TIMEOUT}s waiting for trajectory completion" >&2
      cleanup
      trap - EXIT INT TERM
      exit 124
    fi
  fi
  sleep 0.5
done

wait "${GAZEBO_PID}"