#!/usr/bin/env bash
# End-to-end checks of the vcs CLI on a project that lives on this machine.
# Usage: tests/local.sh [path/to/vcs]
set -uo pipefail

VCS=${1:-$(cd "$(dirname "$0")/.." && pwd)/target/debug/vcs}
WORK=$(mktemp -d)
export VCS_HOME="$WORK/home" VCS_NAME="Test Person" VCS_EMAIL="test@example.com" VCS_SAVER=0
trap 'rm -rf "$WORK"' EXIT
cd "$WORK"

pass=0
fail=0
check() { # name, command...
  local name=$1
  shift
  if "$@" >/dev/null 2>&1; then pass=$((pass + 1)); else fail=$((fail + 1)); echo "FAIL: $name"; fi
}
code() { # expected exit code, command...
  local want=$1
  shift
  "$@" >/dev/null 2>&1
  [ "$?" = "$want" ]
}
json() { "$VCS" --json "$@" 2>/dev/null; }

# A new project with a first version.
mkdir app && cd app
printf 'hello\n' > README.md
mkdir src && printf 'a\nb\nc\nd\ne\nf\ng\n' > src/lib.txt
printf '{\n  "name": "app"\n}\n' > package.json
printf 'SECRET=1\n' > .env
check "init" "$VCS" init
check "land first version" "$VCS" land -m "First version"
check "main is version 1" test "$(json log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 1
check ".env never landed" test -z "$(json log 1 | python3 -c 'import json,sys; print([f for f in json.load(sys.stdin)["files"] if ".env" in f] or "")')"
check "empty land refused (exit 1)" code 1 "$VCS" land -m "Nothing"

# A second workspace gets the files and the .env.
cd "$WORK"
check "get second workspace" "$VCS" get ./app app2
check "files arrived" test "$(cat app2/src/lib.txt | head -1)" = a
check ".env came along" test "$(cat app2/.env)" = "SECRET=1"

# Parallel edits to different files both land, in any order.
printf 'hello there\n' > app/README.md
printf 'a\nb\nc\nd\ne\nf\nG\n' > app2/src/lib.txt
check "land from app" "$VCS" -C app land -m "Greet better"
check "land from app2 without syncing" "$VCS" -C app2 land -m "Capital G"
check "main is version 3" test "$(json -C app log | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["n"])')" = 3

# JSON files merge by key.
cd "$WORK" && "$VCS" -C app sync >/dev/null 2>&1 && "$VCS" -C app2 sync >/dev/null 2>&1
printf '{\n  "name": "app",\n  "version": "1.0.0"\n}\n' > app/package.json
printf '{\n  "name": "app",\n  "license": "MIT"\n}\n' > app2/package.json
check "land json key A" "$VCS" -C app land -m "Add version"
check "land json key B (merged by key)" "$VCS" -C app2 land -m "Add license"
"$VCS" -C app sync >/dev/null 2>&1
check "both keys on main" python3 -c 'import json; d=json.load(open("app/package.json")); assert d["version"]=="1.0.0" and d["license"]=="MIT"'

# A real conflict: land refuses, sync marks it, fixing it lands.
"$VCS" -C app2 sync >/dev/null 2>&1
perl -pi -e 's/^b$/B from app/' app/src/lib.txt
perl -pi -e 's/^b$/B from app2/' app2/src/lib.txt
check "land A" "$VCS" -C app land -m "B from app"
check "land B conflicts (exit 3)" code 3 "$VCS" -C app2 land -m "B from app2"
check "sync leaves markers (exit 3)" code 3 "$VCS" -C app2 sync
check "markers in file" grep -q '<<<<<<< main' app2/src/lib.txt
check "land refused while markers remain" code 3 "$VCS" -C app2 land
python3 - "$WORK/app2/src/lib.txt" <<'EOF'
import sys, re
p = sys.argv[1]
t = open(p).read()
t = re.sub(r"<<<<<<< [^\n]*\n(.*?)=======\n(.*?)>>>>>>> [^\n]*\n", lambda m: "B from both\n", t, flags=re.S)
open(p, "w", newline="\n").write(t)
EOF
check "land after fixing (reuses description)" "$VCS" -C app2 land
check "status clean after land" test "$(json -C app2 status | python3 -c 'import json,sys; print(len(json.load(sys.stdin)["files"]))')" = 0

