#!/usr/bin/env bash
# Shared companions: make/tools.mk scripts/ci/fixture-lifecycle.sh scripts/ci/check-pipe-jobserver.pl scripts/ci/prepare-script-fixture.sh
set -euo pipefail
path_context=false
if [[ "${1:-}" == --path-context && $# == 1 ]]; then path_context=true;
elif [[ $# != 0 ]]; then echo 'usage: fixture [--path-context]' >&2; exit 2; fi

ROOT="$0"
[[ "$ROOT" == /* ]] || ROOT="$PWD/$ROOT"
ROOT="$(cd -P "${ROOT%/*}/../.." && printf '%s/.' "$PWD")"
ROOT="${ROOT%/.}"
fixture="$(mktemp -d "${TMPDIR:-/tmp}/shared-tool-commands.XXXXXX")"
fixture="$(CDPATH="" cd -P -- "$fixture" && printf '%s/.' "$PWD")"
fixture="${fixture%/.}"
# shellcheck source=scripts/ci/fixture-lifecycle.sh
source "$ROOT/scripts/ci/fixture-lifecycle.sh"
fixture_complete=false
trap 'fixture_finish "$?" "$fixture" "Failed tool command fixture retained"' EXIT
unset MAKEFLAGS MFLAGS MAKEOVERRIDES GNUMAKEFLAGS MAKEFILES
consumer="$fixture/consumer with spaces"
snapshot="$consumer/vendor/toko-tooling"
mkdir -p "$snapshot/make" "$snapshot/scripts/dev" "$consumer/.tools/host/bin" "$consumer/.tools/ic/bin"
cp "$ROOT/make/tools.mk" "$ROOT/make/execution.mk" "$snapshot/make/"
mkdir -p "$snapshot/scripts/ci"
cp "$ROOT/scripts/ci/check-make-execution.sh" "$snapshot/scripts/ci/"
export TOOL_COMMAND_LOG="$fixture/commands"
export TOOL_COMMAND_CONSUMER="$consumer"
export JOBSERVER_PROBE="$ROOT/scripts/ci/check-pipe-jobserver.pl"
cat > "$fixture/tool-stub" <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
if [[ "${JOBSERVER_TEST_REQUIRED:-0}" == 1 && "${0##*/}" == install-rust-tools.sh ]]; then
    perl "$JOBSERVER_PROBE"
fi
name="${0##*/}"
printf '%s' "$name" >> "$TOOL_COMMAND_LOG"
printf ' <%s>' "$@" >> "$TOOL_COMMAND_LOG"
printf '\n' >> "$TOOL_COMMAND_LOG"
[[ "$PATH" == "$TOOL_COMMAND_CONSUMER/.tools/host/bin:$TOOL_COMMAND_CONSUMER/.tools/rust/common/bin:"* ]] || exit 1
if [[ "${!#}" == --preflight ]]; then
    [[ "${TOOL_COMMAND_PREFLIGHT_FAIL:-}" != "$name" ]] || exit 24
    exit 0
fi
if [[ "${TOOL_COMMAND_FAIL:-}" == "$name" ]]; then exit 23; fi
SCRIPT
for tool in install-host-tools.sh install-ic-tools.sh install-rust-tools.sh; do
    cp "$fixture/tool-stub" "$snapshot/scripts/dev/$tool"
done
cat > "$consumer/Makefile" <<'MAKE'
TOKO_TOOLING_ROOT := $(CURDIR)/vendor/toko-tooling
include vendor/toko-tooling/make/tools.mk
.PHONY: help
help:
	@echo consumer help
MAKE
# Including common commands must not make bare `make` install anything.
[[ "$(make --no-print-directory -C "$consumer")" == 'consumer help' ]] || exit 1
[[ ! -e "$TOOL_COMMAND_LOG" ]] || exit 1

make --no-print-directory -j4 -C "$consumer" install-tools > "$fixture/install.log" 2>&1
cat > "$fixture/expected" <<EOF
install-rust-tools.sh <--consumer> <$consumer> <--versions> <$snapshot/ci/tool-versions.env> <--preflight>
install-host-tools.sh <--consumer> <$consumer> <--versions> <$snapshot/ci/tool-versions.env>
install-rust-tools.sh <--consumer> <$consumer> <--versions> <$snapshot/ci/tool-versions.env>
EOF
cmp "$fixture/expected" "$TOOL_COMMAND_LOG"

: > "$TOOL_COMMAND_LOG"
make --no-print-directory -j4 -C "$consumer" tools-check \
    HOST_TOOL_VERSIONS="$consumer/reviewed host pins.env" IC_TOOL_PINS="$consumer/reviewed IC pins.tsv" \
    > "$fixture/check.log" 2>&1
cat > "$fixture/expected" <<EOF
install-host-tools.sh <--consumer> <$consumer> <--versions> <$consumer/reviewed host pins.env> <--check>
install-rust-tools.sh <--consumer> <$consumer> <--versions> <$snapshot/ci/tool-versions.env> <--check>
EOF
cmp "$fixture/expected" "$TOOL_COMMAND_LOG"

if [[ "$path_context" == true ]]; then
    : > "$TOOL_COMMAND_LOG"
    status=0
    TOOL_COMMAND_FAIL=install-host-tools.sh make --no-print-directory -C "$consumer" tools-check > "$fixture/failed.log" 2>&1 || status=$?
    [[ "$status" != 0 && "$(wc -l < "$TOOL_COMMAND_LOG" | tr -d ' ')" == 1 ]] || exit 1
    fixture_complete=true
    echo 'Make path-context dispatch, checks and failure propagation passed'
    exit 0
fi

# IC setup/check forwards the consumer's explicit executable selection.
for target in install-ic-tools ic-tools-check; do
    : > "$TOOL_COMMAND_LOG"
    make --no-print-directory -C "$consumer" "$target" IC_TOOLS='wasm-opt ic-wasm' \
        > "$fixture/$target-selection.log" 2>&1
    expected="install-ic-tools.sh <--consumer> <$consumer> <--pins> <$snapshot/ci/ic-tools.tsv> <--tool> <wasm-opt> <--tool> <ic-wasm>"
    [[ "$target" != ic-tools-check ]] || expected+=' <--check>'
    printf '%s\n' "$expected" > "$fixture/expected"
    cmp "$fixture/expected" "$TOOL_COMMAND_LOG"
done

# Every common failure stops the ordered aggregate, including under parallel Make.
for target in install-tools tools-check; do
  count=0
  [[ "$target" != install-tools ]] || count=1
  for failed in install-host-tools.sh install-rust-tools.sh; do
    count=$((count + 1))
    : > "$TOOL_COMMAND_LOG"
    if TOOL_COMMAND_FAIL="$failed" make --no-print-directory -j4 -C "$consumer" "$target" \
        > "$fixture/$target-failed.log" 2>&1; then
        echo "accepted failed common step: $target ($failed)" >&2; exit 1
    fi
    [[ "$(wc -l < "$TOOL_COMMAND_LOG" | tr -d ' ')" == "$count" ]] || exit 1
  done
done

: > "$TOOL_COMMAND_LOG"
if make --no-print-directory -C "$consumer" cloc > "$fixture/retired-cloc.log" 2>&1; then
    echo 'retired make cloc target remains available' >&2; exit 1
fi

# Standalone tools.mk consumers get both valid jobserver descriptors and the
# existing execution admission guard. Probe the aggregate/preflight and direct
# Rust routes, then refuse unsafe modes before any substituted installer runs.
parallel=(-j4)
if make --help | grep -q -- --jobserver-style; then parallel+=(--jobserver-style=pipe); fi
for target in install-tools tools-check install-rust-tools rust-tools-check; do
    JOBSERVER_TEST_REQUIRED=1 make "${parallel[@]}" --no-print-directory -C "$consumer" "$target" \
        > "$fixture/jobserver-$target.log" 2>&1
    for mode in -n -t -q -i --dry-run --touch --question --ignore-errors; do
        for source in direct inherited cleared hidden; do
            : > "$TOOL_COMMAND_LOG"
            status=0
            if [[ "$source" == inherited ]]; then
                MAKEFLAGS="$mode" make -C "$consumer" "$target" > "$fixture/unsafe.log" 2>&1 || status=$?
            else
                flags=(--no-print-directory)
                [[ "$source" != cleared && "$source" != hidden ]] || flags+=(MAKEFLAGS=)
                [[ "$source" != hidden ]] || flags+=(MFLAGS=)
                make -C "$consumer" "$mode" "$target" "${flags[@]}" > "$fixture/unsafe.log" 2>&1 || status=$?
            fi
            [[ "$status" == 2 && ! -s "$TOOL_COMMAND_LOG" ]] || exit 1
        done
    done
done

# Product tools extend the ordered recipe rather than racing as prerequisites.
cat >> "$consumer/Makefile" <<'MAKE'
LOCAL_TOOL_INSTALL_TARGETS += install-product install-second
LOCAL_TOOL_CHECK_TARGETS += check-product check-second
.PHONY: install-product install-second check-product check-second
install-product install-second check-product check-second:
	@printf '%s\n' '$@' >> "$(TOOL_COMMAND_LOG)"
	@test "$(TOOL_COMMAND_FAIL)" != '$@'
MAKE
: > "$TOOL_COMMAND_LOG"
make --no-print-directory -j4 -C "$consumer" install-tools > "$fixture/rust-install.log" 2>&1
[[ "$(sed -n '3p' "$TOOL_COMMAND_LOG")" == "install-rust-tools.sh <--consumer> <$consumer> <--versions> <$snapshot/ci/tool-versions.env>" ]] || exit 1
printf 'install-product\ninstall-second\n' > "$fixture/product-expected"
tail -2 "$TOOL_COMMAND_LOG" > "$fixture/product-actual"
cmp "$fixture/product-expected" "$fixture/product-actual"
: > "$TOOL_COMMAND_LOG"
make --no-print-directory -j4 -C "$consumer" tools-check RUST_TOOL_VERSIONS="$consumer/rust pins.env" > "$fixture/rust-check.log" 2>&1
[[ "$(sed -n '2p' "$TOOL_COMMAND_LOG")" == "install-rust-tools.sh <--consumer> <$consumer> <--versions> <$consumer/rust pins.env> <--check>" ]] || exit 1
printf 'check-product\ncheck-second\n' > "$fixture/product-expected"
tail -2 "$TOOL_COMMAND_LOG" > "$fixture/product-actual"
cmp "$fixture/product-expected" "$fixture/product-actual"
for target in install-tools tools-check; do
    phase=install; [[ "$target" != tools-check ]] || phase=check
    for failed in install-rust-tools.sh "$phase-product" "$phase-second"; do
        : > "$TOOL_COMMAND_LOG"
        if TOOL_COMMAND_FAIL="$failed" make --no-print-directory -j4 -C "$consumer" "$target" \
            > "$fixture/product-failure.log" 2>&1; then exit 1; fi
        case "$failed" in
            install-rust-tools.sh) expected_count=2 ;;
            *-product) expected_count=3 ;;
            *-second) expected_count=4 ;;
        esac
        [[ "$target" != install-tools ]] || expected_count=$((expected_count + 1))
        [[ "$(wc -l < "$TOOL_COMMAND_LOG" | tr -d ' ')" == "$expected_count" ]] || exit 1
    done
done
# Common Rust preflight failure cannot reach installation or product extensions.
: > "$TOOL_COMMAND_LOG"
if TOOL_COMMAND_PREFLIGHT_FAIL=install-rust-tools.sh make --no-print-directory -j4 -C "$consumer" install-tools \
    > "$fixture/preflight-failure.log" 2>&1; then exit 1; fi
if grep -v '<--preflight>$' "$TOOL_COMMAND_LOG"; then exit 1; fi
# Keep later default-goal comparison on its current command record.
cp "$TOOL_COMMAND_LOG" "$fixture/expected"

# A fixture-owned gate composes actual shared recipes and script substitutes;
# it never appends a second recipe for a shared or production-owned target.
cat >> "$consumer/Makefile" <<'MAKE'
.PHONY: fixture-qualify fixture-ci
fixture-qualify:
	+@$(MAKE) --no-print-directory install-tools
	+@$(MAKE) --no-print-directory fixture-ci
fixture-ci:
	+@$(MAKE) --no-print-directory tools-check
	@echo gate >> "$(TOOL_COMMAND_LOG)"
	@test "$(TOOL_COMMAND_FAIL)" != gate
MAKE
for failed in '' install-product check-product gate; do
    : > "$TOOL_COMMAND_LOG"
    status=0
    TOOL_COMMAND_FAIL="$failed" make --no-print-directory -j4 -C "$consumer" fixture-qualify \
        > "$fixture/qualification.log" 2>&1 || status=$?
    if [[ -z "$failed" ]]; then
        [[ "$status" == 0 && "$(tail -1 "$TOOL_COMMAND_LOG")" == gate ]]
    else
        [[ "$status" != 0 && "$(tail -1 "$TOOL_COMMAND_LOG")" == "$failed" ]]
    fi
    if grep -E 'overriding recipe|ignoring old recipe' "$fixture/qualification.log"; then exit 1; fi
done
cp "$TOOL_COMMAND_LOG" "$fixture/expected"

# An explicitly selected default goal remains unchanged too.
printf '.DEFAULT_GOAL := help\n' > "$fixture/prefixed.mk"
cat "$consumer/Makefile" >> "$fixture/prefixed.mk"
cp "$fixture/prefixed.mk" "$consumer/Makefile"
[[ "$(make --no-print-directory -C "$consumer")" == 'consumer help' ]] || exit 1
cmp "$fixture/expected" "$TOOL_COMMAND_LOG"
# Exercise the actual preflight owners through the actual parallel aggregate.
# Host setup remains a recording stub: refusal must happen before it is called.
mkdir -p "$consumer/ci" "$fixture/bin"
bash "$ROOT/scripts/ci/prepare-script-fixture.sh" "$ROOT" "$snapshot" \
    scripts/dev/install-ic-tools.sh scripts/dev/install-rust-tools.sh
cat > "$fixture/bin/uname" <<'SCRIPT'
#!/usr/bin/env bash
case "$1" in -s) echo Linux ;; -m) echo "${TOOL_PREFLIGHT_ARCH:-x86_64}" ;; esac
SCRIPT
for tool in cargo rustc; do
    cat > "$fixture/bin/$tool" <<'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail
