#!/bin/bash

# Tester for mutex_basics exercise
# Tests mutex protection of shared variables

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

EXERCISE="mutex_basics"
EXE_PATH=""
PASSED=0
FAILED=0

# Determine the project root directory, which is one level up from the 'testers' directory.
PROJECT_ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)

echo "========================================"
echo "Testing: $EXERCISE"
echo "========================================"

# --- Find or compile the executable ---
# Priority:
# 1. rendu/executable
# 2. root/executable
# 3. rendu/source -> compile
# 4. root/source -> compile

# Define potential paths for executable and source
EXE_IN_RENDU="$PROJECT_ROOT/rendu/$EXERCISE"
EXE_IN_ROOT="$PROJECT_ROOT/$EXERCISE"
SRC_IN_RENDU="$PROJECT_ROOT/rendu/${EXERCISE}.c"
SRC_IN_ROOT="$PROJECT_ROOT/${EXERCISE}.c"

# Check for existing executable
if [ -f "$EXE_IN_RENDU" ]; then
    EXE_PATH="$EXE_IN_RENDU"
    echo -e "${YELLOW}Found executable in 'rendu' directory.${NC}"
elif [ -f "$EXE_IN_ROOT" ]; then
    EXE_PATH="$EXE_IN_ROOT"
    echo -e "${YELLOW}Found executable in root directory.${NC}"
else
    echo -e "${YELLOW}Executable not found. Attempting to compile from source...${NC}"
    COMPILE_CMD="gcc -Wall -Wextra -Werror -pthread"

    # Check for source file and compile
    if [ -f "$SRC_IN_RENDU" ]; then
        echo "Found source file in 'rendu'. Compiling..."
        if $COMPILE_CMD "$SRC_IN_RENDU" -o "$EXE_IN_RENDU"; then
            EXE_PATH="$EXE_IN_RENDU"
            echo -e "${GREEN}Compilation successful.${NC}"
        else
            echo -e "${RED}✗ Compilation failed for '$SRC_IN_RENDU'.${NC}"
            exit 1
        fi
    elif [ -f "$SRC_IN_ROOT" ]; then
        echo "Found source file in root. Compiling..."
        if $COMPILE_CMD "$SRC_IN_ROOT" -o "$EXE_IN_ROOT"; then
            EXE_PATH="$EXE_IN_ROOT"
            echo -e "${GREEN}Compilation successful.${NC}"
        else
            echo -e "${RED}✗ Compilation failed for '$SRC_IN_ROOT'.${NC}"
            exit 1
        fi
    else
        echo -e "${RED}✗ Neither executable nor source file found for '$EXERCISE'.${NC}"
        echo "Looked for:"
        echo "  - $EXE_IN_RENDU"
        echo "  - $EXE_IN_ROOT"
        echo "  - $SRC_IN_RENDU"
        echo "  - $SRC_IN_ROOT"
        exit 1
    fi
fi

echo -e "${YELLOW}Using executable at: $EXE_PATH${NC}"

# Test 1: Counter should be exactly 4000
echo -n "Test 1: Counter correctness (should be 4000)... "
OUTPUT=$(timeout 10 "$EXE_PATH" 2>&1)
EXIT_CODE=$?

if [ $EXIT_CODE -eq 0 ]; then
    COUNTER=$(echo "$OUTPUT" | grep -oP "(?i)counter.*?[:=]\s*\K\d+" | head -1)
    if [ -z "$COUNTER" ]; then
        COUNTER=$(echo "$OUTPUT" | grep -oP "\d{4}" | head -1)
    fi
    
    if [ "$COUNTER" = "4000" ]; then
        echo -e "${GREEN}✓ PASSED${NC}"
        ((PASSED++))
    else
        echo -e "${RED}✗ FAILED${NC}"
        echo "Expected counter = 4000, got: $COUNTER"
        echo "Output: $OUTPUT"
        ((FAILED++))
    fi
else
    echo -e "${RED}✗ FAILED (timeout or crash)${NC}"
    ((FAILED++))
fi

