#!/usr/bin/env zsh
# ...existing code...
# scripts/restart-livekit-server.sh
# Reinicia/arranca livekit-server con la clave API/SECRET adecuada, redirige logs y realiza checks básicos.
# Uso típico:
#  ./scripts/restart-livekit-server.sh --api-key devkey --api-secret secret --method dev --logs /tmp/livekit.log

set -euo pipefail

API_KEY="${LIVEKIT_API_KEY:-devkey}"
API_SECRET="${LIVEKIT_API_SECRET:-secret}"
METHOD="auto"            # auto | systemd | docker | dev
SERVICE_NAME="livekit-server"  # nombre del servicio para systemd / docker-compose
COMPOSE_PATH="./docker-compose.yml"
BINARY="${LIVEKIT_BINARY:-livekit-server}"
LOGS="${LOGS_FILE:-livekit-server.log}"
HTTP_URL="${LIVEKIT_HTTP_URL:-http://localhost:7880}"
WS_URL="${LIVEKIT_WS_URL:-ws://localhost:7880}"
SKIP_TESTS=false

usage() {
  cat <<EOF
Usage: $0 [options]
Options:
  --api-key KEY         LiveKit API key (default: $API_KEY)
  --api-secret SECRET   LiveKit API secret (default: $API_SECRET)
  --method METHOD       Restart method: auto|systemd|docker|dev (default: auto)
  --service-name NAME   Systemd / compose service name (default: $SERVICE_NAME)
  --compose-path PATH   docker-compose.yml path (default: $COMPOSE_PATH)
  --binary PATH         livekit-server binary (default: $BINARY)
  --logs PATH           File to append logs (default: $LOGS)
  --http-url URL        Base HTTP URL for health/validate checks (default: $HTTP_URL)
  --ws-url URL          WebSocket URL for handshake test (default: $WS_URL)
  --skip-tests          Skip curl/wscat tests
  -h, --help            Show this help
EOF
}

# Parse args
while [[ $# -gt 0 ]]; do
  case "$1" in
    --api-key) API_KEY="$2"; shift 2;;
    --api-secret) API_SECRET="$2"; shift 2;;
    --method) METHOD="$2"; shift 2;;
    --service-name) SERVICE_NAME="$2"; shift 2;;
    --compose-path) COMPOSE_PATH="$2"; shift 2;;
    --binary) BINARY="$2"; shift 2;;
    --logs) LOGS="$2"; shift 2;;
    --http-url) HTTP_URL="$2"; shift 2;;
    --ws-url) WS_URL="$2"; shift 2;;
    --skip-tests) SKIP_TESTS=true; shift 1;;
    -h|--help) usage; exit 0;;
    *) echo "Unknown option: $1"; usage; exit 1;;
  esac
done

echo "[restart-livekit] método=$METHOD service=$SERVICE_NAME binary=$BINARY logs=$LOGS"

# Helpers
has_systemd_service() {
  if command -v systemctl >/dev/null 2>&1; then
    sudo systemctl list-unit-files --type=service --no-legend | grep -q "$SERVICE_NAME" || return 1
    return 0
  fi
  return 1
}

restart_systemd() {
  echo "[restart-livekit] intentando reiniciar servicio systemd: $SERVICE_NAME"
  if ! sudo systemctl restart "$SERVICE_NAME"; then
    echo "[restart-livekit] fallo al reiniciar systemd service $SERVICE_NAME" >&2
    return 1
  fi
  echo "[restart-livekit] systemd restart pedido correctamente. Esperando 2s para estabilizar..."
  sleep 2
  return 0
}

