#!/bin/bash

##############################################################################
# Test Cleanup Progress Tracker v2.0
# 
# Runs tests by sections to avoid Mockery "Cannot redeclare" issues
# Tracks progress towards 100% passing tests for CI/CD implementation
# 
# Usage: ./scripts/test-progress-tracker.sh [--save] [--detailed]
##############################################################################

set -e

# Colors
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Progress file
PROGRESS_FILE=".test-cleanup-progress.json"
BASELINE_FAILURES=315
BASELINE_PASSED=1169
BASELINE_TOTAL=1498
MAX_TIME_PER_SECTION=60  # 60s max per section

# Detailed mode flag
DETAILED_MODE=0
if [ "$1" == "--detailed" ] || [ "$2" == "--detailed" ]; then
    DETAILED_MODE=1
fi

echo -e "${BLUE}╔════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║        SuiteX Test Cleanup Progress Tracker v2.0          ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}"
echo ""

# Test sections to run (avoids Mockery "Cannot redeclare" by splitting execution)
TEST_SECTIONS=(
    "tests/Unit/Services"
    "tests/Unit/Models"
    "tests/Unit/Jobs"
    "tests/Unit/Helpers"
    "tests/Unit/Domain"
    "tests/Unit/Traits"
    "tests/Unit/Providers"
    "tests/Unit/Listeners"
    "tests/Unit/Http"
    "tests/Unit/Domain/Ipaas"
    "tests/Integration"
    "tests/Performance"
)

# Run tests section by section
echo -e "${YELLOW}Running test suite by sections (avoids Mockery scale issues)...${NC}"
echo ""

TOTAL_FAILED=0
TOTAL_PASSED=0
TOTAL_RISKY=0
TOTAL_SKIPPED=0
TOTAL_DURATION=0

# Temp file for error analysis
ERROR_LOG=$(mktemp)

for SECTION in "${TEST_SECTIONS[@]}"; do
    # Check if section exists
    if [ ! -d "$SECTION" ]; then
        continue
    fi
    
    SECTION_NAME=$(basename "$SECTION")
    printf "  %-30s " "$SECTION_NAME..."
    
    # Run section with timeout
    # For Jobs section, set env var to skip tests that require process isolation
    if [[ "$SECTION" == *"Jobs"* ]]; then
        SECTION_OUTPUT=$(SKIP_SUITE_SENSITIVE_TESTS=true timeout ${MAX_TIME_PER_SECTION}s php artisan test "$SECTION" --compact 2>&1 || true)
    else
        SECTION_OUTPUT=$(timeout ${MAX_TIME_PER_SECTION}s php artisan test "$SECTION" --compact 2>&1 || true)
    fi
    
    # Extract section results
    SEC_FAILED=$(echo "$SECTION_OUTPUT" | grep -oP 'Tests:\s+\K\d+(?= failed)' | head -1 || echo "0")
    SEC_PASSED=$(echo "$SECTION_OUTPUT" | grep -oP '\d+(?= passed)' | head -1 || echo "0")
    SEC_RISKY=$(echo "$SECTION_OUTPUT" | grep -oP '\d+(?= risky)' | head -1 || echo "0")
    SEC_SKIPPED=$(echo "$SECTION_OUTPUT" | grep -oP '\d+(?= skipped)' | head -1 || echo "0")
    
    # Accumulate
    TOTAL_FAILED=$((TOTAL_FAILED + SEC_FAILED))
    TOTAL_PASSED=$((TOTAL_PASSED + SEC_PASSED))
    TOTAL_RISKY=$((TOTAL_RISKY + SEC_RISKY))
    TOTAL_SKIPPED=$((TOTAL_SKIPPED + SEC_SKIPPED))
    
    # Save errors for detailed analysis
    if [ $DETAILED_MODE -eq 1 ]; then
        echo "$SECTION_OUTPUT" >> "$ERROR_LOG"
    fi
    
    # Display section result
    if [ $SEC_FAILED -gt 0 ]; then
        printf "${RED}✗ %d failed${NC}, ${GREEN}%d passed${NC}\n" $SEC_FAILED $SEC_PASSED
    else
        printf "${GREEN}✓ %d passed${NC}\n" $SEC_PASSED
    fi
