#!/bin/bash
# Comprehensive testing script
# Runs unit tests, integration tests, benchmarks, and race detection

set -e

PROJECT_ROOT="/docker/mev-beta"
cd "$PROJECT_ROOT" || exit 1

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

info() { echo -e "${BLUE}ℹ${NC} $1"; }
success() { echo -e "${GREEN}✓${NC} $1"; }
warn() { echo -e "${YELLOW}⚠${NC} $1"; }
error() { echo -e "${RED}✗${NC} $1"; }
section() { echo -e "\n${CYAN}━━━ $1 ━━━${NC}\n"; }

# Parse arguments
TEST_TYPE="${1:-all}"
VERBOSE="${2:-false}"

usage() {
    cat <<EOF
Usage: ./scripts/test.sh [type] [verbose]

Test Types:
  all          Run all tests (default)
  unit         Run unit tests only
  integration  Run integration tests
  race         Run race detector
  bench        Run benchmarks
  coverage     Generate coverage report
  pkg <name>   Test specific package

Examples:
  ./scripts/test.sh all              # Run all tests
  ./scripts/test.sh unit             # Unit tests only
  ./scripts/test.sh race             # Race detection
  ./scripts/test.sh bench            # Benchmarks
  ./scripts/test.sh pkg sequencer    # Test pkg/sequencer
  ./scripts/test.sh all true         # Verbose mode

EOF
    exit 0
}

if [ "$TEST_TYPE" = "help" ] || [ "$TEST_TYPE" = "--help" ]; then
    usage
fi

# Determine verbosity flag
VERBOSE_FLAG=""
if [ "$VERBOSE" = "true" ] || [ "$VERBOSE" = "v" ] || [ "$VERBOSE" = "-v" ]; then
    VERBOSE_FLAG="-v"
fi

echo "🧪 MEV Bot Test Suite"
echo "======================"
echo "Test Type: $TEST_TYPE"
echo "Verbose: $VERBOSE"
echo "Date: $(date)"
echo ""

# Function to run tests in container
run_test() {
    local test_cmd=$1
    local description=$2

    info "$description"

    if podman exec mev-go-dev sh -c "cd /workspace && $test_cmd"; then
        success "$description passed"
        return 0
    else
        error "$description failed"
        return 1
    fi
}

# 1. Unit Tests
run_unit_tests() {
    section "Unit Tests"

    run_test \
        "go test ./pkg/... $VERBOSE_FLAG -short -timeout 5m" \
        "Running unit tests"
}

# 2. Integration Tests
run_integration_tests() {
    section "Integration Tests"

    # Check if integration tests exist
    if ! find tests/ -name "*_integration_test.go" -o -name "integration" -type d 2>/dev/null | grep -q "."; then
        warn "No integration tests found (create tests/ directory)"
        return 0
    fi

    run_test \
        "go test ./tests/... $VERBOSE_FLAG -timeout 10m" \
        "Running integration tests"
}

# 3. Race Detection
run_race_tests() {
    section "Race Detection"

    info "Running tests with race detector (may take longer)..."

    run_test \
        "go test ./pkg/... -race -short -timeout 10m" \
        "Race detection on unit tests"
}

# 4. Benchmarks
run_benchmarks() {
    section "Benchmarks"

    info "Running benchmarks..."

    podman exec mev-go-dev sh -c "cd /workspace && go test ./pkg/... -bench=. -benchmem -run=^$ -timeout 10m" || true

    success "Benchmarks complete"
}

# 5. Coverage Report
run_coverage() {
    section "Coverage Report"

    info "Generating coverage report..."

    # Create coverage directory
    mkdir -p coverage

    # Run tests with coverage
    if podman exec mev-go-dev sh -c "cd /workspace && go test ./pkg/... -coverprofile=coverage/coverage.out -covermode=atomic"; then

        # Generate HTML report
        podman exec mev-go-dev sh -c "cd /workspace && go tool cover -html=coverage/coverage.out -o coverage/coverage.html"

        # Print summary
        COVERAGE=$(podman exec mev-go-dev sh -c "cd /workspace && go tool cover -func=coverage/coverage.out | tail -1 | awk '{print \$3}'")

        info "Total coverage: $COVERAGE"
        success "Coverage report generated: coverage/coverage.html"

        # Check coverage threshold
        COVERAGE_NUM=${COVERAGE%\%}
        if (( $(echo "$COVERAGE_NUM < 70" | bc -l) )); then
            warn "Coverage below 70% threshold"
        else
            success "Coverage above 70%"
        fi
    else
        error "Coverage generation failed"
        return 1
    fi
}

# 6. Test Specific Package
test_package() {
    local pkg_name=$1

    section "Testing Package: $pkg_name"

    run_test \
        "go test ./pkg/$pkg_name/... $VERBOSE_FLAG -timeout 5m" \
        "Testing pkg/$pkg_name"
}

# 7. Contract Tests
run_contract_tests() {
    section "Contract Tests (Foundry)"

    if [ ! -d "contracts" ]; then
        warn "No contracts directory found"
        return 0
    fi

    info "Running Foundry tests..."

    if podman exec mev-foundry sh -c "cd /workspace/contracts && forge test" 2>/dev/null; then
        success "Contract tests passed"
    else
        warn "Contract tests not available (compilation errors)"
    fi
}

# Main execution
FAILED=0

case "$TEST_TYPE" in
    all)
        run_unit_tests || FAILED=$((FAILED + 1))
        run_integration_tests || FAILED=$((FAILED + 1))
        run_race_tests || FAILED=$((FAILED + 1))
        run_contract_tests || true  # Don't fail on contract test issues
        ;;

    unit)
        run_unit_tests || FAILED=$((FAILED + 1))
        ;;

    integration)
        run_integration_tests || FAILED=$((FAILED + 1))
        ;;

    race)
        run_race_tests || FAILED=$((FAILED + 1))
        ;;

    bench)
        run_benchmarks
        ;;

    coverage)
        run_coverage || FAILED=$((FAILED + 1))
        ;;

    contracts)
        run_contract_tests || FAILED=$((FAILED + 1))
        ;;

    pkg)
        if [ -z "$2" ]; then
            error "Package name required: ./scripts/test.sh pkg <name>"
            exit 1
        fi
        test_package "$2" || FAILED=$((FAILED + 1))
        ;;

    *)
        error "Unknown test type: $TEST_TYPE"
        usage
        ;;
esac

# Summary
section "Test Summary"

if [ "$FAILED" -eq 0 ]; then
    success "✅ All tests passed!"
    exit 0
else
    error "❌ $FAILED test suite(s) failed"
    exit 1
fi