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

PROJECT_ROOT="${PROJECT_ROOT:-/home/happyuser/projects/DEX}"
BOOTSTRAP_SUPERVISOR="${BOOTSTRAP_SUPERVISOR:-1}"
BOOTSTRAP_TIMEBOX_SECONDS="${BOOTSTRAP_TIMEBOX_SECONDS:-900}"
BOOTSTRAP_MODEL="${BOOTSTRAP_MODEL:-}"
STATUS_INTERVAL_SECONDS="${STATUS_INTERVAL_SECONDS:-30}"
SUPERVISOR_IDLE_INTERVAL_SECONDS="${SUPERVISOR_IDLE_INTERVAL_SECONDS:-900}"
SUPERVISOR_BUSY_INTERVAL_SECONDS="${SUPERVISOR_BUSY_INTERVAL_SECONDS:-7200}"

cd "$PROJECT_ROOT"
mkdir -p .agent/logs .agent/events .agent/tmux_logs .agent/control
mkdir -p .agent/job_requests .agent/job_requests/handled .agent/job_requests/failed

tmux set -g mouse on 2>/dev/null || true
LAST_EVENT_FILE=".agent/control/last_handled_event.txt"
EXPECTED_EVENTS_FILE=".agent/control/expected_events_announced.txt"
LAST_SUPERVISOR_RUN_FILE=".agent/control/last_supervisor_run_epoch.txt"
touch "$LAST_EVENT_FILE"
touch "$EXPECTED_EVENTS_FILE"
touch "$LAST_SUPERVISOR_RUN_FILE"
initial_latest_event="$(find .agent/events -maxdepth 1 -type f -printf '%T@ %p\n' 2>/dev/null | sort -nr | head -1 | cut -d' ' -f2- || true)"
if [[ -n "$initial_latest_event" ]]; then
  printf '%s\n' "$initial_latest_event" > "$LAST_EVENT_FILE"
fi

CONTROL_LOG=".agent/control/control_room_$(date -u +%Y%m%dT%H%M%SZ).log"
exec > >(tee -a "$CONTROL_LOG") 2>&1

echo "===== DEX Codex event control room: $(date -u +%Y-%m-%dT%H:%M:%SZ) ====="
echo "PROJECT_ROOT=$PROJECT_ROOT"
echo "BOOTSTRAP_SUPERVISOR=$BOOTSTRAP_SUPERVISOR"
echo "BOOTSTRAP_TIMEBOX_SECONDS=$BOOTSTRAP_TIMEBOX_SECONDS"
echo "BOOTSTRAP_MODEL=${BOOTSTRAP_MODEL:-<default>}"
echo "STATUS_INTERVAL_SECONDS=$STATUS_INTERVAL_SECONDS"
echo "CONTROL_LOG=$PROJECT_ROOT/$CONTROL_LOG"
echo
echo "Use supervised jobs only:"
echo "  ./scripts/run_tmux_supervised.sh <session_name> '<command>'"
echo

codex_active() {
  "$PROJECT_ROOT/scripts/codex_active_process.sh"
}

kill_codex_active() {
  "$PROJECT_ROOT/scripts/codex_kill_active_processes.sh"
}

latest_event_file() {
  find .agent/events -maxdepth 1 -type f -printf '%T@ %p\n' 2>/dev/null \
    | sort -nr | head -1 | cut -d' ' -f2- || true
}

sanitize_session_name() {
  printf '%s' "$1" | tr -c 'A-Za-z0-9_.-' '_'
}

tmux_log_for_session() {
  local session_name="$1"
  local safe_session
  safe_session="$(sanitize_session_name "$session_name")"
  find .agent/tmux_logs -maxdepth 1 -type f -name "${safe_session}_*.log" -printf '%T@ %p\n' 2>/dev/null \
    | sort -nr | head -1 | cut -d' ' -f2- || true
}

pending_job_request_count() {
  find .agent/job_requests -maxdepth 1 -type f -name '*.request' 2>/dev/null | wc -l | tr -d ' '
}

active_job_session_count() {
  tmux list-sessions 2>/dev/null \
    | awk -F: '$1 != "dex_control_room" {count++} END {print count + 0}'
}

