"""
Unit Tests for Health Events

Tests health-related events from ws/events/health/events.py including:
- Injuries: minorInjury, breakArm, sprainedAnkle
- Illnesses: minorSickness, allergySymptoms, foodPoisoning
- Medical Care: annualCheckup, dentalCavity, mentalHealthDay
- Aging/Lifestyle: firstGrayHair, backPain, eyeStrain, sleepDisorder
- Habits: lowEnergyEvent, negativeHabitEvent

Test Pattern (per TESTING_PLAN.md Section 4.4):
- test_event_triggers_at_correct_age - Event only triggers in age range
- test_event_requires_conditions - Event needs specific conditions met
- test_event_not_duplicate - Event fname not in player.events
- test_event_applies_costs_correctly - Money/energy/stats updated
- test_event_choice_consequences - Different answers -> different outcomes
"""

import pytest
import random
from unittest.mock import patch, MagicMock
from types import SimpleNamespace

from ws.core.models import playerClass, personClass
from ws.events.base import messageEvent, questionEvent, answerOption

# Import health event functions
from ws.events.health import events as health_events

minorInjury = health_events.minorInjury
minorSickness = health_events.minorSickness
breakArm = health_events.breakArm
annualCheckup = health_events.annualCheckup
allergySymptoms = health_events.allergySymptoms
dentalCavity = health_events.dentalCavity
mentalHealthDay = health_events.mentalHealthDay
sprainedAnkle = health_events.sprainedAnkle
eyeStrain = health_events.eyeStrain
backPain = health_events.backPain
firstGrayHair = health_events.firstGrayHair
sleepDisorder = health_events.sleepDisorder
foodPoisoning = health_events.foodPoisoning


# ============================================================================
# FIXTURES
# ============================================================================

@pytest.fixture
def child_player():
    """Create a player with child character (age 8)"""
    player = playerClass()
    player.c = personClass()
    player.c.firstname = "Child"
    player.c.lastname = "TestKid"
    player.c.ageYears = 8
    player.c.ageDays = 365 * 8
    player.c.energy = 100
    player.c.happiness = 75
    player.c.health = 80
    player.c.social = 50
    player.c.money = 100
    player.c.location = "home123"
    player.c.habits = []
    player.c.healthConditions = []
    player.events = set()
    player.askedQuestions = set()
    player.messageQueue = []
    player.date = "01-15"
    player.hourOfDay = 12
    player.gameSpeed = 1000
    player.previousGameSpeed = 1000
    return player


@pytest.fixture
def teen_player():
    """Create a player with teenager character (age 16)"""
    player = playerClass()
    player.c = personClass()
    player.c.firstname = "Teen"
    player.c.lastname = "TestKid"
    player.c.ageYears = 16
    player.c.ageDays = 365 * 16
    player.c.energy = 100
    player.c.happiness = 75
    player.c.health = 80
    player.c.social = 50
    player.c.money = 500
    player.c.location = "home123"
    player.c.canDrive = False
    player.c.habits = []
    player.c.healthConditions = []
    player.events = set()
    player.askedQuestions = set()
    player.messageQueue = []
    player.date = "01-15"
    player.hourOfDay = 12
    player.gameSpeed = 1000
    player.previousGameSpeed = 1000
    return player


@pytest.fixture
def adult_player():
    """Create a player with adult character (age 30)"""
    player = playerClass()
    player.c = personClass()
    player.c.firstname = "Adult"
    player.c.lastname = "TestPerson"
    player.c.ageYears = 30
    player.c.ageDays = 365 * 30
    player.c.energy = 80
    player.c.happiness = 70
    player.c.health = 75
    player.c.social = 60
    player.c.money = 2000
    player.c.stress = 30
    player.c.location = "home123"
    player.c.canDrive = True
    player.c.habits = []
    player.c.healthConditions = []
    player.events = set()
    player.askedQuestions = set()
    player.messageQueue = []
    player.date = "01-15"
    player.hourOfDay = 12
    player.gameSpeed = 1000
    player.previousGameSpeed = 1000
    return player


