#!/bin/bash
set -euo pipefail
SELF_DIR="$(cd "$(dirname "$0")" && pwd)"
. "$BRAIN/scripts/_util.sh" 2>/dev/null || true
if ! declare -F human_now >/dev/null 2>&1; then
  human_now(){ date -u +%Y-%m-%dT%H:%M:%SZ; }
fi

BRAIN="${BRAIN:-/Users/josephanady/Desktop/AI_Brain_Control}"
BODY="${BODY:-/Users/josephanady/Desktop/AI_Body}"
SUB="$BRAIN/sub_brains/codex"
JOBS="$SUB/jobs"
QUEUED="$JOBS/queued"
RUNNING="$JOBS/running"
DONE="$JOBS/done"
FAILED="$JOBS/failed"
OUT="$SUB/out"
LOGS="$SUB/logs"
BRIDGE="$BRAIN/bridges"
DOCS="$BRAIN/docs"
mkdir -p "$QUEUED" "$RUNNING" "$DONE" "$FAILED" "$OUT" "$LOGS" "$BRIDGE" "$DOCS"

LOG="$LOGS/codex_$(date +%F).log"
exec > >(tee -a "$LOG") 2>&1

echo "[$(human_now)] Codex starting…"
echo "  BODY=$BODY"
echo "  BRAIN=$BRAIN"
echo "  QUEUED=$QUEUED"
echo "  OUT=$OUT"

# Locate builder(s)
BUILDER_A="$BODY/build_body.sh"                       # SQLite/telemetry builder
BUILDER_B="$BODY/build_body_with_metadata.sh"         # JSON-metadata builder (if present)

safe_run_builder(){
  local profile="$1" total="$2" size="$3" comp="$4" level="$5"
  if [ -x "$BUILDER_A" ]; then
    echo "[$(human_now)] Running builder A…"
    PROFILE="$profile" TOTAL_SHARDS="$total" TARGET_COMPRESSED_MB="$size" \
    COMPRESSOR="$comp" COMPRESS_LEVEL="$level" \
      "$BUILDER_A"
    return $?
  elif [ -x "$BUILDER_B" ]; then
    echo "[$(human_now)] Running builder B…"
    PROFILE="$profile" TOTAL_SHARDS="$total" TARGET_COMPRESSED_MB="$size" \
    COMPRESSOR="$comp" COMPRESS_LEVEL="$level" \
      "$BUILDER_B"
    return $?
  else
    echo "[$(human_now)] No builder found in BODY."
    return 2
  fi
}

b64dec(){ python3 - <<PY
import sys,base64
print(base64.b64decode(sys.stdin.read()).decode('utf-8','ignore'))
PY
}

write_file(){
  local path="$1" mode="${2:-}"
  local tmp="$(mktemp)"
  b64dec > "$tmp"
  mkdir -p "$(dirname "$path")"
  mv "$tmp" "$path"
  if [ -z "$mode" ]; then
    [[ "$path" == *.sh ]] && chmod 755 "$path" || chmod 644 "$path"
  else
    chmod "$mode" "$path"
  fi
  echo "[$(human_now)] WROTE $path"
}

refresh_handshake(){
  local append_text="${1:-}"
  local doc="$DOCS/body_brain_builder.md"
  mkdir -p "$(dirname "$doc")"
  {
    echo "# AI Body/Brain Builder – Live Handshake"
    echo
    echo "Last Updated (UTC): $(human_now)"
    echo
    echo "## Codex"
    echo "- Role: job runner & scaffold writer"
    echo "- Queues: $JOBS"
    echo "- Output: $OUT"
    [ -n "$append_text" ] && { echo; echo "## Notes (appended)"; echo "$append_text"; }
    echo
    echo "## How to enqueue a job"
    echo "cat > \"$QUEUED/example.job\" <<'JOB'"; echo "ACTION=SHELL"; echo "CMD=echo hello"; echo "JOB"
  } > "$doc"
  echo "[$(human_now)] Handshake refreshed: $doc"
}

run_shell(){
  local cmd="$1" jid="$2"
  local of="$OUT/shell_${jid}_$(date +%H%M%S).out"
  ( set -o pipefail; bash -lc "$cmd" ) > "$of" 2>&1 || true
  echo "[$(human_now)] SHELL output -> $of"
}

