#!/bin/bash

# Tester for process_philosophers exercise
# Tests complete philosophers implementation with processes and semaphores

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

EXERCISE="process_philosophers"
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 "========================================"

# --- Compilation and Executable Finding Logic ---
EXE_PATH="$PROJECT_ROOT/$EXERCISE"
RENDU_EXE_PATH="$PROJECT_ROOT/rendu/$EXERCISE"
SOURCE_FILE="$PROJECT_ROOT/${EXERCISE}.c"
RENDU_SOURCE_FILE="$PROJECT_ROOT/rendu/${EXERCISE}.c"

# Prefer executable in 'rendu' directory
if [ -f "$RENDU_EXE_PATH" ]; then
    EXE_PATH="$RENDU_EXE_PATH"
# Fallback to root directory executable
elif [ -f "$EXE_PATH" ]; then
    : # EXE_PATH is already set correctly
# If no executable, try to compile from source
else
    COMPILE_CANDIDATE=""
    if [ -f "$RENDU_SOURCE_FILE" ]; then
        COMPILE_CANDIDATE="$RENDU_SOURCE_FILE"
    elif [ -f "$SOURCE_FILE" ]; then
        COMPILE_CANDIDATE="$SOURCE_FILE"
    fi

    if [ -n "$COMPILE_CANDIDATE" ]; then
        echo -e "${YELLOW}Executable not found, attempting to compile from $COMPILE_CANDIDATE...${NC}"
        gcc -Wall -Wextra -Werror -pthread "$COMPILE_CANDIDATE" -o "$PROJECT_ROOT/$EXERCISE"
        if [ $? -eq 0 ]; then
            echo -e "${GREEN}✓ Compilation successful.${NC}"
            EXE_PATH="$PROJECT_ROOT/$EXERCISE" # Use the newly compiled executable
        else
            echo -e "${RED}✗ Compilation failed.${NC}"
            exit 1
        fi
    else
        echo -e "${RED}✗ Executable and source file for '$EXERCISE' not found.${NC}"
        exit 1
    fi
fi
echo -e "${YELLOW}Using executable at: $EXE_PATH${NC}"
# --- End of Logic ---