# ============================================================================
# INJURY EVENTS TESTS
# ============================================================================

class TestMinorInjury:
    """Test minorInjury questionEvent (ages 5-15)"""

    @patch('random.random', return_value=0.0)
    def test_minor_injury_triggers_at_correct_age(self, mock_random, child_player):
        """Event should trigger between ages 5-15"""
        child_player.c.ageYears = 8
        result = minorInjury(child_player)
        assert result is not None
        assert isinstance(result, questionEvent)
        assert "scrape" in result.message.lower() or "knee" in result.message.lower()

    @patch('random.random', return_value=0.0)
    def test_minor_injury_not_before_age(self, mock_random, child_player):
        """Event should not trigger before age 5"""
        child_player.c.ageYears = 4
        result = minorInjury(child_player)
        assert result is None

    @patch('random.random', return_value=0.0)
    def test_minor_injury_not_duplicate(self, mock_random, child_player):
        """Event should not trigger if already in askedQuestions"""
        child_player.c.ageYears = 8
        child_player.askedQuestions.add('minorInjury')
        result = minorInjury(child_player)
        assert result is None

    def test_minor_injury_answer_go_home(self, child_player):
        """Going home should add message"""
        response = {'option': 'Go home and tell your parents'}
        minorInjury(child_player, type='answer', response=response)
        assert len(child_player.messageQueue) > 0
        assert "bandaid" in child_player.messageQueue[0].lower() or "clean" in child_player.messageQueue[0].lower()

    def test_minor_injury_answer_keep_playing(self, child_player):
        """Ignoring injury should increase social"""
        child_player.c.social = 50
        response = {'option': 'Ignore it and keep playing'}
        minorInjury(child_player, type='answer', response=response)
        assert child_player.c.social == 55


class TestBreakArm:
    """Test breakArm messageEvent (ages 6+)"""

    @patch('random.random', return_value=0.0)
    def test_break_arm_triggers_at_correct_age(self, mock_random, child_player):
        """Event should trigger at age 6+"""
        child_player.c.ageYears = 8
        result = breakArm(child_player)
        assert result is not None
        assert isinstance(result, messageEvent)
        assert "broke" in result.message.lower() and "arm" in result.message.lower()

    @patch('random.random', return_value=0.0)
    def test_break_arm_not_before_age(self, mock_random, child_player):
        """Event should not trigger before age 6"""
        child_player.c.ageYears = 5
        result = breakArm(child_player)
        assert result is None

    @patch('random.random', return_value=0.0)
    def test_break_arm_not_duplicate(self, mock_random, child_player):
        """Event should not trigger if already in events"""
        child_player.c.ageYears = 8
        child_player.events.add('breakArm')
        result = breakArm(child_player)
        assert result is None


class TestSprainedAnkle:
    """Test sprainedAnkle messageEvent (ages 10-50)"""

    @patch('random.random', return_value=0.0)
    def test_sprained_ankle_triggers_at_correct_age(self, mock_random, adult_player):
        """Event should trigger between ages 10-50"""
        adult_player.c.ageYears = 25
        result = sprainedAnkle(adult_player)
        assert result is not None
        assert isinstance(result, messageEvent)

    @patch('random.random', return_value=0.0)
    def test_sprained_ankle_applies_costs(self, mock_random, adult_player):
        """Event should decrease energy and happiness"""
        adult_player.c.ageYears = 25
        adult_player.c.energy = 100
        adult_player.c.happiness = 80
        result = sprainedAnkle(adult_player)
        assert adult_player.c.energy == 85
        assert adult_player.c.happiness == 70


# ============================================================================
# ILLNESS EVENTS TESTS
# ============================================================================

