#!/usr/bin/env bash
# tests/smoke-init.sh — End-to-end smoke test for disinto init using mock Forgejo
#
# Validates the full init flow: Forgejo API, user/token creation,
# repo setup, labels, TOML generation, and cron installation.
#
# Uses mock Forgejo server (started by .woodpecker/smoke-init.yml).
#
# Required env:  SMOKE_FORGE_URL (default: http://localhost:3000)
# Required tools: bash, curl, jq, git

set -euo pipefail

FACTORY_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
FORGE_URL="${SMOKE_FORGE_URL:-http://localhost:3000}"
TEST_SLUG="smoke-org/smoke-repo"
MOCK_BIN="/tmp/smoke-mock-bin"
FAILED=0

fail() { printf 'FAIL: %s\n' "$*" >&2; FAILED=1; }
pass() { printf 'PASS: %s\n' "$*"; }

cleanup() {
  rm -rf "$MOCK_BIN" /tmp/smoke-test-repo \
         "${FACTORY_ROOT}/projects/smoke-repo.toml"
  # Restore .env only if we created the backup
  if [ -f "${FACTORY_ROOT}/.env.smoke-backup" ]; then
    mv "${FACTORY_ROOT}/.env.smoke-backup" "${FACTORY_ROOT}/.env"
  else
    rm -f "${FACTORY_ROOT}/.env"
  fi
}
trap cleanup EXIT

# Back up existing .env if present
if [ -f "${FACTORY_ROOT}/.env" ]; then
  cp "${FACTORY_ROOT}/.env" "${FACTORY_ROOT}/.env.smoke-backup"
fi
# Start with a clean .env (init writes tokens here)
printf '' > "${FACTORY_ROOT}/.env"

# ── 1. Verify mock Forgejo is ready ─────────────────────────────────────────
echo "=== 1/6 Verifying mock Forgejo at ${FORGE_URL} ==="
retries=0
api_version=""
while true; do
  api_version=$(curl -sf --max-time 3 "${FORGE_URL}/api/v1/version" 2>/dev/null \
    | jq -r '.version // empty' 2>/dev/null) || api_version=""
  if [ -n "$api_version" ]; then
    break
  fi
  retries=$((retries + 1))
  if [ "$retries" -gt 30 ]; then
    fail "Mock Forgejo API not responding after 30s"
    exit 1
  fi
  sleep 1
done
pass "Mock Forgejo API v${api_version} (${retries}s)"

# ── 2. Set up mock binaries (claude, tmux) ─────────────────────────────────
echo "=== 2/6 Setting up mock binaries ==="
mkdir -p "$MOCK_BIN"

# ── Mock: claude ──
cat > "$MOCK_BIN/claude" << 'CLAUDEMOCK'
#!/usr/bin/env bash
case "$*" in
  *"auth status"*) printf '{"loggedIn":true}\n' ;;
  *"--version"*)   printf 'claude 1.0.0 (mock)\n' ;;
esac
exit 0
CLAUDEMOCK
chmod +x "$MOCK_BIN/claude"

# ── Mock: tmux ──
printf '#!/usr/bin/env bash\nexit 0\n' > "$MOCK_BIN/tmux"
chmod +x "$MOCK_BIN/tmux"

export PATH="$MOCK_BIN:$PATH"
pass "Mock binaries installed (claude, tmux)"

# ── 3. Run disinto init ─────────────────────────────────────────────────────
echo "=== 3/6 Running disinto init ==="
rm -f "${FACTORY_ROOT}/projects/smoke-repo.toml"

# Configure git identity (needed for git operations)
git config --global user.email "smoke@test.local"
git config --global user.name "Smoke Test"

export SMOKE_FORGE_URL="$FORGE_URL"
export FORGE_URL

if bash "${FACTORY_ROOT}/bin/disinto" init \
  "${TEST_SLUG}" \
  --bare --yes \
  --forge-url "$FORGE_URL" \
  --repo-root "/tmp/smoke-test-repo"; then
  pass "disinto init completed successfully"
else
  fail "disinto init exited non-zero"
fi

# ── 4. Verify Forgejo state ─────────────────────────────────────────────────
echo "=== 4/6 Verifying Forgejo state ==="

# Admin user exists
if curl -sf --max-time 5 "${FORGE_URL}/api/v1/users/disinto-admin" >/dev/null 2>&1; then
  pass "Admin user 'disinto-admin' exists on Forgejo"
else
  fail "Admin user 'disinto-admin' not found on Forgejo"
fi

# Bot users exist
for bot in dev-bot review-bot; do
  if curl -sf --max-time 5 "${FORGE_URL}/api/v1/users/${bot}" >/dev/null 2>&1; then
    pass "Bot user '${bot}' exists on Forgejo"
  else
    fail "Bot user '${bot}' not found on Forgejo"
  fi
done

# Repo exists (try org path, then fallback paths)
repo_found=false
for repo_path in "${TEST_SLUG}" "dev-bot/smoke-repo" "disinto-admin/smoke-repo"; do
  if curl -sf --max-time 5 "${FORGE_URL}/api/v1/repos/${repo_path}" >/dev/null 2>&1; then
    pass "Repo '${repo_path}' exists on Forgejo"
    repo_found=true
    break
  fi
done
if [ "$repo_found" = false ]; then
  fail "Repo not found on Forgejo under any expected path"
fi