# A file's history, and the version behind each line.
check "log of a file" test "$(json -C app log src/lib.txt | python3 -c 'import json,sys; print(",".join(str(v["n"]) for v in json.load(sys.stdin)["versions"]))')" = 7,6,3,1
check "log of a folder" sh -c "\"$VCS\" -C app log src | grep -q 'Capital G'"
check "log of a file from inside its folder" sh -c "cd app/src && \"$VCS\" log lib.txt | grep -q 'First version'"
check "blame" test "$(json -C app2 blame src/lib.txt | python3 -c 'import json,sys; print(",".join(str(l["version"]) for l in json.load(sys.stdin)["lines"]))')" = 1,7,1,1,1,1,3
check "blame of a missing file fails" sh -c "! \"$VCS\" -C app blame nope.txt"
check "show a file in main" sh -c "\"$VCS\" -C app show src/lib.txt | grep -q 'B from both'"
check "show a file at a version" test "$("$VCS" -C app show src/lib.txt --from 1 | tail -1)" = g
check "show a missing file fails" sh -c "! \"$VCS\" -C app show nope.txt"
check "completions" sh -c "\"$VCS\" completions bash | grep -q _vcs"

# Tags: names for versions.
check "tag main's latest" "$VCS" -C app tag v1.0
check "tag an older version" "$VCS" -C app tag first 1
check "the list has them" sh -c "\"$VCS\" -C app tag | grep -q 'v1.0' && \"$VCS\" -C app tag | grep -q first"
check "show at a tag" test "$("$VCS" -C app show src/lib.txt --from first | tail -1)" = g
check "log of a tag" sh -c "\"$VCS\" -C app log first | grep -q 'First version'"
check "a tag stays on its version (exit 3)" code 3 "$VCS" -C app tag first 2
check "a number can't be a tag (exit 2)" code 2 "$VCS" -C app tag 12
check "remove a tag" "$VCS" -C app tag first --remove
check "it's gone" sh -c "! \"$VCS\" -C app tag | grep -q first"

# Cleaning up: a dropped change's saves and objects go; what's kept still works.
cd "$WORK/app"
"$VCS" sync >/dev/null 2>&1
head -c 200000 /dev/urandom > scratch.bin
"$VCS" status >/dev/null 2>&1
"$VCS" drop >/dev/null 2>&1
check "gc --dry-run says what would go" sh -c "VCS_GC_FRESH=0 '$VCS' gc --older 0s --dry-run | grep -q 'would remove'"
check "gc removes the dropped change's objects" test "$(VCS_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"] > 0)')" = True
check "main still reads" sh -c "\"$VCS\" show src/lib.txt | grep -q 'B from both'"
check "history still reads" sh -c "\"$VCS\" log src/lib.txt | grep -q 'First version'"
check "nothing is damaged" "$VCS" check
check "a second gc has nothing left" test "$(VCS_GC_FRESH=0 json gc --older 0s | python3 -c 'import json,sys; print(json.load(sys.stdin)["objects"])')" = 0
cd "$WORK"

# Undo a land: main gets a version that takes it back out.
cd "$WORK/app"
"$VCS" sync >/dev/null 2>&1
printf 'oops\n' > oops.txt
check "land oops" "$VCS" land -m "Oops"
check "undo the land" "$VCS" undo
check "oops is open again" test "$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["state"])')" = open
check "main took it back" test "$(json log -n 1 | python3 -c 'import json,sys; print(json.load(sys.stdin)["versions"][0]["title"][:13])')" = "Take back mai"
check "drop it" "$VCS" drop
check "undo the drop" "$VCS" undo
check "drop again" "$VCS" drop

# Restore a file from an earlier save.
printf 'v1\n' > notes.txt
"$VCS" status >/dev/null 2>&1
sleep 3
printf 'broken\n' > notes.txt
"$VCS" status >/dev/null 2>&1
check "restore --at" "$VCS" restore notes.txt --at "2s ago"
check "notes is v1" test "$(cat notes.txt)" = v1
check "undo the restore" "$VCS" undo
check "notes is broken again" test "$(cat notes.txt)" = broken
check "restore to base (removes the new file)" "$VCS" restore notes.txt
check "notes gone" test ! -e notes.txt

# New, switch, stacks.
printf 'feature a\n' > a.txt
check "describe" "$VCS" describe "Feature A"
A=$(json status | python3 -c 'import json,sys; print(json.load(sys.stdin)["change"]["id"])')
check "new stacked on A" "$VCS" new "Feature B" --on "$A"
printf 'feature b\n' > b.txt
check "a.txt visible in B" test -e a.txt
check "switch back to A" "$VCS" switch "${A:0:6}"
check "b.txt gone in A" test ! -e b.txt
check "undo switch" "$VCS" undo
check "b.txt back" test -e b.txt
check "land B lands A then B" "$VCS" land
check "main has both" test "$(json log -n 2 | python3 -c 'import json,sys; print(",".join(v["title"] for v in json.load(sys.stdin)["versions"]))')" = "Feature B,Feature A"