is_busy_mode() {
  local pending active
  pending="$(pending_job_request_count)"
  active="$(active_job_session_count)"
  if [[ "$pending" != "0" || "$active" != "0" ]]; then
    return 0
  fi
  return 1
}

current_supervisor_interval_seconds() {
  if is_busy_mode; then
    printf '%s\n' "$SUPERVISOR_BUSY_INTERVAL_SECONDS"
  else
    printf '%s\n' "$SUPERVISOR_IDLE_INTERVAL_SECONDS"
  fi
}

record_supervisor_launch() {
  date -u +%s > "$LAST_SUPERVISOR_RUN_FILE"
}

last_supervisor_launch_epoch() {
  local value
  value="$(tr -d '[:space:]' < "$LAST_SUPERVISOR_RUN_FILE" 2>/dev/null || true)"
  if [[ -n "$value" && "$value" =~ ^[0-9]+$ ]]; then
    printf '%s\n' "$value"
  else
    printf '0\n'
  fi
}

maybe_periodic_supervisor_start() {
  local now_epoch last_epoch elapsed interval mode
  now_epoch="$(date -u +%s)"
  last_epoch="$(last_supervisor_launch_epoch)"
  interval="$(current_supervisor_interval_seconds)"

  if is_busy_mode; then
    mode="busy"
  else
    mode="idle"
  fi

  if codex_active; then
    return 0
  fi

  if [[ "$last_epoch" == "0" ]]; then
    echo "[control] periodic supervisor start mode=$mode interval=${interval}s elapsed=initial"
    start_supervisor_if_idle "" 1
    return $?
  fi

  elapsed=$((now_epoch - last_epoch))
  if (( elapsed < interval )); then
    return 0
  fi

  echo "[control] periodic supervisor start mode=$mode interval=${interval}s elapsed=${elapsed}s"
  start_supervisor_if_idle "" 1
  return $?
}

announce_expected_event_once() {
  local key="$1"
  local description="$2"
  local eta="$3"
  local existing
  existing="$(grep -F -x "$key" "$EXPECTED_EVENTS_FILE" 2>/dev/null || true)"
  if [[ -n "$existing" ]]; then
    return 1
  fi
  printf '%s\n' "$key" >> "$EXPECTED_EVENTS_FILE"
  echo "$description -> expected around $eta"
  return 0
}

print_expected_events_once() {
  local now_utc now_epoch eta_epoch eta_iso request expected_count key start_line start_utc session_name log_file
  now_utc="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
  now_epoch="$(date -u +%s)"
  expected_count=0

  while IFS= read -r request; do
    [[ -n "$request" && -f "$request" ]] || continue
    request="$(basename "$request")"
    key="request:$request"
    expected_count=$((expected_count + 1))
    eta_epoch=$((now_epoch + STATUS_INTERVAL_SECONDS))
    eta_iso="$(date -u -d "@$eta_epoch" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u +%Y-%m-%dT%H:%M:%SZ)"
    announce_expected_event_once "$key" "queued job request: $request" "$eta_iso" || true
  done < <(find .agent/job_requests -maxdepth 1 -type f -name '*.request' -printf '%T@ %p\n' 2>/dev/null | sort -n | cut -d' ' -f2-)

  while IFS= read -r session_line; do
    [[ -n "$session_line" ]] || continue
    case "$session_line" in
      dex_control_room:*)
        continue
        ;;
    esac
    session_name="${session_line%%:*}"
    log_file="$(tmux_log_for_session "$session_name")"
    if [[ -z "$log_file" || ! -f "$log_file" ]]; then
      continue
    fi

    start_line="$(sed -n '1p' "$log_file" 2>/dev/null || true)"
    start_utc="${start_line#===== tmux supervised start: }"
    start_utc="${start_utc% =====}"
    if [[ "$start_utc" == "$start_line" || -z "$start_utc" ]]; then
      start_utc="$now_utc"
    fi

    eta_iso="$(date -u -d "$start_utc + 30 minutes" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo "$now_utc")"
    expected_count=$((expected_count + 1))
    key="tmux:${session_name}:${start_utc}"
    announce_expected_event_once "$key" "active tmux job: $session_name" "$eta_iso" || true
  done < <(tmux list-sessions 2>/dev/null || true)

  if [[ "$expected_count" == "0" ]]; then
    return 0
  fi
}