class TestMinorSickness:
    """Test minorSickness questionEvent (ages 5-15)"""

    @patch('random.random', return_value=0.0)
    def test_minor_sickness_triggers_at_correct_age(self, mock_random, child_player):
        """Event should trigger between ages 5-15"""
        child_player.c.ageYears = 10
        result = minorSickness(child_player)
        assert result is not None
        assert isinstance(result, questionEvent)

    @patch('random.random', return_value=0.0)
    def test_minor_sickness_decreases_energy(self, mock_random, child_player):
        """Event should decrease energy when triggered"""
        child_player.c.ageYears = 10
        child_player.c.energy = 100
        result = minorSickness(child_player)
        assert child_player.c.energy < 100

    def test_minor_sickness_answer_rest(self, child_player):
        """Staying home should increase energy"""
        initial_energy = child_player.c.energy
        response = {'option': 'Stay home and rest'}
        minorSickness(child_player, type='answer', response=response)
        # Energy might increase by random amount
        assert len(child_player.messageQueue) > 0


class TestAllergySymptoms:
    """Test allergySymptoms messageEvent (ages 10+, spring only)"""

    @patch('random.random', return_value=0.0)
    def test_allergy_triggers_in_spring(self, mock_random, teen_player):
        """Event should trigger in spring months (March-May)"""
        teen_player.c.ageYears = 15
        teen_player.date = "03-15"  # March
        result = allergySymptoms(teen_player)
        assert result is not None
        assert isinstance(result, messageEvent)

    @patch('random.random', return_value=0.0)
    def test_allergy_not_in_winter(self, mock_random, teen_player):
        """Event should not trigger outside spring"""
        teen_player.c.ageYears = 15
        teen_player.date = "01-15"  # January
        result = allergySymptoms(teen_player)
        assert result is None

    @patch('random.random', return_value=0.0)
    def test_allergy_decreases_energy(self, mock_random, teen_player):
        """Event should decrease energy"""
        teen_player.c.ageYears = 15
        teen_player.date = "04-10"
        teen_player.c.energy = 100
        result = allergySymptoms(teen_player)
        assert teen_player.c.energy == 95


class TestFoodPoisoning:
    """Test foodPoisoning messageEvent (ages 10+)"""

    @patch('random.random', return_value=0.0)
    def test_food_poisoning_triggers_at_correct_age(self, mock_random, teen_player):
        """Event should trigger at age 10+"""
        teen_player.c.ageYears = 16
        result = foodPoisoning(teen_player)
        assert result is not None
        assert isinstance(result, messageEvent)

    @patch('random.random', return_value=0.0)
    def test_food_poisoning_applies_costs(self, mock_random, teen_player):
        """Event should decrease energy, happiness, and health"""
        teen_player.c.ageYears = 16
        teen_player.c.energy = 100
        teen_player.c.happiness = 80
        teen_player.c.health = 90
        result = foodPoisoning(teen_player)
        assert teen_player.c.energy == 70
        assert teen_player.c.happiness == 60
        assert teen_player.c.health == 80


# ============================================================================
# MEDICAL CARE EVENTS TESTS
# ============================================================================

class TestAnnualCheckup:
    """Test annualCheckup questionEvent (ages 18+)"""

    @patch('random.random', return_value=0.0)
    def test_annual_checkup_triggers_at_correct_age(self, mock_random, adult_player):
        """Event should trigger at age 18+"""
        adult_player.c.ageYears = 25
        result = annualCheckup(adult_player)
        assert result is not None
        assert isinstance(result, questionEvent)

    @patch('random.random', return_value=0.0)
    def test_annual_checkup_has_cost_options(self, mock_random, adult_player):
        """Event should have options with money costs"""
        adult_player.c.ageYears = 25
        result = annualCheckup(adult_player)
        # Check that at least one option has a cost
        has_cost = any(hasattr(opt, 'moneyCost') and opt.moneyCost > 0 for opt in result.answers)
        assert has_cost

    def test_annual_checkup_answer_yes(self, adult_player):
        """Scheduling checkup should cost money but improve health"""
        adult_player.c.money = 500
        adult_player.c.health = 70
        adult_player.c.happiness = 60
        response = {'option': 'Yes, schedule it'}
        annualCheckup(adult_player, type='answer', response=response)
        assert adult_player.c.health == 75
        assert adult_player.c.happiness == 65

    def test_annual_checkup_answer_no(self, adult_player):
        """Skipping checkup should decrease health"""
        adult_player.c.health = 70
        adult_player.c.happiness = 60
        response = {'option': 'No, skip it'}
        annualCheckup(adult_player, type='answer', response=response)
        assert adult_player.c.health == 60
        assert adult_player.c.happiness == 55