restart_docker_compose() {
  if [ -f "$COMPOSE_PATH" ]; then
    echo "[restart-livekit] intentando restart con docker-compose ($COMPOSE_PATH)"
    if command -v docker-compose >/dev/null 2>&1; then
      docker-compose -f "$COMPOSE_PATH" restart "$SERVICE_NAME" || docker-compose -f "$COMPOSE_PATH" up -d "$SERVICE_NAME"
      sleep 2
      return 0
    elif command -v docker >/dev/null 2>&1 && command -v docker-compose >/dev/null 2>&1; then
      docker-compose -f "$COMPOSE_PATH" restart "$SERVICE_NAME" || docker-compose -f "$COMPOSE_PATH" up -d "$SERVICE_NAME"
      sleep 2
      return 0
    else
      echo "[restart-livekit] docker-compose no encontrado" >&2
      return 1
    fi
  fi
  return 1
}

start_dev_process() {
  echo "[restart-livekit] arrancando '$BINARY --dev' con LIVEKIT_KEYS='${API_KEY}:${API_SECRET}'"
  # Matar procesos previos (intento seguro)
  if pgrep -f "$BINARY" >/dev/null 2>&1; then
    echo "[restart-livekit] matando procesos previos de $BINARY"
    pkill -f "$BINARY" || true
    sleep 1
  fi

  mkdir -p "$(dirname "$LOGS")" || true
  echo "[restart-livekit] lanzando en background; logs -> $LOGS"
  nohup env LIVEKIT_KEYS="${API_KEY}:${API_SECRET}" "$BINARY" --dev > "$LOGS" 2>&1 &
  sleep 2
}

# Decide el método
if [ "$METHOD" = "auto" ]; then
  if has_systemd_service; then
    CHOSEN=systemd
  elif [ -f "$COMPOSE_PATH" ]; then
    CHOSEN=docker
  else
    CHOSEN=dev
  fi
else
  CHOSEN="$METHOD"
fi

echo "[restart-livekit] método elegido: $CHOSEN"

case "$CHOSEN" in
  systemd)
    if ! restart_systemd; then
      echo "[restart-livekit] systemd falló, intentando método dev como fallback"
      start_dev_process
    fi
    ;;
  docker)
    if ! restart_docker_compose; then
      echo "[restart-livekit] docker-compose falló, intentando método dev como fallback"
      start_dev_process
    fi
    ;;
  dev)
    start_dev_process
    ;;
  *)
    echo "Método desconocido: $CHOSEN"; exit 2
    ;;
esac

# Wait breve y realizar checks
if [ "$SKIP_TESTS" = true ]; then
  echo "[restart-livekit] skip tests activado, terminado. Revisa logs: $LOGS"
  exit 0
fi

echo "[restart-livekit] comprobaciones básicas: curl y wscat (si está instalado)"

# 1) curl a /rtc/validate (si el usuario lo desea, la URL es configurable)
if command -v curl >/dev/null 2>&1; then
  echo "\n--- curl ${HTTP_URL}/rtc/validate (timeout 5s) ---"
  set +e
  HTTP_OUT=$(curl -sS --max-time 5 -w "HTTP_STATUS:%{http_code}" "${HTTP_URL}/rtc/validate" 2>&1)
  CURL_STATUS=$?
  set -e
  if [ $CURL_STATUS -ne 0 ]; then
    echo "[restart-livekit] curl fallo (exit $CURL_STATUS). Salida:\n$HTTP_OUT"
  else
    echo "$HTTP_OUT" | sed -n '1,200p'
  fi
else
  echo "[restart-livekit] curl no está instalado; omitiendo check HTTP"
fi

# 2) intento rápido con wscat para ver handshake (no envía token)
if command -v wscat >/dev/null 2>&1; then
  echo "\n--- wscat -c ${WS_URL} (intento corto 4s) ---"
  # usar timeout para no colgar
  if command -v timeout >/dev/null 2>&1; then
    timeout 4s wscat -c "${WS_URL}" || true
  else
    echo "(nota: no se encontró 'timeout', wscat puede esperar indefinidamente)"
    wscat -c "${WS_URL}" || true
  fi
else
  echo "[restart-livekit] wscat no instalado; para una prueba WebSocket instálalo con 'npm i -g wscat' o utilice websocat"
fi

echo "[restart-livekit] FIN. Revisa $LOGS para logs completos (tail -n 200 $LOGS)"
# ...existing code...