# Step 1: Verify gateway is healthy
curl -s "$GATEWAY_URL/health/ready" | jq .
curl -s "$GATEWAY_URL/api/servers" -H "Authorization: Bearer $TOKEN" | jq .

# Step 2: Stop PostgreSQL
docker stop postgres-test

# Step 3: Wait for detection (connection timeout)
sleep 5

# Step 4: Verify health check fails
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "$GATEWAY_URL/health/ready")
echo "Health check status: $HTTP_CODE"
[ "$HTTP_CODE" = "503" ] && echo "PASS: Health check failed" || echo "FAIL"

# Step 5: Make API request
RESPONSE=$(curl -s -w "\n%{http_code}" "$GATEWAY_URL/api/servers" \
  -H "Authorization: Bearer $TOKEN")
HTTP_CODE=$(echo "$RESPONSE" | tail -1)
echo "API response: $HTTP_CODE"
[ "$HTTP_CODE" = "503" ] && echo "PASS: 503 returned" || echo "FAIL"

# Step 6: Restart PostgreSQL
docker start postgres-test

# Step 7: Wait for recovery
sleep 10

# Step 8: Verify recovery
curl -s "$GATEWAY_URL/health/ready" | jq .
curl -s "$GATEWAY_URL/api/servers" -H "Authorization: Bearer $TOKEN" | jq '.[:1]'

# Step 1: Verify normal operation
curl -s "$GATEWAY_URL/api/servers" -H "Authorization: Bearer $TOKEN" | jq '.total'

# Step 2: Add network partition via toxiproxy
toxiproxy-cli toxic add postgres -t timeout -a timeout=0

# Step 3: Wait for connection attempts to timeout
sleep 35  # Connection timeout typically 30s

# Step 4: Verify failure
HTTP_CODE=$(curl -s -o /dev/null -w "%{http_code}" "$GATEWAY_URL/api/servers" \
  -H "Authorization: Bearer $TOKEN")
echo "Response during partition: $HTTP_CODE"

# Step 5: Remove partition
toxiproxy-cli toxic delete postgres -n timeout_downstream

# Step 6: Verify recovery
sleep 5
curl -s "$GATEWAY_URL/health/ready" | jq .

# Step 1: Create slow query endpoint or use existing one
# (May need to add artificial delay for testing)

# Step 2: Launch concurrent requests exceeding pool size
for i in {1..20}; do
  curl -s "$GATEWAY_URL/api/tools" -H "Authorization: Bearer $TOKEN" &
done

# Step 3: Observe pool behavior
# Check logs for "pool limit reached" or similar

# Step 4: Wait for all to complete
wait

# Step 5: Verify all eventually succeeded or failed with 503
# (Should not have connection errors)

# Step 1: Make initial request (populates pool)
curl -s "$GATEWAY_URL/api/servers" -H "Authorization: Bearer $TOKEN"

# Step 2: Check pool statistics
psql $DATABASE_URL -c "SELECT * FROM pg_stat_activity WHERE datname = 'mcpgateway';"

# Step 3: Restart database (invalidates connections)
docker restart postgres-test
sleep 5

# Step 4: Make request (should detect stale and reconnect)
RESPONSE=$(curl -s -w "\n%{http_code}" "$GATEWAY_URL/api/servers" \
  -H "Authorization: Bearer $TOKEN")
HTTP_CODE=$(echo "$RESPONSE" | tail -1)
echo "After restart: $HTTP_CODE"

# Step 5: Verify success (pool_pre_ping detected stale)
[ "$HTTP_CODE" = "200" ] && echo "PASS: Stale connection handled" || echo "FAIL"

# Step 1: Verify current primary
psql $DATABASE_URL -c "SELECT pg_is_in_recovery();"
# Should return 'f' for false (is primary)

# Step 2: Create test data
curl -s -X POST "$GATEWAY_URL/api/servers" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "failover-test", "url": "http://test.com"}'

# Step 3: Simulate primary failure
docker stop postgres-primary

# Step 4: Promote standby
docker exec postgres-standby pg_ctl promote

# Step 5: Update connection string (or use PgBouncer/HAProxy)
# This depends on your HA setup

# Step 6: Verify writes work on new primary
curl -s -X POST "$GATEWAY_URL/api/servers" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name": "after-failover", "url": "http://new.com"}'

# Step 7: Verify no data loss
curl -s "$GATEWAY_URL/api/servers?name=failover-test" \
  -H "Authorization: Bearer $TOKEN" | jq .

# In terminal 1:
psql $DATABASE_URL << 'EOF'
BEGIN;
UPDATE servers SET description = 'lock1' WHERE name = 'server-a';
-- Wait here for terminal 2
SELECT pg_sleep(5);
UPDATE servers SET description = 'lock1' WHERE name = 'server-b';
COMMIT;
EOF

# In terminal 2 (run simultaneously):
psql $DATABASE_URL << 'EOF'
BEGIN;
UPDATE servers SET description = 'lock2' WHERE name = 'server-b';
-- This will create deadlock with terminal 1
UPDATE servers SET description = 'lock2' WHERE name = 'server-a';
COMMIT;
EOF

# One should succeed, one should get deadlock error

# Step 1: Check current timeout
psql $DATABASE_URL -c "SHOW statement_timeout;"

# Step 2: Create scenario that times out via API
# (Depends on implementation - may need slow endpoint)

# Step 3: Verify timeout error returned
# Should be a clear timeout error, not generic 500

# Step 4: Verify transaction rolled back
# Subsequent queries should work normally
curl -s "$GATEWAY_URL/api/servers" -H "Authorization: Bearer $TOKEN" | jq .