class TestDentalCavity:
    """Test dentalCavity questionEvent (ages 8+)"""

    @patch('random.random', return_value=0.0)
    def test_dental_cavity_triggers_at_correct_age(self, mock_random, child_player):
        """Event should trigger at age 8+"""
        child_player.c.ageYears = 10
        result = dentalCavity(child_player)
        assert result is not None
        assert isinstance(result, questionEvent)

    def test_dental_cavity_answer_fill_now(self, child_player):
        """Getting filling should cost money and decrease happiness"""
        child_player.c.money = 500
        child_player.c.happiness = 70
        response = {'option': 'Get it filled now'}
        dentalCavity(child_player, type='answer', response=response)
        assert child_player.c.money == 300
        assert child_player.c.happiness == 60

    def test_dental_cavity_answer_ignore(self, child_player):
        """Ignoring cavity should decrease health significantly"""
        child_player.c.health = 80
        child_player.c.happiness = 70
        response = {'option': 'Ignore it'}
        dentalCavity(child_player, type='answer', response=response)
        assert child_player.c.health == 65
        assert child_player.c.happiness == 60


class TestMentalHealthDay:
    """Test mentalHealthDay questionEvent (ages 16-65, low happiness/energy)"""

    @patch('random.random', return_value=0.0)
    def test_mental_health_day_requires_low_stats(self, mock_random, adult_player):
        """Event should require low happiness or energy"""
        adult_player.c.ageYears = 30
        adult_player.c.happiness = 25
        adult_player.c.energy = 15
        result = mentalHealthDay(adult_player)
        assert result is not None
        assert isinstance(result, questionEvent)

    @patch('random.random', return_value=0.0)
    def test_mental_health_day_not_when_happy(self, mock_random, adult_player):
        """Event should not trigger when happiness and energy are high"""
        adult_player.c.ageYears = 30
        adult_player.c.happiness = 80
        adult_player.c.energy = 90
        result = mentalHealthDay(adult_player)
        assert result is None

    def test_mental_health_day_answer_take_day_off(self, adult_player):
        """Taking day off should increase happiness and energy"""
        adult_player.c.happiness = 25
        adult_player.c.energy = 15
        response = {'option': 'Yes, take the day off'}
        mentalHealthDay(adult_player, type='answer', response=response)
        assert adult_player.c.happiness == 45
        assert adult_player.c.energy == 35

    def test_mental_health_day_answer_push_through(self, adult_player):
        """Pushing through should decrease stats further"""
        adult_player.c.happiness = 25
        adult_player.c.energy = 15
        response = {'option': 'No, push through'}
        mentalHealthDay(adult_player, type='answer', response=response)
        assert adult_player.c.energy < 15
        assert adult_player.c.happiness < 25


# ============================================================================
# AGING & LIFESTYLE EVENTS TESTS
# ============================================================================

class TestBackPain:
    """Test backPain messageEvent (ages 30+)"""

    @patch('random.random', return_value=0.0)
    def test_back_pain_triggers_at_correct_age(self, mock_random, adult_player):
        """Event should trigger at age 30+"""
        adult_player.c.ageYears = 35
        result = backPain(adult_player)
        assert result is not None
        assert isinstance(result, messageEvent)

    @patch('random.random', return_value=0.0)
    def test_back_pain_not_before_age(self, mock_random, adult_player):
        """Event should not trigger before age 30"""
        adult_player.c.ageYears = 25
        result = backPain(adult_player)
        assert result is None

    @patch('random.random', return_value=0.0)
    def test_back_pain_decreases_stats(self, mock_random, adult_player):
        """Event should decrease energy and health"""
        adult_player.c.ageYears = 35
        adult_player.c.energy = 80
        adult_player.c.health = 75
        result = backPain(adult_player)
        assert adult_player.c.energy == 75
        assert adult_player.c.health == 70


