#!/usr/bin/env bash
# Behavioural tests for scripts/revision-preflight.sh
#
# Every case builds a throwaway clone with a real bare remote, so origin/master
# is genuine and the guard's fetch path is exercised. Nothing outside mktemp is
# touched.
#
# The pre-fix draft is kept at tests/fixtures/revision-preflight.prefix.sh and
# is run against the SAME cases, to prove these tests bite: the pre-fix guard
# exits 0 where the fixed guard exits 1.

set -uo pipefail

HERE="$(cd "$(dirname "$0")" && pwd)"
REPO="$(cd "$HERE/.." && pwd)"
GUARD="$REPO/scripts/revision-preflight.sh"
PREFIX_GUARD="$HERE/fixtures/revision-preflight.prefix.sh"

PASS=0
FAIL=0
FAILED_CASES=()

pass() { printf '  ✓ %s\n' "$1"; PASS=$((PASS + 1)); }
fail() { printf '  ✗ %s\n' "$1"; FAIL=$((FAIL + 1)); FAILED_CASES+=("$1"); }

# Build a clone with a real remote; echo the clone path.
make_clone() {
    local tmp
    tmp="$(mktemp -d)"
    git init --bare -q "$tmp/remote.git"
    git init -q "$tmp/clone"
    (
        cd "$tmp/clone" || exit 1
        git config user.email test@example.invalid
        git config user.name test
        mkdir -p scripts
        printf '#!/bin/bash\necho hello\n' > scripts/demo.sh
        chmod +x scripts/demo.sh
        git add -A
        git commit -qm init
        git branch -M master
        git remote add origin "$tmp/remote.git"
        git push -q origin master
        git fetch -q origin
    )
    echo "$tmp/clone"
}

echo "== revision-preflight behavioural tests =="

# ── 1. match → exit 0 ────────────────────────────────────────────────────────
echo "1. matching copy"
C=$(make_clone)
if out=$("$GUARD" "$C/scripts/demo.sh" "$C" 2>&1); then
    pass "matching copy exits 0"
else
    fail "matching copy should exit 0 (got $?, output: $out)"
fi
if [[ -z "$( "$GUARD" --quiet "$C/scripts/demo.sh" "$C" 2>&1 )" ]]; then
    pass "--quiet prints nothing on a match"
else
    fail "--quiet should print nothing on a match"
fi
rm -rf "$(dirname "$C")"

# ── 2. mismatch → exit 1 and names both hashes ───────────────────────────────
echo "2. mismatched copy"
C=$(make_clone)
printf '#!/bin/bash\necho TAMPERED\n' > "$C/scripts/demo.sh"
out=$("$GUARD" "$C/scripts/demo.sh" "$C" 2>&1); rc=$?
if [[ $rc -eq 1 ]]; then pass "mismatch exits 1"; else fail "mismatch should exit 1 (got $rc)"; fi
if [[ "$out" == *"MISMATCH"* ]]; then pass "mismatch says MISMATCH"; else fail "mismatch should say MISMATCH"; fi
if [[ "$out" == *"executed:"* && "$out" == *"merged:"* ]]; then
    pass "mismatch prints both revisions"
else
    fail "mismatch should print both revisions"
fi
rm -rf "$(dirname "$C")"

# ── 3. paths under scripts/ resolve (the original basename defect) ───────────
echo "3. repo-relative path resolution"
C=$(make_clone)
if "$GUARD" --quiet "$C/scripts/demo.sh" "$C" >/dev/null 2>&1; then
    pass "script under scripts/ resolves against origin/master"
else
    fail "script under scripts/ must resolve (basename defect)"
fi
rm -rf "$(dirname "$C")"

# ── 4. script that exists in NO revision → must fail ─────────────────────────
echo "4. untracked script present in no revision"
C=$(make_clone)
printf '#!/bin/bash\necho never committed\n' > "$C/scripts/ghost.sh"
out=$("$GUARD" "$C/scripts/ghost.sh" "$C" 2>&1); rc=$?
if [[ $rc -eq 1 ]]; then pass "ghost script exits 1"; else fail "ghost script must exit 1 (got $rc)"; fi
if [[ "$out" == *"does not exist in"* ]]; then
    pass "ghost script says it is absent from the ref"
else
    fail "ghost script should say it is absent from the ref"