# Test 2: Run multiple times to ensure consistency
echo -n "Test 2: Consistency check (5 runs)... "
CONSISTENT=true
for i in {1..5}; do
    OUTPUT=$(timeout 10 "$EXE_PATH" 2>&1)
    COUNTER=$(echo "$OUTPUT" | grep -oP "(?i)counter.*?[:=]\s*\K\d+" | head -1)
    if [ -z "$COUNTER" ]; then
        COUNTER=$(echo "$OUTPUT" | grep -oP "\d{4}" | head -1)
    fi
    
    if [ "$COUNTER" != "4000" ]; then
        CONSISTENT=false
        break
    fi
done

if [ "$CONSISTENT" = true ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Counter value inconsistent across multiple runs"
    echo "This suggests race conditions - mutex not working properly"
    ((FAILED++))
fi

# Test 3: Check execution time is reported
echo -n "Test 3: Execution time reported... "
OUTPUT=$(timeout 10 "$EXE_PATH" 2>&1)
if echo "$OUTPUT" | grep -qiE "(time|ms|milliseconds|seconds|duration)"; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Program should print the execution time"
    ((FAILED++))
fi

# Test 4: Thread sanitizer check
if command -v gcc &> /dev/null; then
    echo -n "Test 4: Data race detection... "
    # Try to compile with thread sanitizer
    # Find the source file to compile
    SOURCE_FILE=""
    if [ -f "$PROJECT_ROOT/rendu/${EXERCISE}.c" ]; then
        SOURCE_FILE="$PROJECT_ROOT/rendu/${EXERCISE}.c"
    elif [ -f "$PROJECT_ROOT/${EXERCISE}.c" ]; then
        SOURCE_FILE="$PROJECT_ROOT/${EXERCISE}.c"
    fi

    if [ -n "$SOURCE_FILE" ]; then
        TSAN_EXE="$PROJECT_ROOT/$(basename "$EXE_PATH")_tsan"
        gcc -Wall -Wextra -Werror -pthread -fsanitize=thread -g "$SOURCE_FILE" -o "$TSAN_EXE" 2>/dev/null
        if [ $? -eq 0 ]; then
            TSAN_OUTPUT=$(timeout 15 "$TSAN_EXE" 2>&1)
            if echo "$TSAN_OUTPUT" | grep -q "WARNING: ThreadSanitizer: data race"; then
                echo -e "${RED}✗ FAILED${NC}"
                echo "Data race detected! Mutex not protecting all accesses"
                echo "$TSAN_OUTPUT" | head -20
                ((FAILED++))
            else
                echo -e "${GREEN}✓ PASSED${NC}"
                ((PASSED++))
            fi
            rm -f "$TSAN_EXE"
        else
            echo -e "${YELLOW}⊘ Could not compile with ThreadSanitizer, skipping test${NC}"
        fi
    else
        echo -e "${YELLOW}⊘ Source file ${EXERCISE}.c not found, skipping ThreadSanitizer test${NC}"
    fi
else
    echo -e "${YELLOW}⊘ Test 4: gcc not found, skipping data race test${NC}"
fi

# Test 5: Memory leak check
if command -v valgrind &> /dev/null; then
    echo -n "Test 5: Memory leak check... "
    VALGRIND_OUTPUT=$(valgrind --leak-check=full --error-exitcode=42 ./$EXERCISE 2>&1)
    if [ $? -ne 42 ]; then
        echo -e "${GREEN}✓ PASSED${NC}"
        ((PASSED++))
    else
        echo -e "${RED}✗ FAILED${NC}"
        echo "Memory leaks detected!"
        echo "$VALGRIND_OUTPUT" | grep -A 5 "LEAK SUMMARY"
        ((FAILED++))
    fi
else
    echo -e "${YELLOW}⊘ Test 5: Valgrind not installed, skipping${NC}"
fi

# Final summary
echo "----------------------------------------"
if [ $FAILED -eq 0 ]; then
    echo -e "${GREEN}Summary: All $PASSED tests passed for $EXERCISE!${NC}"
    exit 0
else
    echo -e "${RED}Summary: $FAILED out of $((PASSED + FAILED)) tests failed for $EXERCISE.${NC}"
    exit 1
fi