handle_job_requests() {
  local request rc session_name command_b64 command handled failed
  while IFS= read -r request; do
    [[ -n "$request" && -f "$request" ]] || continue
    session_name=""
    command_b64=""
    # shellcheck disable=SC1090
    source "$request"
    if [[ -z "${SESSION_NAME:-}" || -z "${COMMAND_B64:-}" ]]; then
      echo "[control] invalid job request: $request"
      mv "$request" ".agent/job_requests/failed/$(basename "$request").invalid" 2>/dev/null || true
      continue
    fi
    session_name="$SESSION_NAME"
    command_b64="$COMMAND_B64"
    command="$(printf '%s' "$command_b64" | base64 -d)"
    echo "[control] starting requested supervised job: $session_name"
    set +e
    "$PROJECT_ROOT/scripts/run_tmux_supervised.sh" "$session_name" "$command"
    rc=$?
    set -e
    if [[ "$rc" == "0" ]]; then
      handled=".agent/job_requests/handled/$(basename "$request").started"
      mv "$request" "$handled" 2>/dev/null || true
      echo "[control] job request started: $handled"
    else
      failed=".agent/job_requests/failed/$(basename "$request").failed"
      mv "$request" "$failed" 2>/dev/null || true
      echo "[control] job request failed rc=$rc: $failed"
    fi
  done < <(find .agent/job_requests -maxdepth 1 -type f -name '*.request' -printf '%T@ %p\n' 2>/dev/null | sort -n | cut -d' ' -f2-)
}

start_supervisor_if_idle() {
  local event_file="${1:-}"
  local force="${2:-0}"
  if [[ "$force" != "1" ]] && codex_active; then
    echo "[control] Codex already active; deferring new supervisor start"
    return 0
  fi

  set +e
  record_supervisor_launch
  if [[ -n "$event_file" ]]; then
    echo "[control] starting supervisor for event: $event_file"
    PROJECT_ROOT="$PROJECT_ROOT" \
    CODEX_MODEL="$BOOTSTRAP_MODEL" \
    TIMEBOX_SECONDS="$BOOTSTRAP_TIMEBOX_SECONDS" \
    SUPERVISOR_EVENT_FILE="$event_file" \
    SNAPSHOT_PROMPT_LINES=80 \
    "$PROJECT_ROOT/scripts/codex_autorun_nogit.sh"
  else
    echo "[control] starting bootstrap supervisor"
    PROJECT_ROOT="$PROJECT_ROOT" \
    CODEX_MODEL="$BOOTSTRAP_MODEL" \
    TIMEBOX_SECONDS="$BOOTSTRAP_TIMEBOX_SECONDS" \
    SNAPSHOT_PROMPT_LINES=80 \
    "$PROJECT_ROOT/scripts/codex_autorun_nogit.sh"
  fi
  rc=$?
  if [[ "$rc" == "0" ]]; then
    set -e
    return 0
  fi
  return "$rc"
}

if [[ "$BOOTSTRAP_SUPERVISOR" == "1" ]]; then
  echo "===== bootstrap supervisor start: $(date -u +%Y-%m-%dT%H:%M:%SZ) ====="
  if codex_active; then
    echo "[bootstrap] Codex already active; resetting active Codex processes before bootstrap"
    kill_codex_active
  fi
  set +e
  start_supervisor_if_idle "" 1
  rc=$?
  set -e
  echo "===== bootstrap supervisor exit=$rc: $(date -u +%Y-%m-%dT%H:%M:%SZ) ====="
fi

while true; do
  echo "."
  handle_job_requests
  print_expected_events_once

  latest_event="$(latest_event_file)"
  last_handled_event="$(cat "$LAST_EVENT_FILE" 2>/dev/null || true)"
  if [[ -n "$latest_event" && -f "$latest_event" ]]; then
    if [[ "$latest_event" != "$last_handled_event" ]]; then
      if codex_active; then
        echo "[control] new event is pending, but Codex is still active"
      else
        set +e
        start_supervisor_if_idle "$latest_event"
        rc=$?
        set -e
        echo "$latest_event" > "$LAST_EVENT_FILE"
        echo "[control] handled event: $latest_event (rc=$rc)"
      fi
    fi
  fi
  maybe_periodic_supervisor_start || true
  sleep "$STATUS_INTERVAL_SECONDS"
done