#!/usr/bin/env bash
# Shared companions: scripts/ci/run-release.sh scripts/ci/fixture-lifecycle.sh
set -euo pipefail

# Owner qualification: real commits/tags/pushes only in disposable repositories.
unset MAKEFLAGS MFLAGS MAKEOVERRIDES GNUMAKEFLAGS MAKEFILES
export RELEASE_DELIVERY=direct
ROOT="${BASH_SOURCE[0]}"
[[ "$ROOT" == /* ]] || ROOT="$PWD/$ROOT"
ROOT="$(cd -P "${ROOT%/*}/../.." && printf '%s/.' "$PWD")"
ROOT="${ROOT%/.}"
FIXTURE_ROOT="$(mktemp -d "${TMPDIR:-/tmp}/release-tracking-test.XXXXXX")"
FIXTURE_ROOT="$(CDPATH="" cd -P -- "$FIXTURE_ROOT" && printf '%s/.' "$PWD")"
FIXTURE_ROOT="${FIXTURE_ROOT%/.}"
# shellcheck source=scripts/ci/fixture-lifecycle.sh
source "$ROOT/scripts/ci/fixture-lifecycle.sh"
fixture_complete=false
trap 'fixture_finish "$?" "$FIXTURE_ROOT" "Failed release-tracking fixture retained"' EXIT
export REAL_GIT REAL_MAKE
REAL_GIT="$(command -v git)"
REAL_MAKE="$(command -v make)"

# Use native Git histories and bare destinations for tracking observation. Metadata
# and validation targets are deliberately inert: this qualifies Git, not a product.
TRACKING_ROOT="$FIXTURE_ROOT/real-tracking"
mkdir -p "$TRACKING_ROOT/bin"
cat > "$TRACKING_ROOT/bin/git" <<'GIT'
#!/usr/bin/env bash
set -euo pipefail
case "$1" in
    push)
        echo push >> "$TRACKING_EVENTS"
        [[ "${TRACKING_PUSH_FAIL:-}" != yes ]] || exit 9
        before_push="$("$REAL_GIT" show-ref --verify --hash "$TRACKING_SELECTED_REF" 2>/dev/null || :)"
        "$REAL_GIT" "$@"
        # Git versions can refresh a matching remote-tracking ref even when
        # the push uses its URL. Record that native effect independently of
        # the runner's explicit upstream-refresh callback.
        if [[ "${TRACKING_NATIVE_UPDATE:-}" == yes ]]; then
            "$REAL_GIT" update-ref "$TRACKING_SELECTED_REF" "$("$REAL_GIT" rev-parse HEAD)"
        fi
        # Fault/race cases must reach the explicit refresh callback even if
        # this Git already refreshed the ref. Recreate their stale checkpoint
        # at the transport boundary, entirely inside this disposable fixture.
        if [[ "${TRACKING_CALLBACK_CHECKPOINT:-}" == yes ]]; then
            if [[ -n "$before_push" ]]; then
                "$REAL_GIT" update-ref "$TRACKING_SELECTED_REF" "$before_push"
            else
                "$REAL_GIT" update-ref -d "$TRACKING_SELECTED_REF"
            fi
        fi
        "$REAL_GIT" show-ref --verify --hash "$TRACKING_SELECTED_REF" > "$TRACKING_EVENTS.after-push" || :
        if [[ "${TRACKING_PUSH_LOST:-}" == yes && ! -e "$TRACKING_EVENTS.lost" ]]; then
            touch "$TRACKING_EVENTS.lost"
            exit 9
        fi
        exit 0
        ;;
    update-ref)
        echo tracking >> "$TRACKING_EVENTS"
        [[ "${TRACKING_UPDATE_FAIL:-}" != yes ]] || exit 9
        if [[ -n "${TRACKING_RACE_OID:-}" && ! -e "$TRACKING_EVENTS.raced" ]]; then
            "$REAL_GIT" update-ref "$TRACKING_SELECTED_REF" "$TRACKING_RACE_OID"
            touch "$TRACKING_EVENTS.raced"
        fi
        if [[ "${TRACKING_SYMBOLIC_RACE:-}" == yes && ! -e "$TRACKING_EVENTS.raced" ]]; then
            "$REAL_GIT" symbolic-ref "$TRACKING_SELECTED_REF" refs/heads/preserved
            touch "$TRACKING_EVENTS.raced"
        fi
        ;;
    symbolic-ref)
        if [[ "${3:-}" == "${TRACKING_SELECTED_REF:-}" &&
            -e "$("$REAL_GIT" rev-parse --git-path "$TRACKING_SELECTED_REF.lock")" ]]; then
            [[ "${TRACKING_INSPECTION_FAIL:-}" != yes ]] || exit 128
            if [[ "${TRACKING_PREPARED_RACE:-}" == yes ]]; then
                if "$REAL_GIT" -c core.filesRefLockTimeout=0 symbolic-ref "$TRACKING_SELECTED_REF" refs/heads/preserved; then
                    echo symbolic-writer-accepted >> "$TRACKING_EVENTS"
                else
                    echo symbolic-writer-refused >> "$TRACKING_EVENTS"
                fi
            fi
        fi
        ;;
esac
exec "$REAL_GIT" "$@"
GIT
chmod +x "$TRACKING_ROOT/bin/git"
for tracking_case in normal completed-resume custom-map missing-ref no-upstream no-upstream-native-update other-remote other-branch fetch-destination symbolic newer divergent rejected-push lost-push update-failure update-race symbolic-race missing-symbolic-race prepared-symbolic-race inspection-failure; do
    (
        unset FIXTURE_DESTINATION FIXTURE_REMOTE_FAIL FIXTURE_PUSH_MUTATION
        unset TRACKING_PUSH_FAIL TRACKING_PUSH_LOST TRACKING_UPDATE_FAIL TRACKING_RACE_OID
        unset TRACKING_NATIVE_UPDATE
        unset TRACKING_CALLBACK_CHECKPOINT
        unset TRACKING_SYMBOLIC_RACE TRACKING_PREPARED_RACE TRACKING_INSPECTION_FAIL TRACKING_SELECTED_REF
        selected="$TRACKING_ROOT/$tracking_case"
        mkdir -p "$selected"
        "$REAL_GIT" init --quiet --bare "$selected/destination.git"
        "$REAL_GIT" init --quiet -b main "$selected/work"
        cd "$selected/work"
        "$REAL_GIT" config user.name 'Release fixture'
        "$REAL_GIT" config user.email 'fixture@example.invalid'
        printf '0.1.0\n' > version
        cat > Makefile <<'MAKE'
.PHONY: release-version release-preflight release-verify release-prepare-version release-prepared-check release-files release-commit-check release-committed-check release-tagged-check release-push-check
release-version:
	@cat version
release-prepare-version:
	@printf '%s\n' '$(RELEASE_VERSION)' > version
release-files:
	@printf 'version\0'
release-preflight release-verify release-prepared-check release-commit-check release-committed-check release-tagged-check release-push-check:
	@:
MAKE
        "$REAL_GIT" add Makefile version
        "$REAL_GIT" commit --quiet -m source
        source_head="$("$REAL_GIT" rev-parse HEAD)"
        "$REAL_GIT" remote add origin "$selected/destination.git"
        "$REAL_GIT" push --quiet --set-upstream origin main
        tracking_ref=refs/remotes/origin/main
        case "$tracking_case" in
            custom-map)
                "$REAL_GIT" config remote.origin.fetch '+refs/heads/main:refs/remotes/custom/main'
                tracking_ref=refs/remotes/custom/main
                "$REAL_GIT" update-ref "$tracking_ref" "$source_head"
                ;;
            missing-ref|missing-symbolic-race) "$REAL_GIT" update-ref -d "$tracking_ref" ;;
            no-upstream|no-upstream-native-update)
                "$REAL_GIT" config --unset branch.main.remote
                "$REAL_GIT" config --unset branch.main.merge
                ;;
            other-remote)
                "$REAL_GIT" remote add other "$selected/destination.git"
                "$REAL_GIT" config branch.main.remote other
                "$REAL_GIT" update-ref refs/remotes/other/main "$source_head"
                ;;
            other-branch)
                "$REAL_GIT" config branch.main.merge refs/heads/other
                "$REAL_GIT" update-ref refs/remotes/origin/other "$source_head"
                ;;
            fetch-destination)
                "$REAL_GIT" clone --quiet --bare "$selected/destination.git" "$selected/fetch.git"
                "$REAL_GIT" remote set-url origin "$selected/fetch.git"
                "$REAL_GIT" remote set-url --push origin "$selected/destination.git"
                ;;
            symbolic)
                "$REAL_GIT" branch preserved "$source_head"
                "$REAL_GIT" symbolic-ref "$tracking_ref" refs/heads/preserved
                ;;
        esac
        export TRACKING_EVENTS="$selected/events"
        export TRACKING_SELECTED_REF="$tracking_ref"
        : > "$TRACKING_EVENTS"
        export PATH="$TRACKING_ROOT/bin:$PATH"
        export RELEASE_MAKE="$REAL_MAKE"
        if [[ "$tracking_case" == no-upstream-native-update ]]; then export TRACKING_NATIVE_UPDATE=yes; fi
        case "$tracking_case" in
            update-failure|update-race|symbolic-race|missing-symbolic-race|prepared-symbolic-race|inspection-failure)
                export TRACKING_CALLBACK_CHECKPOINT=yes ;;
        esac
        if [[ "$tracking_case" == rejected-push ]]; then export TRACKING_PUSH_FAIL=yes; fi
        if [[ "$tracking_case" == lost-push ]]; then export TRACKING_PUSH_LOST=yes; fi
        if [[ "$tracking_case" == update-failure ]]; then export TRACKING_UPDATE_FAIL=yes; fi
        if [[ "$tracking_case" == inspection-failure ]]; then export TRACKING_INSPECTION_FAIL=yes; fi
        if [[ "$tracking_case" == symbolic-race || "$tracking_case" == prepared-symbolic-race ]]; then
            "$REAL_GIT" branch preserved "$source_head"
        fi
        if [[ "$tracking_case" == symbolic-race || "$tracking_case" == missing-symbolic-race ]]; then
            export TRACKING_SYMBOLIC_RACE=yes
        fi
        if [[ "$tracking_case" == prepared-symbolic-race ]]; then export TRACKING_PREPARED_RACE=yes; fi
        if [[ "$tracking_case" == update-race ]]; then
            TRACKING_RACE_OID="$(printf 'concurrent observation\n' | "$REAL_GIT" commit-tree "$("$REAL_GIT" rev-parse "HEAD^{tree}")" -p "$source_head")"
            export TRACKING_RACE_OID
        fi
        if [[ "$tracking_case" == rejected-push || "$tracking_case" == lost-push ]]; then
            if bash "$ROOT/scripts/ci/run-release.sh" patch origin main > "$selected/first.log" 2>&1; then
                echo "tracking fixture accepted failed/lost push: $tracking_case" >&2; exit 1
            fi
            if [[ "$tracking_case" == rejected-push ]]; then
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$source_head" ]] || exit 1
                [[ "$("$REAL_GIT" --git-dir="$selected/destination.git" rev-parse refs/heads/main)" == "$source_head" ]] || exit 1
            else
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$(cat "$TRACKING_EVENTS.after-push")" ]] || exit 1
            fi
            unset TRACKING_PUSH_FAIL TRACKING_PUSH_LOST
            bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > "$selected/resume.log" 2>&1
        else
            bash "$ROOT/scripts/ci/run-release.sh" patch origin main > "$selected/first.log" 2>&1
        fi
        release_head="$("$REAL_GIT" rev-parse HEAD)"
        [[ "$("$REAL_GIT" --git-dir="$selected/destination.git" rev-parse refs/heads/main)" == "$release_head" ]] || exit 1
        [[ "$(tail -n 1 .git/release-state/0.1.1.plan)" == complete ]] || exit 1
        case "$tracking_case" in
            no-upstream|no-upstream-native-update|other-remote|other-branch|fetch-destination|symbolic)
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$(cat "$TRACKING_EVENTS.after-push")" ]] || exit 1
                [[ "$(awk '$0 == "tracking" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 0 ]] || exit 1
                if [[ "$tracking_case" == symbolic ]]; then
                    [[ "$("$REAL_GIT" symbolic-ref "$tracking_ref")" == refs/heads/preserved ]] || exit 1
                    [[ "$("$REAL_GIT" rev-parse preserved)" == "$(cat "$TRACKING_EVENTS.after-push")" ]] || exit 1
                fi
                ;;
            update-race)
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$TRACKING_RACE_OID" ]] || exit 1
                [[ "$(awk '$0 == "push" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                ;;
            symbolic-race|missing-symbolic-race)
                [[ "$("$REAL_GIT" symbolic-ref "$tracking_ref")" == refs/heads/preserved ]] || exit 1
                if [[ "$tracking_case" == symbolic-race ]]; then
                    [[ "$("$REAL_GIT" rev-parse preserved)" == "$source_head" ]] || exit 1
                else
                    if "$REAL_GIT" show-ref --verify --quiet refs/heads/preserved; then exit 1; fi
                fi
                [[ ! -e "$("$REAL_GIT" rev-parse --git-path "$tracking_ref.lock")" ]] || exit 1
                bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > "$selected/resume.log" 2>&1
                [[ "$("$REAL_GIT" symbolic-ref "$tracking_ref")" == refs/heads/preserved ]] || exit 1
                [[ "$(awk '$0 == "push" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                ;;
            update-failure|inspection-failure)
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$source_head" ]] || exit 1
                [[ ! -e "$("$REAL_GIT" rev-parse --git-path "$tracking_ref.lock")" ]] || exit 1
                unset TRACKING_UPDATE_FAIL TRACKING_INSPECTION_FAIL
                bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > "$selected/resume.log" 2>&1
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$release_head" ]] || exit 1
                [[ "$(awk '$0 == "push" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                ;;
            completed-resume)
                "$REAL_GIT" update-ref "$tracking_ref" "$source_head"
                bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > "$selected/resume.log" 2>&1
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$release_head" ]] || exit 1
                [[ "$(awk '$0 == "push" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                ;;
            newer|divergent)
                tracking_parent="$release_head"
                [[ "$tracking_case" != divergent ]] || tracking_parent="$source_head"
                retained_head="$(printf 'retained observation\n' | "$REAL_GIT" commit-tree "$("$REAL_GIT" rev-parse "HEAD^{tree}")" -p "$tracking_parent")"
                "$REAL_GIT" update-ref "$tracking_ref" "$retained_head"
                bash "$ROOT/scripts/ci/run-release.sh" resume 0.1.1 origin main > "$selected/resume.log" 2>&1
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$retained_head" ]] || exit 1
                [[ "$(awk '$0 == "push" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                ;;
            *)
                [[ "$("$REAL_GIT" rev-parse "$tracking_ref")" == "$release_head" ]] || exit 1
                [[ "$("$REAL_GIT" rev-list --count "@{upstream}..HEAD")" == 0 ]] || exit 1
                if [[ "$tracking_case" == prepared-symbolic-race ]]; then
                    [[ "$("$REAL_GIT" rev-parse preserved)" == "$source_head" ]] || exit 1
                    [[ "$(awk '$0 == "symbolic-writer-refused" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                    if grep -q '^symbolic-writer-accepted$' "$TRACKING_EVENTS"; then exit 1; fi
                fi
                if [[ "$tracking_case" == custom-map ]]; then
                    [[ "$("$REAL_GIT" rev-parse refs/remotes/origin/main)" == "$source_head" ]] || exit 1
                fi
                if [[ "$tracking_case" == lost-push ]]; then
                    [[ "$(awk '$0 == "push" { count++ } END { print count+0 }' "$TRACKING_EVENTS")" == 1 ]] || exit 1
                fi
                ;;
        esac
        echo "real Git tracking fixture passed: $tracking_case"
    )
done

# Real Git admission of superseded local preparation; all effects stay in /tmp.
for phase in prepare stage staged commit tag push complete; do
for metadata in unchanged bumped bumped-undelivered; do
    (
        selected="$FIXTURE_ROOT/fresh-$phase-$metadata"
        mkdir -p "$selected"
        "$REAL_GIT" init --quiet --bare "$selected/destination.git"
        "$REAL_GIT" init --quiet -b main "$selected/work"
        cd "$selected/work"
        "$REAL_GIT" config user.name 'Release fixture'
        "$REAL_GIT" config user.email 'fixture@example.invalid'
        export RELEASE_RESTART_EVENTS="$selected/events"
        printf '0.6.3\n' > version
        cat > Makefile <<'MAKE'
.PHONY: release-version release-preflight release-verify release-prepare-version release-prepared-check release-files release-commit-check release-committed-check release-tagged-check release-push-check
release-version:
	@cat version
release-verify:
	@printf '%s\n' '$(RELEASE_SOURCE)' >> "$$RELEASE_RESTART_EVENTS"
	@test "$${RESTART_FAIL_VERIFY:-no}" != yes
release-prepare-version:
	@test "$${RESTART_FAIL_PREPARE:-no}" != yes
	@printf '%s\n' '$(RELEASE_VERSION)' > version
release-files:
	@printf 'version\0'
release-preflight release-prepared-check release-commit-check release-committed-check release-tagged-check release-push-check:
	@:
MAKE
        "$REAL_GIT" add Makefile version
        "$REAL_GIT" commit --quiet -m source
        old_source="$("$REAL_GIT" rev-parse HEAD)"
        "$REAL_GIT" remote add origin "$selected/destination.git"
        "$REAL_GIT" push --quiet --set-upstream origin main
        if RESTART_FAIL_PREPARE=yes bash "$ROOT/scripts/ci/run-release.sh" patch origin main > "$selected/interrupted.log" 2>&1; then exit 1; fi
        # Historical staging receipts are not the current index. Normal commands
        # must ignore them along with every other old phase and malformed plan.
        historical_phase="$phase"
        [[ "$phase" != staged ]] || historical_phase=stage
        awk -v phase="$historical_phase" -v staged="$phase" '
            NR == 10 && staged == "staged" { print "dddddddddddddddddddddddddddddddddddddddd"; next }
            NR == 11 { print phase; next }
            { print }
        ' .git/release-state/0.6.4.plan > "$selected/changed-plan"
        mv "$selected/changed-plan" .git/release-state/0.6.4.plan
        printf 'obsolete roster\n' > .git/release-state/0.6.4.plan.files
        printf 'invalid historical plan\n' > .git/release-state/0.1.0.plan
        mkdir .git/release-state/broken.plan
        cp .git/release-state/0.6.4.plan "$selected/saved-plan"
        cp "$RELEASE_RESTART_EVENTS" "$selected/saved-validation"
        printf 'retained build artifact\n' > "$selected/build.evidence"
        if [[ "$metadata" != unchanged ]]; then printf '0.6.4\n' > version; fi
        printf 'committed source fix\n' > fix
        "$REAL_GIT" add version fix
        "$REAL_GIT" commit --quiet -m 'Committed preparation disposition'
        current_source="$("$REAL_GIT" rev-parse HEAD)"
        if [[ "$metadata" == bumped-undelivered ]]; then
            # Publication may refer to this older candidate source while HEAD
            # has later fixes. No registry is contacted or publication claimed.
            published_source="$current_source"
            printf 'later source fix\n' > later-fix
            "$REAL_GIT" add later-fix
            "$REAL_GIT" commit --quiet -m 'Later committed source fix'
            current_source="$("$REAL_GIT" rev-parse HEAD)"
        fi
        next=0.6.4
        if [[ "$metadata" != unchanged ]]; then next=0.6.5; fi
        if [[ "$metadata" == bumped ]]; then
            # A separately delivered earlier tag remains exactly as recorded.
            "$REAL_GIT" tag -a v0.6.4 -m 'Manually finalized 0.6.4'
            "$REAL_GIT" push --quiet --atomic origin main refs/tags/v0.6.4
            old_tag="$("$REAL_GIT" rev-parse refs/tags/v0.6.4)"
        fi
        if RESTART_FAIL_VERIFY=yes bash "$ROOT/scripts/ci/run-release.sh" patch origin main > "$selected/failed-revalidation.log" 2>&1; then exit 1; fi
        [[ ! -e ".git/release-state/$next.plan" && ! -e ".git/release-state/$next.plan.files" ]] || exit 1
        if [[ "$next" != 0.6.4 ]]; then cmp "$selected/saved-plan" .git/release-state/0.6.4.plan; fi
        [[ "$("$REAL_GIT" rev-parse HEAD)" == "$current_source" ]] || exit 1
        if [[ "$metadata" == bumped-undelivered ]]; then
            [[ "$(cat version)" == 0.6.4 && "$(tail -n 1 .git/release-state/0.6.4.plan)" == "$historical_phase" ]] || exit 1
            [[ "$("$REAL_GIT" --git-dir="$selected/destination.git" rev-parse refs/heads/main)" == "$old_source" ]] || exit 1
            [[ -z "$("$REAL_GIT" tag --list v0.6.4)" && -z "$("$REAL_GIT" --git-dir="$selected/destination.git" tag --list v0.6.4)" ]] || exit 1
        fi
        bash "$ROOT/scripts/ci/run-release.sh" patch origin main > "$selected/released.log" 2>&1
        printf '%s\n' "$old_source" "$current_source" "$current_source" > "$selected/expected-validation"
        cmp "$selected/expected-validation" "$RELEASE_RESTART_EVENTS"
        [[ "$(cat version)" == "$next" && "$("$REAL_GIT" log -1 --format=%s)" == "Release $next" ]] || exit 1
        [[ "$("$REAL_GIT" --git-dir="$selected/destination.git" rev-parse refs/heads/main)" == "$("$REAL_GIT" rev-parse HEAD)" ]] || exit 1
        [[ "$("$REAL_GIT" --git-dir="$selected/destination.git" rev-parse "refs/tags/v$next")" == "$("$REAL_GIT" rev-parse "refs/tags/v$next")" ]] || exit 1
        [[ "$(tail -n 1 ".git/release-state/$next.plan")" == complete ]] || exit 1
        if [[ "$metadata" == bumped ]]; then
            [[ "$("$REAL_GIT" rev-parse refs/tags/v0.6.4)" == "$old_tag" ]] || exit 1
            [[ "$("$REAL_GIT" --git-dir="$selected/destination.git" rev-parse refs/tags/v0.6.4)" == "$old_tag" ]] || exit 1
        fi
        if [[ "$metadata" == bumped-undelivered ]]; then
            [[ -z "$("$REAL_GIT" tag --list v0.6.4)" && -z "$("$REAL_GIT" --git-dir="$selected/destination.git" tag --list v0.6.4)" ]] || exit 1
            "$REAL_GIT" merge-base --is-ancestor "$published_source" HEAD
            [[ "$(tail -n 1 .git/release-state/0.6.4.plan)" == "$historical_phase" ]] || exit 1
        fi
        if [[ "$next" != 0.6.4 ]]; then cmp "$selected/saved-plan" .git/release-state/0.6.4.plan; fi
        [[ -d .git/release-state/broken.plan && "$(cat .git/release-state/0.1.0.plan)" == 'invalid historical plan' ]] || exit 1
        [[ "$(cat "$selected/build.evidence")" == 'retained build artifact' ]] || exit 1
        echo "real Git fresh release fixture passed: $phase/$metadata"
    )
done
done

echo 'Native release tracking and recovery tests passed'
fixture_complete=true