fi
rm -rf "$(dirname "$C")"

# ── 5. unresolvable ref → must fail ──────────────────────────────────────────
echo "5. unresolvable ref"
C=$(make_clone)
out=$("$GUARD" --no-fetch --ref origin/nope "$C/scripts/demo.sh" "$C" 2>&1); rc=$?
if [[ $rc -eq 1 ]]; then pass "unresolvable ref exits 1"; else fail "unresolvable ref must exit 1 (got $rc)"; fi
rm -rf "$(dirname "$C")"

# ── 6. missing script → must fail ────────────────────────────────────────────
echo "6. missing script"
C=$(make_clone)
out=$("$GUARD" "$C/scripts/nope.sh" "$C" 2>&1); rc=$?
if [[ $rc -eq 1 ]]; then pass "missing script exits 1"; else fail "missing script must exit 1 (got $rc)"; fi
rm -rf "$(dirname "$C")"

# ── 7. script outside the clone → must fail ──────────────────────────────────
echo "7. script outside the clone"
C=$(make_clone)
OUTSIDE=$(mktemp)
printf '#!/bin/bash\necho outside\n' > "$OUTSIDE"
out=$("$GUARD" "$OUTSIDE" "$C" 2>&1); rc=$?
if [[ $rc -eq 1 ]]; then pass "outside script exits 1"; else fail "outside script must exit 1 (got $rc)"; fi
rm -f "$OUTSIDE"; rm -rf "$(dirname "$C")"

# ── 8. --no-fetch states the freshness assumption ────────────────────────────
echo "8. --no-fetch states its assumption"
C=$(make_clone)
out=$("$GUARD" --no-fetch "$C/scripts/demo.sh" "$C" 2>&1)
if [[ "$out" == *"freshness is assumed"* ]]; then
    pass "--no-fetch states the freshness assumption"
else
    fail "--no-fetch should state the freshness assumption"
fi
rm -rf "$(dirname "$C")"

# ── 9. the pre-fix guard must FAIL these same cases (proves the tests bite) ──
echo "9. pre-fix draft fails the same cases (bite proof)"
if [[ ! -f "$PREFIX_GUARD" ]]; then
    fail "pre-fix fixture missing: $PREFIX_GUARD"
else
    # 9a. repo-relative path: pre-fix drops scripts/ and cannot resolve
    C=$(make_clone)
    out=$("$PREFIX_GUARD" "$C/scripts/demo.sh" "$C" 2>&1); rc=$?
    if [[ $rc -eq 0 && "$out" == *"could not resolve"* ]]; then
        pass "pre-fix: exits 0 and cannot resolve scripts/demo.sh (defect confirmed)"
    else
        fail "pre-fix should exit 0 with 'could not resolve' (got rc=$rc)"
    fi
    rm -rf "$(dirname "$C")"

    # 9b. ghost script: pre-fix passes a script that exists in no revision
    C=$(make_clone)
    printf '#!/bin/bash\necho never committed\n' > "$C/scripts/ghost.sh"
    out=$("$PREFIX_GUARD" "$C/scripts/ghost.sh" "$C" 2>&1); rc=$?
    if [[ $rc -eq 0 ]]; then
        pass "pre-fix: PASSES a ghost script that exists in no revision (defect confirmed)"
    else
        fail "pre-fix was expected to wrongly pass the ghost script (got rc=$rc)"
    fi
    rm -rf "$(dirname "$C")"

    # 9c. a file that DOES exist at the repo root still works pre-fix, showing
    #     the defect is specific to nested paths
    C=$(make_clone)
    printf '#!/bin/bash\necho root\n' > "$C/rootlevel.sh"
    ( cd "$C" && git add rootlevel.sh && git commit -qm root && git push -q origin master && git fetch -q origin )
    if "$PREFIX_GUARD" "$C/rootlevel.sh" "$C" >/dev/null 2>&1; then
        pass "pre-fix: root-level path resolves (so the defect is the basename, not git)"
    else
        fail "pre-fix should resolve a root-level tracked file"
    fi
    rm -rf "$(dirname "$C")"
fi

echo
echo "  passed: $PASS   failed: $FAIL"
if [[ $FAIL -gt 0 ]]; then
    printf '  FAILED: %s\n' "${FAILED_CASES[@]}"
    exit 1
fi
echo "All revision-preflight tests passed."