#!/bin/bash
# Pi Verify - Session Watcher & Verifier
# Listens for builder ticks, verifies output, injects feedback

set -e

SOCKET="${SOCKET:-/tmp/pi-verify.sock}"
SESSION="${SESSION:-./session.jsonl}"
MAX_LOOPS="${MAX_LOOPS:-3}"

# Colors
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
RED='\033[0;31m'
CYAN='\033[0;36m'
NC='\033[0m'

log() { echo -e "${CYAN}[verify]${NC} $1"; }
pass() { echo -e "${GREEN}[VERIFIED]${NC} $1"; }
warn() { echo -e "${YELLOW}[PARTIAL]${NC} $1"; }
fail() { echo -e "${RED}[FAILED]${NC} $1"; }

# Verify a single turn
verify_turn() {
    local turn="$1"
    local confidence="VERIFIED"
    local feedback=""
    
    # Extract files created/modified
    local files=$(echo "$turn" | jq -r '.files[]?.path' 2>/dev/null || echo "")
    
    # Check 1: Files exist
    if [ -n "$files" ]; then
        for f in $files; do
            if [ ! -f "$f" ]; then
                confidence="FAILED"
                feedback="$feedback\n- File $f was not created"
            fi
        done
    fi
    
    # Check 2: Syntax (if TypeScript/JS)
    if echo "$files" | grep -qE '\.(ts|tsx|js|jsx)$'; then
        for f in $(echo "$files" | grep -E '\.(ts|tsx|js|jsx)$'); do
            if ! node --check "$f" 2>/dev/null; then
                confidence="PARTIAL"
                feedback="$feedback\n- Syntax error in $f"
            fi
        done
    fi
    
    # Check 3: Tests (if exists)
    if [ -f "package.json" ] && grep -q '"test"' package.json; then
        if ! npm test -- --passWithNoTests >/dev/null 2>&1; then
            confidence="PARTIAL"
            feedback="$feedback\n- Tests failed"
        fi
    fi
    
    # Check 4: No dangerous commands
    if echo "$turn" | grep -qE 'rm\s+-rf|drop\s+database|--force'; then
        confidence="PARTIAL"
        feedback="$feedback\n- Dangerous command detected"
    fi
    
    echo "{\"confidence\":\"$confidence\",\"feedback\":\"$feedback\"}"
}

# Main loop
main() {
    log "Starting verifier..."
    log "Socket: $SOCKET"
    log "Session: $SESSION"
    log "Max loops: $MAX_LOOPS"
    
    # Wait for socket
    if [ ! -S "$SOCKET" ]; then
        log "Waiting for builder socket..."
        while [ ! -S "$SOCKET" ]; do sleep 1; done
    fi
    
    log "Connected to builder"
    
    # Read ticks and verify
    while true; do
        # Read tick from socket
        local tick=$(nc -U -l -p 1 "$SOCKET" 2>/dev/null || echo "")
        
        case "$tick" in
            "start")
                log "Builder started"
                ;;
            "stop")
                log "Builder stopped"
                break
                ;;
            "turn")
                # Read last turn from session
                local last_turn=$(tail -1 "$SESSION" 2>/dev/null || echo "{}")
                
                log "Verifying turn..."
                local result=$(verify_turn "$last_turn")
                local confidence=$(echo "$result" | jq -r '.confidence')
                
                case "$confidence" in
                    PERFECT|VERIFIED)
                        pass "$confidence"
                        ;;
                    PARTIAL)
                        warn "Issues found"
                        echo "$result" | jq -r '.feedback' >&2
                        # Send feedback to builder
                        echo "$result" | nc -U "$SOCKET" 2>/dev/null || true
                        ;;
                    FAILED)
                        fail "Major problems"
                        echo "$result" | jq -r '.feedback' >&2
                        echo "$result" | nc -U "$SOCKET" 2>/dev/null || true
                        ;;
                esac
                ;;
            *)
                # Tick received
                ;;
        esac
    done
    
    log "Verifier shutdown"
}

main "$@"