class TestFirstGrayHair:
    """Test firstGrayHair messageEvent (ages 28-45)"""

    @patch('random.random', return_value=0.0)
    def test_first_gray_hair_triggers_at_correct_age(self, mock_random, adult_player):
        """Event should trigger between ages 28-45"""
        adult_player.c.ageYears = 32
        result = firstGrayHair(adult_player)
        assert result is not None
        assert isinstance(result, messageEvent)

    @patch('random.random', return_value=0.0)
    def test_first_gray_hair_decreases_happiness(self, mock_random, adult_player):
        """Event should decrease happiness"""
        adult_player.c.ageYears = 32
        adult_player.c.happiness = 70
        result = firstGrayHair(adult_player)
        assert adult_player.c.happiness == 65


class TestEyeStrain:
    """Test eyeStrain messageEvent (ages 10+, requires screen time habit)"""

    @patch('random.random', return_value=0.0)
    def test_eye_strain_requires_screen_habit(self, mock_random, teen_player):
        """Event should require excessive screen time habit"""
        teen_player.c.ageYears = 16
        # Create a habit object
        habit = SimpleNamespace(name='excessive_screen_time')
        teen_player.c.habits = [habit]
        result = eyeStrain(teen_player)
        assert result is not None
        assert isinstance(result, messageEvent)

    @patch('random.random', return_value=0.0)
    def test_eye_strain_not_without_habit(self, mock_random, teen_player):
        """Event should not trigger without screen time habit"""
        teen_player.c.ageYears = 16
        teen_player.c.habits = []
        result = eyeStrain(teen_player)
        assert result is None


class TestSleepDisorder:
    """Test sleepDisorder questionEvent (ages 18+, low energy)"""

    @patch('random.random', return_value=0.0)
    def test_sleep_disorder_requires_low_energy(self, mock_random, adult_player):
        """Event should require low energy"""
        adult_player.c.ageYears = 25
        adult_player.c.energy = 25
        result = sleepDisorder(adult_player)
        assert result is not None
        assert isinstance(result, questionEvent)

    def test_sleep_disorder_answer_see_doctor(self, adult_player):
        """Seeing doctor should cost money but improve energy significantly"""
        adult_player.c.money = 500
        adult_player.c.energy = 25
        adult_player.c.health = 70
        response = {'option': 'See a doctor'}
        sleepDisorder(adult_player, type='answer', response=response)
        assert adult_player.c.money == 350
        assert adult_player.c.energy == 45
        assert adult_player.c.health == 80

    def test_sleep_disorder_answer_suffer(self, adult_player):
        """Suffering through should decrease stats"""
        adult_player.c.energy = 25
        adult_player.c.happiness = 50
        response = {'option': 'Suffer through it'}
        sleepDisorder(adult_player, type='answer', response=response)
        assert adult_player.c.energy == 15
        assert adult_player.c.happiness == 40


# ============================================================================
# SUMMARY
# ============================================================================
"""
Test Summary:
=============

Injury Events (3 events):
- minorInjury (5 tests)
- breakArm (3 tests)
- sprainedAnkle (2 tests)

Illness Events (3 events):
- minorSickness (3 tests)
- allergySymptoms (3 tests)
- foodPoisoning (2 tests)

Medical Care Events (3 events):
- annualCheckup (4 tests)
- dentalCavity (3 tests)
- mentalHealthDay (4 tests)

Aging & Lifestyle Events (4 events):
- backPain (3 tests)
- firstGrayHair (2 tests)
- eyeStrain (2 tests)
- sleepDisorder (4 tests)

Total: 13 health event functions tested with 43 test cases

Test Coverage:
- Age range validation
- Condition requirements (habits, energy, health, dates)
- Duplicate prevention
- Cost/stat application
- Choice consequences
- Treatment vs. ignoring outcomes
"""