#!/usr/bin/env bash
# Regression tests for hooks/lib/run-plan-scan.mjs — the shared scan/classify/completion module behind
# the SessionStart hook, the statusline count, and `/run-plan status`. Covers, in one place:
#   • classify branches: self / orphan (dead owner) / live (alive owner) / legacy (no beacon)
#   • completion: field-count vs GIT-RECONCILE divergence — the Part-B fix (field under-counts; the
#     reconcile path recovers the true count). This is the load-bearing assertion: without it the
#     "numbers are OFF" fix is unverified.
#   • reconcile-FAILURE is flagged (reconciled:false), never silently shown as git-accurate.
#   • fixture coverage migrated from the retired test-run-plan-resume-detect.sh: completed→excluded,
#     lease-only-branch→ignored, foreign-branch-no-JSONL→ignored, malformed-JSONL→unreadable-not-crash,
#     empty PROJECTS→empty.
#   • CLI: --mode=count (integer, excludes live) and --mode=report (table).
# Run: bash test-run-plan-scan.sh (exit 0 = all pass).
set -uo pipefail
DIR="$(cd "$(dirname "$0")" && pwd)"
MOD="$DIR/lib/run-plan-scan.mjs"
PASS=0; FAIL=0
ok()  { PASS=$((PASS+1)); printf '  ok   %s\n' "$1"; }
bad() { FAIL=$((FAIL+1)); printf '  FAIL %s\n     %s\n' "$1" "$2"; }

SB=$(mktemp -d "${TMPDIR:-/tmp}/rps-test-XXXX")
export RUN_PLAN_RUN_DIR="$SB/run" RUN_PLAN_CLAUDE_PROJECTS="$SB/projects" RUN_PLAN_RESUME_PROJECTS="$SB/Projects"
mkdir -p "$RUN_PLAN_RUN_DIR" "$RUN_PLAN_CLAUDE_PROJECTS"
HOST=$(node -e 'console.log(require("os").hostname())')

# harness: prints JSON array of {slug,done,total,readable,reconciled,cls} from scanRuns.
# args: <self> <recon|field> [repoAbs]
cat > "$SB/harness.mjs" <<EOF
import { scanRuns } from '$MOD';
const self = process.argv[2] || '';
const recon = process.argv[3] === 'recon';
const repo = process.argv[4] || null;
const rows = scanRuns({ self, reconcile: recon, repoFilter: repo });
console.log(JSON.stringify(rows.map(r => ({
  slug: r.slug, done: r.done, total: r.total, readable: r.readable, reconciled: r.reconciled, cls: r.cls,
}))));
EOF
scan() { node "$SB/harness.mjs" "$@"; }
# field <json> <slug> <key> → prints the value for that slug's row (empty if absent)
field() { node -e 'const a=JSON.parse(process.argv[1]);const r=a.find(x=>x.slug===process.argv[2]);process.stdout.write(r?String(r[process.argv[3]]):"")' "$1" "$2" "$3"; }

mk_repo() {  # <name> → inits repo, returns nothing; sets REPO
  REPO="$SB/Projects/$1"; mkdir -p "$REPO/docs/plans"
  git -C "$REPO" init -q; git -C "$REPO" config user.email t@t; git -C "$REPO" config user.name t
  git -C "$REPO" config commit.gpgsign false
  echo base > "$REPO/f"; git -C "$REPO" add -A; git -C "$REPO" commit -qm init
}
plan() { printf '%s\n' "${@:2}" > "$1"; }  # <jsonlPath> <lines...>
owner() { printf '%s\n' "$2" > "$RUN_PLAN_RUN_DIR/$1.owner"; }
pidf()  { printf '%s\n' "$2" > "$RUN_PLAN_RUN_DIR/$1.pid"; }
live()  { touch "$RUN_PLAN_RUN_DIR/$1.live"; }

# ===========================================================================
# Fixture repo "main" — one repo, many integration branches, one per scenario.
# ===========================================================================
mk_repo main; MAIN="$REPO"
T_PEND='{"type":"task","id":"t1","status":"PENDING"}'
T_DONE='{"type":"task","id":"t2","status":"COMMITTED"}'

newslug() {  # <slug> <integration?yes> <jsonl lines...|SKIP>
  local slug="$1" mkbranch="$2"; shift 2
  [[ "$mkbranch" == yes ]] && git -C "$MAIN" branch "plan/$slug"
  [[ "$1" != SKIP ]] && plan "$MAIN/docs/plans/2026-06-27-$slug.jsonl" "$@"
}

newslug selfown  yes "$T_PEND" "$T_DONE"     # owner==self → self
newslug orphan   yes "$T_PEND" "$T_DONE"     # owner=other, dead pid → orphan
newslug alive    yes "$T_PEND" "$T_DONE"     # owner=other, alive pid → live
newslug legacyy  yes "$T_PEND" "$T_DONE"     # no beacon → legacy
newslug donerun  yes "$T_DONE" "$T_DONE"     # all done → excluded (complete)
newslug malf     yes 'not json {{{'          # malformed → unreadable, surfaced not crash
newslug foreign  yes SKIP                     # branch but no jsonl → ignored
# lease-only: a task branch but NO integration branch → ignored
git -C "$MAIN" branch 'plan/leasey--w1.t1'
plan "$MAIN/docs/plans/2026-06-27-leasey.jsonl" "$T_PEND"

