#!/usr/bin/env bash
# scripts/run-shell-tests.sh — run the repository's shell test suite.
#
# WHY THIS EXISTS
#
# The enumeration used to live inline in .github/workflows/ci.yml as two
# near-identical ~40-line bash blocks embedded in YAML. That had one
# consequence that cost real time: **there was no way to run what CI runs
# without pushing.** `make check`, documented as the "full pre-PR gate", ran
# cargo only — build, test, clippy, deny — and none of the 190 shell tests,
# which are the ones that catch this repo's actual defect classes.
#
# Measured 2026-08-08: the CI step takes 243s plus queue and checkout, while
# the static guards complete locally in about 5 seconds. Two PRs that day were
# turned red by tests/test_pipefail_early_exit_guard.sh — both times correctly,
# and both times only after a full CI cycle had been spent to say so.
#
# So the enumeration lives here, both CI and the Makefile call it, and local
# and CI cannot enumerate different sets. That property is the point: a local
# gate running a *different* set than CI is how "green locally, red in CI"
# happens, which is the problem this replaces rather than a new form of it.
#
# Usage:
#   scripts/run-shell-tests.sh              # everything (plain-bash + bats)
#   scripts/run-shell-tests.sh --plain      # plain-bash only
#   scripts/run-shell-tests.sh --bats       # bats only
#   scripts/run-shell-tests.sh --list       # print the resolved sets, run nothing

set -uo pipefail

REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
cd "$REPO_ROOT" || exit 1

# ---------------------------------------------------------------------------
# Skip lists. These are data, deliberately kept beside the runner rather than
# in workflow YAML — when a local run skips something, the reason has to be
# readable from the repo.
#
# Every entry must name a file that exists. A stale exclusion is worse than no
# exclusion: it silently protects nothing while reading as a known issue, and
# the next person cannot tell the difference. The guard below fails the run.
# ---------------------------------------------------------------------------

# Needs a local HTTP fallback server that CI does not provide. Every other
# plain-bash test either passes or self-SKIPs (exit 0) when a live
# prerequisite is absent — a <domain> argument, a running edge, a locally
# built Docker image, a reachable daemon, or the opec binary.
PLAIN_SKIP="test_update_sh.sh"

# Whole-file skips for pre-existing assertion drift on main:
#   test_hydrate_render_identical.sh — Caddyfile upstream refactored from
#     `10.9.0.2:8907 host.docker.internal:18443` to `xray-client:3080`;
#     fixture never updated.
#   test_install_opec_parity.sh — install.sh's `render_with_opec xray` call
#     site was removed during OPEC Phase 3 absorb; the assertion is stale.
#   test_release_assets.sh — release.yml's uninstall.sh staging path changed;
#     the test still asserts the old pattern.
BATS_SKIP="test_hydrate_render_identical.sh test_install_opec_parity.sh test_release_assets.sh"

mode="all"
native=0
for arg in "$@"; do
    case "$arg" in
        --plain)  mode="plain" ;;
        --bats)   mode="bats" ;;
        --list)   mode="list" ;;
        --all)    mode="all" ;;
        --native) native=1 ;;
        *) echo "usage: $0 [--plain|--bats|--list|--all] [--native]" >&2; exit 2 ;;
    esac
done

# ---------------------------------------------------------------------------
# Platform gate.
#
# The suite targets Linux edges and assumes GNU userland. Measured 2026-08-08:
# the same commit scores 133/134 on the ubuntu runner and 107/134 on macOS, the
# 27 differences being BSD-vs-GNU flag handling rather than defects. A gate that
# reports 27 phantom failures is worse than no gate — it teaches people to read
# red as normal, which is how a real failure gets waved through.
#
# So off Linux this re-runs itself inside the CI image instead of guessing. If
# that is impossible it exits NON-ZERO and says why. It never emits a verdict it
# cannot stand behind: no silent skip, no partial pass, no green for "could not
# check". --native forces the local run for someone who knows the difference.
# ---------------------------------------------------------------------------
if [ "$mode" != "list" ] && [ "$native" -eq 0 ] && [ "$(uname -s)" != "Linux" ]; then
    cat >&2 <<EOF