[[ "$PWD" == "$TOOL_COMMAND_CONSUMER" && "$RUSTUP_AUTO_INSTALL" == 0 && "$1" == --version ]] || exit 1
printf '%s\n' "${0##*/}" >> "$TOOL_PREFLIGHT_PROBES"
if [[ "${TOOL_PREFLIGHT_BROKEN:-}" == "${0##*/}" ]]; then echo 'selected toolchain unavailable' >&2; exit 29; fi
printf '%s 1.0.0\n' "${0##*/}"
SCRIPT
    chmod +x "$fixture/bin/$tool"
done
chmod +x "$fixture/bin/uname"
export TOOL_PREFLIGHT_PROBES="$fixture/preflight-probes"
# Keep only these prerequisites in PATH to model genuinely absent Rust commands.
for tool in bash make awk sort grep perl tr; do ln -s "$(command -v "$tool")" "$fixture/bin/$tool"; done
# GNU Make may execute the guard's printf directly instead of via a shell builtin.
ln -s "$(type -P printf)" "$fixture/bin/printf"
real_make="$(command -v make)"
for failure in rustc cargo missing-rustc missing-cargo; do
    : > "$TOOL_COMMAND_LOG"
    : > "$TOOL_PREFLIGHT_PROBES"
    arch=x86_64; broken=''
    case "$failure" in
        rustc|cargo) broken="$failure" ;;
        missing-*) mv "$fixture/bin/${failure#missing-}" "$fixture/saved-tool" ;;
    esac
    if PATH="$fixture/bin" TOOL_PREFLIGHT_ARCH="$arch" TOOL_PREFLIGHT_BROKEN="$broken" \
        "$real_make" --no-print-directory -j4 -C "$consumer" install-tools \
        > "$fixture/preflight-$failure.log" 2>&1; then exit 1; fi
    [[ ! -s "$TOOL_COMMAND_LOG" && ! -e "$consumer/.tools/rust" ]] || exit 1
    case "$failure" in
        *) grep -F "tool=${failure#missing-}" "$fixture/preflight-$failure.log"
           grep -Ei 'prepare' "$fixture/preflight-$failure.log" >/dev/null ;;
    esac
    case "$failure" in missing-*) mv "$fixture/saved-tool" "$fixture/bin/${failure#missing-}" ;; esac