# beacons
owner selfown sess-ME
owner orphan sess-OTHER; pidf orphan "$HOST 2147483647 0"; live orphan
sleep 300 & ALIVE_PID=$!
owner alive sess-OTHER; pidf alive "$HOST $ALIVE_PID"; live alive
# legacyy: no beacon at all

J=$(scan sess-ME field "$MAIN")

[[ "$(field "$J" selfown cls)" == self   ]] && ok "classify: owner==self → self"        || bad "self cls" "$J"
[[ "$(field "$J" orphan  cls)" == orphan ]] && ok "classify: dead owner → orphan"        || bad "orphan cls" "$J"
[[ "$(field "$J" alive   cls)" == live   ]] && ok "classify: alive owner → live"         || bad "alive cls" "$J"
[[ "$(field "$J" legacyy cls)" == legacy ]] && ok "classify: no beacon → legacy"         || bad "legacy cls" "$J"
[[ -z "$(field "$J" donerun cls)" ]] && ok "completed run excluded"                       || bad "done excluded" "$J"
[[ -z "$(field "$J" foreign cls)" ]] && ok "foreign branch (no jsonl) ignored"            || bad "foreign ignored" "$J"
[[ -z "$(field "$J" leasey cls)" ]]  && ok "lease-only branch ignored"                    || bad "lease ignored" "$J"
[[ "$(field "$J" malf readable)" == false ]] && ok "malformed jsonl → unreadable, surfaced not crash" || bad "malformed" "$J"
kill "$ALIVE_PID" 2>/dev/null

# ===========================================================================
# Divergence — the Part-B fix. Repo "div": t1 committed-to-git but PENDING-in-JSONL.
# field count UNDER-counts (done=0); git reconcile recovers it (done=1).
# ===========================================================================
mk_repo div; DIV="$REPO"
git -C "$DIV" checkout -q -b plan/div
echo a > "$DIV/a"; git -C "$DIV" add -A; git -C "$DIV" commit -qm 'feat(t1): land t1'
git -C "$DIV" checkout -q master 2>/dev/null || git -C "$DIV" checkout -q main 2>/dev/null || true
plan "$DIV/docs/plans/2026-06-27-div.jsonl" \
  '{"type":"task","id":"t1","status":"PENDING"}' \
  '{"type":"task","id":"t2","status":"PENDING"}'

JF=$(scan '' field "$DIV"); JR=$(scan '' recon "$DIV")
df=$(field "$JF" div done); dr=$(field "$JR" div done)
[[ "$df" == 0 ]] && ok "field count UNDER-counts committed-but-PENDING task (done=0)" || bad "field undercount" "got $df"
[[ "$dr" == 1 ]] && ok "git reconcile RECOVERS true count (done=1) — Part-B fix" || bad "reconcile recover" "got $dr from $JR"
[[ "$(field "$JR" div reconciled)" == true ]] && ok "reconciled flag true on success" || bad "reconciled flag" "$JR"

# reconcile FAILURE is flagged, not silently shown as accurate: point LIB at a broken path via a repo
# whose .git is removed mid-flight would be racy; instead assert the field-path row carries reconciled=null
# (reconcile not requested) so callers can distinguish "not reconciled" from "reconcile failed".
[[ "$(field "$JF" div reconciled)" == null ]] && ok "field-only path → reconciled=null (distinguishable)" || bad "reconciled null" "$JF"

# ===========================================================================
# CLI modes
# ===========================================================================
# count: --repo=DIV → div is incomplete, not live → counts 1
c=$(node "$MOD" --mode=count --repo="$DIV")
[[ "$c" == 1 ]] && ok "CLI --mode=count → integer, excludes complete/live (1)" || bad "cli count" "got '$c'"

# count on a repo with the alive run excluded: main has self+orphan+legacy+malf incomplete (4), alive excluded
sleep 300 & ALIVE_PID=$!
pidf alive "$HOST $ALIVE_PID"; live alive
cm=$(node "$MOD" --mode=count --repo="$MAIN")
[[ "$cm" == 4 ]] && ok "CLI count excludes live run (main=4)" || bad "cli count main" "got '$cm' (expect 4)"
kill "$ALIVE_PID" 2>/dev/null

# report: --repo=DIV → table with slug + progress reconciled
r=$(node "$MOD" --mode=report --repo="$DIV")
[[ "$r" == *"div"* && "$r" == *"reconciled vs git"* ]] && ok "CLI --mode=report → table, reconciled" || bad "cli report" "$r"

# report empty: a fresh repo with no plan branches → "No stalled"
mk_repo emptyrepo
re=$(node "$MOD" --mode=report --repo="$REPO")
[[ "$re" == *"No stalled"* ]] && ok "CLI report empty → 'No stalled'" || bad "cli report empty" "$re"

# empty PROJECTS scan → empty array
EMPTY=$(mktemp -d "${TMPDIR:-/tmp}/rps-empty-XXXX")
ee=$(RUN_PLAN_RESUME_PROJECTS="$EMPTY" node "$SB/harness.mjs" '' field)
rm -rf "$EMPTY"
[[ "$ee" == "[]" ]] && ok "empty PROJECTS → empty scan" || bad "empty scan" "$ee"

rm -rf "$SB"
echo
echo "PASS=$PASS FAIL=$FAIL"
[[ "$FAIL" -eq 0 ]]