ERROR: this suite needs a Linux userland, and this is $(uname -s).

  Measured 2026-08-08: the same commit scores 133/134 on the ubuntu runner and
  107/134 here. The 27 differences are BSD-vs-GNU flag handling, not defects.
  A gate that reports 27 phantom failures is worse than no gate — it teaches
  people to read red as normal, which is how a real failure gets waved through.

  So this refuses rather than emitting a verdict it cannot stand behind.

  Your options:
    - run it on Linux (krolik has the repo at ~/src/oxpulse-partner-edge)
    - '$0 --native' to see the local result, knowing it is
      informational and NOT a gate
    - push and read CI

  Making the suite portable is tracked separately; see the issue linked from
  the Makefile's check-sh target.
EOF
    exit 1
fi

# Read the shebang without a pipeline. The inline CI version spelled this
# as a shebang read piped into an early-exiting matcher, which is a latent
# misclassification under
# `set -o pipefail`: grep -q exits on its match, head takes SIGPIPE, the
# pipeline reports non-zero, and a bats file is then run as plain bash. It
# survived because head usually finishes first — a race, not a guarantee.
_is_bats() {
    local first=""
    IFS= read -r first < "$1" 2>/dev/null || true
    [[ "$first" =~ ^#!.*[^[:alnum:]_]bats([^[:alnum:]_]|$) ]]
}
_skipped() { case " $2 " in *" $1 "*) return 0 ;; *) return 1 ;; esac; }

# Fail on a stale exclusion before running anything.
for entry in $PLAIN_SKIP $BATS_SKIP; do
    if [ ! -f "tests/$entry" ]; then
        echo "ERROR: skip-list entry 'tests/$entry' does not exist — remove the stale exclusion" >&2
        exit 1
    fi
done

if [ "$mode" = "list" ]; then
    echo "plain-bash:"
    for f in tests/test_*.sh; do
        _is_bats "$f" && continue
        n=$(basename "$f"); _skipped "$n" "$PLAIN_SKIP" && { echo "  SKIP $n"; continue; }
        echo "  $n"
    done
    echo "bats:"
    for f in tests/test_*.sh; do
        _is_bats "$f" || continue
        n=$(basename "$f"); _skipped "$n" "$BATS_SKIP" && { echo "  SKIP $n"; continue; }
        echo "  $n"
    done
    exit 0
fi

overall=0

run_plain() {
    local pass=0 fail=0 f n
    for f in tests/test_*.sh; do
        _is_bats "$f" && continue
        n=$(basename "$f")
        if _skipped "$n" "$PLAIN_SKIP"; then echo "SKIP (excluded): $n"; continue; fi
        echo "--- $n ---"
        if bash "$f"; then pass=$((pass + 1)); else echo "FAILED: $n" >&2; fail=$((fail + 1)); fi
    done
    echo
    echo "Plain-bash: PASS=$pass FAIL=$fail"
    [ "$fail" -eq 0 ] || overall=1
}

run_bats() {
    local pass=0 fail=0 f n
    if ! command -v bats >/dev/null 2>&1; then
        # Loud, and non-zero. A silent skip here would let a local `make check`
        # report success having run none of the bats files — the false-green
        # shape this runner exists to remove.
        echo "ERROR: bats is not installed — install it or run with --plain" >&2
        echo "  macOS: brew install bats-core     Debian/Ubuntu: apt-get install bats" >&2
        return 1
    fi
    for f in tests/test_*.sh; do
        _is_bats "$f" || continue
        n=$(basename "$f")
        if _skipped "$n" "$BATS_SKIP"; then echo "SKIP (excluded): $n"; continue; fi
        echo "--- $n ---"
        if bats "$f"; then pass=$((pass + 1)); else fail=$((fail + 1)); fi
    done
    echo
    echo "Bats: PASS=$pass FAIL=$fail"
    [ "$fail" -eq 0 ] || overall=1
}

case "$mode" in
    plain) run_plain || overall=1 ;;
    bats)  run_bats  || overall=1 ;;
    all)   run_plain || overall=1; run_bats || overall=1 ;;
esac

exit "$overall"