done

echo ""

# Calculate totals
TOTAL=$((TOTAL_FAILED + TOTAL_PASSED + TOTAL_SKIPPED))
if [ $TOTAL -eq 0 ]; then
    echo -e "${RED}Error: No tests were executed${NC}"
    rm -f "$ERROR_LOG"
    exit 1
fi

# Calculate progress
PASS_RATE=$(awk "BEGIN {printf \"%.1f\", ($TOTAL_PASSED/$TOTAL)*100}")
IMPROVEMENT=$((BASELINE_FAILURES - TOTAL_FAILED))
IMPROVEMENT_PERCENT=$(awk "BEGIN {printf \"%.1f\", ($IMPROVEMENT/$BASELINE_FAILURES)*100}")

# Display results
echo ""
echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
echo -e "${BLUE}  CURRENT STATUS${NC}"
echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
echo ""
printf "  %-20s ${GREEN}%4d${NC} / ${BLUE}%4d${NC} (%.1f%%)\n" "✓ Passing:" $TOTAL_PASSED $TOTAL $PASS_RATE
printf "  %-20s ${RED}%4d${NC}\n" "✗ Failing:" $TOTAL_FAILED
printf "  %-20s ${YELLOW}%4d${NC}\n" "⚠ Risky:" $TOTAL_RISKY
printf "  %-20s ${YELLOW}%4d${NC}\n" "⊘ Skipped:" $TOTAL_SKIPPED
echo ""

# Progress towards goal
echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
echo -e "${BLUE}  PROGRESS TOWARDS 100%${NC}"
echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
echo ""
printf "  %-25s %4d → ${GREEN}%4d${NC}\n" "Baseline failures:" $BASELINE_FAILURES $TOTAL_FAILED
printf "  %-25s ${GREEN}%4d${NC} tests fixed (%.1f%%)\n" "Improvement:" $IMPROVEMENT $IMPROVEMENT_PERCENT
printf "  %-25s ${RED}%4d${NC} tests remaining\n" "To fix:" $TOTAL_FAILED
echo ""

# Calculate remaining work
if [ $TOTAL_FAILED -gt 0 ]; then
    if [ $TOTAL_FAILED -le 50 ]; then
        echo -e "  Estimated work remaining: ${GREEN}~1-2 sessions${NC} 🎯"
    elif [ $TOTAL_FAILED -le 100 ]; then
        echo -e "  Estimated work remaining: ${YELLOW}~3-5 sessions${NC}"
    else
        SESSIONS_REMAINING=$(awk "BEGIN {printf \"%.0f\", ($TOTAL_FAILED/20)}")
        echo -e "  Estimated work remaining: ${YELLOW}~$SESSIONS_REMAINING sessions${NC}"
    fi
else
    echo -e "  ${GREEN}🎉 All tests passing! Goal achieved!${NC}"
fi

echo ""

# Show progress bar
PROGRESS_BARS=50
FILLED=$((TOTAL_PASSED * PROGRESS_BARS / TOTAL))
EMPTY=$((PROGRESS_BARS - FILLED))

printf "  Progress: ["
printf "${GREEN}%0.s█${NC}" $(seq 1 $FILLED)
printf "%0.s░" $(seq 1 $EMPTY)
printf "] %.1f%%\n" $PASS_RATE
echo ""