done
# A successful cold check is silent and cannot create .tools or build artifacts.
cold="$fixture/cold consumer"; mkdir "$cold"
for mode in ic rust; do
    args=(--consumer "$cold" --preflight)
    [[ "$mode" != ic ]] || args+=(--tool wasm-opt)
    PATH="$fixture/bin" TOOL_COMMAND_CONSUMER="$cold" CARGO_NET_OFFLINE=true \
        bash "$snapshot/scripts/dev/install-$mode-tools.sh" "${args[@]}" > "$fixture/preflight-$mode.out"
    [[ ! -s "$fixture/preflight-$mode.out" && ! -e "$cold/.tools" ]] || exit 1
done
# Repeat preflight over retained Rust state without probing or replacing its tools.
mkdir -p "$cold/.tools/rust/build" "$cold/.tools/rust/bin"
printf 'retained failure evidence\n' > "$cold/.tools/rust/build/evidence"
printf 'retained receipt\n' > "$cold/.tools/rust/.crates2.json"
cp -R "$cold/.tools" "$fixture/retained-tools"
PATH="$fixture/bin" TOOL_COMMAND_CONSUMER="$cold" bash "$snapshot/scripts/dev/install-rust-tools.sh" \
    --consumer "$cold" --preflight
diff -r "$fixture/retained-tools" "$cold/.tools"
# Admission modes are distinct; combining them never falls through to setup.
for mode in ic rust; do
    args=(--consumer "$cold" --check --preflight)
    [[ "$mode" != ic ]] || args+=(--tool wasm-opt)
    status=0
    bash "$snapshot/scripts/dev/install-$mode-tools.sh" "${args[@]}" > "$fixture/conflicting-modes.log" 2>&1 || status=$?
    [[ "$status" == 2 ]] || exit 1
done
echo 'Shared tool Make commands passed (substitute installers)'
fixture_complete=true