# Labels exist on repo
# Create a token to check labels (using disinto-admin which was created by init)
disinto_admin_pass="Disinto-Admin-456"
verify_token=$(curl -sf -X POST \
  -u "disinto-admin:${disinto_admin_pass}" \
  -H "Content-Type: application/json" \
  "${FORGE_URL}/api/v1/users/disinto-admin/tokens" \
  -d '{"name":"smoke-verify","scopes":["all"]}' 2>/dev/null \
  | jq -r '.sha1 // empty') || verify_token=""

if [ -n "$verify_token" ]; then
  label_count=0
  for repo_path in "${TEST_SLUG}" "dev-bot/smoke-repo" "disinto-admin/smoke-repo"; do
    label_count=$(curl -sf \
      -H "Authorization: token ${verify_token}" \
      "${FORGE_URL}/api/v1/repos/${repo_path}/labels?limit=50" 2>/dev/null \
      | jq 'length' 2>/dev/null) || label_count=0
    if [ "$label_count" -gt 0 ]; then
      break
    fi
  done

  if [ "$label_count" -ge 5 ]; then
    pass "Labels created on repo (${label_count} labels)"
  else
    fail "Expected >= 5 labels, found ${label_count}"
  fi
else
  fail "Could not obtain verification token"
fi

# ── 5. Verify local state ───────────────────────────────────────────────────
echo "=== 5/6 Verifying local state ==="

# TOML was generated
toml_path="${FACTORY_ROOT}/projects/smoke-repo.toml"
if [ -f "$toml_path" ]; then
  toml_name=$(python3 -c "
import tomllib, sys
with open(sys.argv[1], 'rb') as f:
    print(tomllib.load(f)['name'])
" "$toml_path" 2>/dev/null) || toml_name=""

  if [ "$toml_name" = "smoke-repo" ]; then
    pass "TOML generated with correct project name"
  else
    fail "TOML name mismatch: expected 'smoke-repo', got '${toml_name}'"
  fi
else
  fail "TOML not generated at ${toml_path}"
fi

# .env has tokens
env_file="${FACTORY_ROOT}/.env"
if [ -f "$env_file" ]; then
  if grep -q '^FORGE_TOKEN=' "$env_file"; then
    pass ".env contains FORGE_TOKEN"
  else
    fail ".env missing FORGE_TOKEN"
  fi
  if grep -q '^FORGE_REVIEW_TOKEN=' "$env_file"; then
    pass ".env contains FORGE_REVIEW_TOKEN"
  else
    fail ".env missing FORGE_REVIEW_TOKEN"
  fi
else
  fail ".env not found"
fi

# Repo was cloned
if [ -d "/tmp/smoke-test-repo/.git" ]; then
  pass "Repo cloned to /tmp/smoke-test-repo"
else
  fail "Repo not cloned to /tmp/smoke-test-repo"
fi

# ── 6. Verify cron setup ────────────────────────────────────────────────────
echo "=== 6/6 Verifying cron setup ==="
cron_output=$(crontab -l 2>/dev/null) || cron_output=""
if [ -n "$cron_output" ]; then
  if printf '%s' "$cron_output" | grep -q 'dev-poll.sh'; then
    pass "Cron includes dev-poll entry"
  else
    fail "Cron missing dev-poll entry"
  fi
  if printf '%s' "$cron_output" | grep -q 'review-poll.sh'; then
    pass "Cron includes review-poll entry"
  else
    fail "Cron missing review-poll entry"
  fi
  if printf '%s' "$cron_output" | grep -q 'gardener-run.sh'; then
    pass "Cron includes gardener entry"
  else
    fail "Cron missing gardener entry"
  fi
else
  fail "No cron entries found (crontab -l returned empty)"
fi

# ── Mock state verification ─────────────────────────────────────────────────
echo "=== Verifying mock Forgejo state ==="

# Query /mock/state to verify all expected API calls were made
mock_state=$(curl -sf \
  -H "Authorization: token ${verify_token}" \
  "${FORGE_URL}/mock/state" 2>/dev/null) || mock_state=""

if [ -n "$mock_state" ]; then
  # Verify users were created
  users=$(echo "$mock_state" | jq -r '.users | length' 2>/dev/null) || users=0
  if [ "$users" -ge 3 ]; then
    pass "Mock state: ${users} users created (expected >= 3)"
  else
    fail "Mock state: expected >= 3 users, found ${users}"
  fi

  # Verify repos were created
  repos=$(echo "$mock_state" | jq -r '.repos | length' 2>/dev/null) || repos=0
  if [ "$repos" -ge 1 ]; then
    pass "Mock state: ${repos} repos created (expected >= 1)"
  else
    fail "Mock state: expected >= 1 repos, found ${repos}"
  fi

  # Verify labels were created
  labels_total=$(echo "$mock_state" | jq '[.labels.values[] | length] | add // 0' 2>/dev/null) || labels_total=0
  if [ "$labels_total" -ge 5 ]; then
    pass "Mock state: ${labels_total} labels created (expected >= 5)"
  else
    fail "Mock state: expected >= 5 labels, found ${labels_total}"
  fi

  # Verify tokens were created
  tokens=$(echo "$mock_state" | jq -r '.tokens | length' 2>/dev/null) || tokens=0
  if [ "$tokens" -ge 1 ]; then
    pass "Mock state: ${tokens} tokens created (expected >= 1)"
  else
    fail "Mock state: expected >= 1 tokens, found ${tokens}"
  fi
else
  fail "Could not query /mock/state endpoint"
fi

# ── Summary ──────────────────────────────────────────────────────────────────
echo ""
if [ "$FAILED" -ne 0 ]; then
  echo "=== SMOKE-INIT TEST FAILED ==="
  exit 1
fi
echo "=== SMOKE-INIT TEST PASSED ==="