# Test 1: Basic execution with valid arguments (5 800 200 200 7)
echo -n "Test 1: Basic execution (5 philos, should complete)... "
OUTPUT=$(timeout 15 "$EXE_PATH" 5 800 200 200 7 2>&1)
EXIT_CODE=$?
if [ $EXIT_CODE -eq 0 ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Program failed or timed out (exit code: $EXIT_CODE)"
    ((FAILED++))
fi

# Test 2: Correct number of philosophers
echo -n "Test 2: Correct number of philosophers... "
PHILO_COUNT=$(echo "$OUTPUT" | grep -oE "Philosopher [0-9]+" | sort -u | wc -l)
if [ "$PHILO_COUNT" -eq 5 ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Expected 5 philosophers, found: $PHILO_COUNT"
    ((FAILED++))
fi

# Test 3: All actions present (fork, eating, sleeping, thinking)
echo -n "Test 3: All actions present... "
HAS_FORK=$(echo "$OUTPUT" | grep -c "taken a fork")
HAS_EAT=$(echo "$OUTPUT" | grep -c "is eating")
HAS_SLEEP=$(echo "$OUTPUT" | grep -c "is sleeping")
HAS_THINK=$(echo "$OUTPUT" | grep -c "is thinking")

if [ "$HAS_FORK" -gt 0 ] && [ "$HAS_EAT" -gt 0 ] && [ "$HAS_SLEEP" -gt 0 ] && [ "$HAS_THINK" -gt 0 ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Missing actions - fork:$HAS_FORK eat:$HAS_EAT sleep:$HAS_SLEEP think:$HAS_THINK"
    ((FAILED++))
fi

# Test 4: Each philosopher eats required number of times
echo -n "Test 4: Each philosopher eats 7 times... "
ALL_ATE_ENOUGH=true
for i in 1 2 3 4 5; do
    EAT_COUNT=$(echo "$OUTPUT" | grep "Philosopher $i" | grep -c "is eating")
    if [ "$EAT_COUNT" -lt 7 ]; then
        ALL_ATE_ENOUGH=false
        echo -e "${RED}✗ FAILED${NC}"
        echo "Philosopher $i ate only $EAT_COUNT times (expected 7)"
        ((FAILED++))
        break
    fi
done
if [ "$ALL_ATE_ENOUGH" = true ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
fi

# Test 5: Timestamps are present and increasing
echo -n "Test 5: Timestamps present and valid... "
if echo "$OUTPUT" | grep -qE "\[[0-9]+\]"; then
    # Extract first and last timestamp
    FIRST_TS=$(echo "$OUTPUT" | grep -oE "\[[0-9]+\]" | head -1 | tr -d '[]')
    LAST_TS=$(echo "$OUTPUT" | grep -oE "\[[0-9]+\]" | tail -1 | tr -d '[]')
    if [ "$LAST_TS" -gt "$FIRST_TS" ]; then
        echo -e "${GREEN}✓ PASSED${NC} (${FIRST_TS}ms -> ${LAST_TS}ms)"
        ((PASSED++))
    else
        echo -e "${RED}✗ FAILED${NC}"
        echo "Timestamps not increasing properly"
        ((FAILED++))
    fi
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "No timestamps found in output"
    ((FAILED++))
fi

# Test 6: No philosopher should die (with 5 800 200 200 7)
echo -n "Test 6: No philosopher dies (5 800 200 200 7)... "
if echo "$OUTPUT" | grep -q "died"; then
    echo -e "${RED}✗ FAILED${NC}"
    echo "A philosopher died when none should have"
    ((FAILED++))
else
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
fi

# Test 7: Death detection (4 310 200 100 should die)
echo -n "Test 7: Death detection (4 310 200 100)... "
OUTPUT_DEATH=$(timeout 5 "$EXE_PATH" 4 310 200 100 2>&1)
if echo "$OUTPUT_DEATH" | grep -q "died"; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Expected a philosopher to die with tight timing"
    ((FAILED++))
fi

# Test 8: Single philosopher case (should not eat - only one fork)
echo -n "Test 8: Single philosopher (1 800 200 200)... "
OUTPUT_SINGLE=$(timeout 3 "$EXE_PATH" 1 800 200 200 2>&1)
SINGLE_EXIT=$?
# Single philosopher should die (can't eat with one fork)
if echo "$OUTPUT_SINGLE" | grep -q "died"; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${YELLOW}⚠ PARTIAL${NC}"
    echo "Single philosopher handling may vary"
    ((PASSED++))
fi

# Test 9: Invalid arguments handling
echo -n "Test 9: Invalid arguments handling... "
timeout 2 "$EXE_PATH" 0 800 200 200 2>&1 > /dev/null
EXIT1=$?
timeout 2 "$EXE_PATH" -5 800 200 200 2>&1 > /dev/null
EXIT2=$?
timeout 2 "$EXE_PATH" abc 800 200 200 2>&1 > /dev/null
EXIT3=$?

if [ $EXIT1 -ne 0 ] && [ $EXIT2 -ne 0 ] && [ $EXIT3 -ne 0 ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Program should reject invalid arguments"
    ((FAILED++))
fi

# Test 10: No zombie processes
echo -n "Test 10: No zombie processes... "
"$EXE_PATH" 3 800 200 200 5 > /dev/null 2>&1 &
PARENT_PID=$!
sleep 2
ZOMBIE_COUNT=$(ps aux | grep "$PARENT_PID" | grep -c "defunct" || echo "0")
wait $PARENT_PID 2>/dev/null
sleep 1
ZOMBIE_COUNT_AFTER=$(ps aux | grep "defunct" | grep -c "$EXERCISE" || echo "0")
if [ "$ZOMBIE_COUNT" -eq 0 ] && [ "$ZOMBIE_COUNT_AFTER" -eq 0 ]; then
    echo -e "${GREEN}✓ PASSED${NC}"
    ((PASSED++))
else
    echo -e "${RED}✗ FAILED${NC}"
    echo "Found zombie processes"
    ((FAILED++))
fi

# Test 11: Check for memory leaks with valgrind (short run)
if command -v valgrind &> /dev/null; then
    echo -n "Test 11: Memory leak check... "
    VALGRIND_OUTPUT=$(valgrind --leak-check=full --error-exitcode=42 --trace-children=yes "$EXE_PATH" 3 800 200 200 2 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 11: Valgrind not installed, skipping memory test${NC}"
fi

# Summary
echo "========================================"
echo -e "Results: ${GREEN}$PASSED passed${NC}, ${RED}$FAILED failed${NC}"
echo "========================================"

if [ $FAILED -eq 0 ]; then
    exit 0
else
    exit 1
fi