# Secrets don't land.
printf 'const key = "sk_live_%s";\n' "$(printf 'x%.0s' {1..24})" > pay.js
check "secret refused (exit 8)" code 8 "$VCS" land -m "Payments"
rm pay.js
printf 'const key = process.env.STRIPE_KEY;\n' > pay.js
check "lands without the secret" "$VCS" land -m "Payments"

# vcs.toml [land] run: the workspace's own checks before it lands.
printf '[land]\nrun = ["exit 1"]\n' > vcs.toml
check "a failing [land] run stops the land (exit 4)" code 4 "$VCS" land -m "Checks"
check "--no-run lands anyway" "$VCS" land -m "Checks" --no-run
printf '[land]\nrun = ["exit 0"]\n' > vcs.toml
check "a passing [land] run lands" "$VCS" land -m "Checks pass"

# No description.
printf 'x\n' > x.txt
check "no description (exit 2)" code 2 "$VCS" land
check "describe then land" "$VCS" land -m "Add x"

# Diff and log output.
printf 'y\n' > x.txt
check "diff shows the edit" sh -c "\"$VCS\" diff | grep -q '^+y'"
check "log --saves" "$VCS" log --saves
check "log --ops" "$VCS" log --ops
check "log --changes" "$VCS" log --changes
check "guide" sh -c "\"$VCS\" guide | grep -q 'vcs land'"

# Deleting a workspace is deleting its folder; a new one can take its place.
cd "$WORK"
check "get a third workspace" "$VCS" get ./app app3
rm -rf app3
check "get again at the same path" "$VCS" get ./app app3
cd "$WORK/app"

# Mine: vcs access <path> me.
printf 'token\n' > secrets.local
check "access me" "$VCS" access secrets.local me
check "mine stays out of the change" sh -c "! \"$VCS\" --json status | grep -q secrets.local"

# An agent each: workspaces added next to this one, and cleaned up once done.
check "add a workspace" "$VCS" workspaces add ../agent1
check "it has main's files" test -f ../agent1/README.md
printf 'parent work\n' > parent.txt
check "add one on this change" "$VCS" workspaces add ../sub1 --on .
check "it starts from this change's work" test -f ../sub1/parent.txt
check "the list has them" sh -c "'$VCS' workspaces | grep -q agent1 && '$VCS' workspaces | grep -q sub1"
printf 'agent work\n' > ../agent1/agent.txt && printf 'sub work\n' > ../sub1/sub.txt
check "clean (nothing idle long enough)" "$VCS" workspaces clean
check "keeps them all" test -d ../agent1 -a -d ../sub1 -a -d ../app2
check "clean, no idle time" "$VCS" workspaces clean --idle 0s
check "keeps work that hasn't landed" test -f ../agent1/agent.txt -a -f ../sub1/sub.txt
check "removes a workspace whose change was empty" test ! -e ../app3
check "never this one" test -d .vcs
check "agent1 lands" "$VCS" -C ../agent1 land -m "Agent work"
check "clean again" "$VCS" workspaces clean --idle 0s
check "removes it once its work landed" test ! -e ../agent1
check "and forgets it" sh -c "! '$VCS' workspaces | grep -q agent1"
check "main has its work" sh -c "'$VCS' sync >/dev/null && test -f agent.txt"

# Bisect: the first version where a check fails, tried in a folder of its own.
mkdir "$WORK/bis" && cd "$WORK/bis"
printf 'fine\n' > state.txt
"$VCS" init >/dev/null 2>&1 && "$VCS" land -m "v1" >/dev/null 2>&1
for i in 2 3 4 5 6; do printf 'fine %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done
printf 'broken\n' > state.txt && "$VCS" land -m "Breaks it" >/dev/null 2>&1
for i in 8 9 10; do printf 'broken %s\n' "$i" > state.txt; "$VCS" land -m "v$i" >/dev/null 2>&1; done
check "bisect finds the version that broke it" test "$(json bisect 1 10 --run 'grep -q fine state.txt' | python3 -c 'import json,sys; print(json.load(sys.stdin)["first_bad"])')" = 7
check "the workspace's files didn't change" grep -q 'broken 10' state.txt
check "with --in it keeps the folder" sh -c "'$VCS' bisect 1 main --run 'grep -q fine state.txt' --in ../bis-try >/dev/null && test -f ../bis-try/state.txt"
printf 'grep -qx "fine 6" state.txt && exit 125\ngrep -q fine state.txt\n' > "$WORK/skip-check.sh"
check "exit 125 skips a version" test "$(json bisect 1 10 --run "sh $WORK/skip-check.sh" | python3 -c 'import json,sys; print(json.load(sys.stdin)["first_bad"])')" = 7
check "a good version after the bad one is refused (exit 2)" code 2 "$VCS" bisect 10 1 --run true

echo "local: $pass passed, $fail failed"
[ "$fail" = 0 ]