verify_shards(){
  local rep="$OUT/verify_$(date +%Y%m%d_%H%M%S).txt"
  if [ -x "$BRAIN/scripts/verify_integrity.sh" ]; then
    "$BRAIN/scripts/verify_integrity.sh" | tee "$rep"
  else
    echo "verify_integrity.sh not found" | tee "$rep"
  fi
  echo "[$(human_now)] VERIFY report -> $rep"
}

process_job(){
  local jf="$1"
  local base="$(basename "$jf")"
  local jid="${base%.*}"
  echo "[$(human_now)] Processing $base"
  mv "$jf" "$RUNNING/$base" || return 1
  jf="$RUNNING/$base"

  # parse
  ACTION=""; NOTE=""
  PROFILE="ssd"; TOTAL_SHARDS="2"; TARGET_MB="256"; COMPRESSOR="auto"; COMPRESS_LEVEL="3"
  OUT_DIR=""; KIND=""; NAME=""; PATH_T=""; MODE_T=""; CONTENT_B64=""; APPEND_TEXT_B64=""; CMD=""

  while IFS='=' read -r k v; do
    [ -z "${k:-}" ] && continue
    case "$k" in
      ACTION) ACTION="$v" ;;
      NOTE) NOTE="$v" ;;
      PROFILE) PROFILE="$v" ;;
      TOTAL_SHARDS) TOTAL_SHARDS="$v" ;;
      TARGET_MB) TARGET_MB="$v" ;;
      COMPRESSOR) COMPRESSOR="$v" ;;
      COMPRESS_LEVEL) COMPRESS_LEVEL="$v" ;;
      OUT_DIR) OUT_DIR="$v" ;;
      KIND) KIND="$v" ;;
      NAME) NAME="$v" ;;
      PATH) PATH_T="$v" ;;
      MODE) MODE_T="$v" ;;
      CONTENT_B64) CONTENT_B64="$v" ;;
      APPEND_TEXT_B64) APPEND_TEXT_B64="$v" ;;
      CMD) CMD="$v" ;;
    esac
  done < "$jf"

  case "$ACTION" in
    BUILD_SHARDS)
      safe_run_builder "$PROFILE" "$TOTAL_SHARDS" "$TARGET_MB" "$COMPRESSOR" "$COMPRESS_LEVEL" && mv "$jf" "$DONE/$base" || mv "$jf" "$FAILED/$base"
      ;;
    HANDSHAKE)
      if [ -n "$APPEND_TEXT_B64" ]; then
        append="$(printf "%s" "$APPEND_TEXT_B64" | b64dec)"
        refresh_handshake "$append"
      else
        refresh_handshake
      fi
      mv "$jf" "$DONE/$base"
      ;;
    WRITE)
      if [ -z "$PATH_T" ] || [ -z "$CONTENT_B64" ]; then
        echo "Invalid WRITE job (PATH or CONTENT_B64 missing)"; mv "$jf" "$FAILED/$base"
      else
        printf "%s" "$CONTENT_B64" | write_file "$PATH_T" "$MODE_T"
        mv "$jf" "$DONE/$base"
      fi
      ;;
    SCAFFOLD)
      if [ -z "$OUT_DIR" ] || [ -z "$KIND" ]; then
        echo "Invalid SCAFFOLD job (OUT_DIR/KIND missing)"; mv "$jf" "$FAILED/$base"
      else
        bash "$SUB/scripts/scaffold.sh" "$KIND" "$OUT_DIR" "${NAME:-codex_proj}" && mv "$jf" "$DONE/$base" || mv "$jf" "$FAILED/$base"
      fi
      ;;
    SHELL)
      if [ -z "$CMD" ]; then
        echo "Invalid SHELL job (CMD missing)"; mv "$jf" "$FAILED/$base"
      else
        run_shell "$CMD" "$jid"; mv "$jf" "$DONE/$base"
      fi
      ;;
    VERIFY)
      verify_shards; mv "$jf" "$DONE/$base"
      ;;
    *)
      echo "Unknown ACTION: $ACTION"; mv "$jf" "$FAILED/$base"
      ;;
  esac
}

# main loop (bounded sleeps, no CPU spin)
STOP_FILE="$SUB/STOP"
while true; do
  [ -f "$STOP_FILE" ] && { echo "[$(human_now)] STOP file present. Exiting."; exit 0; }
  for jf in "$QUEUED"/*.job; do
    [ -e "$jf" ] || break
    process_job "$jf"
  done
  sleep 3
done