# Load previous run if exists
if [ -f "$PROGRESS_FILE" ]; then
    PREV_FAILED=$(jq -r '.failed' "$PROGRESS_FILE" 2>/dev/null || echo "$TOTAL_FAILED")
    PREV_PASSED=$(jq -r '.passed' "$PROGRESS_FILE" 2>/dev/null || echo "$TOTAL_PASSED")
    PREV_DATE=$(jq -r '.date' "$PROGRESS_FILE" 2>/dev/null || echo "Unknown")
    
    DELTA_FAILED=$((PREV_FAILED - TOTAL_FAILED))
    DELTA_PASSED=$((TOTAL_PASSED - PREV_PASSED))
    
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}  CHANGE SINCE LAST RUN${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo ""
    echo "  Last run: $PREV_DATE"
    echo ""
    
    if [ $DELTA_FAILED -gt 0 ]; then
        printf "  ${GREEN}✓ Fixed %d tests${NC}\n" $DELTA_FAILED
    elif [ $DELTA_FAILED -lt 0 ]; then
        printf "  ${RED}✗ %d new failures${NC}\n" $((DELTA_FAILED * -1))
    else
        echo "  No change in failures"
    fi
    
    if [ $DELTA_PASSED -gt 0 ]; then
        printf "  ${GREEN}✓ %d more tests passing${NC}\n" $DELTA_PASSED
    elif [ $DELTA_PASSED -lt 0 ]; then
        printf "  ${YELLOW}⚠ %d fewer tests passing${NC}\n" $((DELTA_PASSED * -1))
    fi
    echo ""
fi

# Detailed error analysis (if --detailed flag)
if [ $DETAILED_MODE -eq 1 ] && [ -f "$ERROR_LOG" ]; then
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}  ERROR ANALYSIS BY TYPE${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════${NC}"
    echo ""
    
    QUERY_EXCEPTIONS=$(grep -c "QueryException" "$ERROR_LOG" 2>/dev/null || echo "0")
    RUNTIME_EXCEPTIONS=$(grep -c "RuntimeException" "$ERROR_LOG" 2>/dev/null || echo "0")
    INVALID_ARG=$(grep -c "InvalidArgumentException" "$ERROR_LOG" 2>/dev/null || echo "0")
    TYPE_ERRORS=$(grep -c "TypeError" "$ERROR_LOG" 2>/dev/null || echo "0")
    ASSERTION_FAILS=$(grep -c "Failed asserting" "$ERROR_LOG" 2>/dev/null || echo "0")
    
    printf "  %-30s %4d occurrences\n" "QueryException:" $QUERY_EXCEPTIONS
    printf "  %-30s %4d occurrences\n" "RuntimeException:" $RUNTIME_EXCEPTIONS
    printf "  %-30s %4d occurrences\n" "InvalidArgumentException:" $INVALID_ARG
    printf "  %-30s %4d occurrences\n" "TypeError:" $TYPE_ERRORS
    printf "  %-30s %4d occurrences\n" "Assertion Failures:" $ASSERTION_FAILS
    
    echo ""
    echo -e "${YELLOW}Top 15 Test Files with Failures:${NC}"
    echo ""
    grep "FAILED" "$ERROR_LOG" | sed 's/.*FAILED  //' | sed 's/ >.*//' | sort | uniq -c | sort -rn | head -15 | while read count file; do
        printf "  [%2d] %s\n" "$count" "$file"
    done
    echo ""
fi

# Save progress if --save flag
if [ "$1" == "--save" ] || [ "$2" == "--save" ]; then
    echo -e "${YELLOW}Saving progress snapshot...${NC}"
    
    cat > "$PROGRESS_FILE" <<EOF
{
  "date": "$(date -Iseconds)",
  "failed": $TOTAL_FAILED,
  "passed": $TOTAL_PASSED,
  "risky": $TOTAL_RISKY,
  "skipped": $TOTAL_SKIPPED,
  "total": $TOTAL,
  "pass_rate": $PASS_RATE,
  "improvement_from_baseline": $IMPROVEMENT
}
EOF
    
    echo -e "${GREEN}Progress saved to $PROGRESS_FILE${NC}"
    echo ""
fi

# Cleanup
rm -f "$ERROR_LOG"

echo -e "${BLUE}╔════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║  Options: --save (track progress) --detailed (full report)║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════╝${NC}"
echo ""
