"""
Unit tests for Education Management Module (education/education_manager.py).

Tests school enrollment, education progression, focus management, extracurricular activities,
GPA calculation, and school data retrieval.

Run with: pytest tests/unit/test_education_manager.py -v
"""

import pytest
import sys
from pathlib import Path
from unittest.mock import Mock, patch, MagicMock
from datetime import date

# Add ws directory to path
ws_dir = Path(__file__).parent.parent.parent / 'ws'
sys.path.insert(0, str(ws_dir))

# Mock problematic imports before importing main modules
with patch.dict('sys.modules', {
    'messaging_style': MagicMock(),
}):
    from education.education_manager import (
        getSchools,
        getColleges,
        getMajors,
        getFocuses,
        randomFocus,
        getFocus,
        update_focus,
        getExtraCurriculars,
        randomExtraCurricular,
        setExtracurricular,
        applyForExtracurricular,
        quitExtraCurricular,
        handleEducation,
        setEducation,
        ElementarySchoolClass,
        HighSchoolClass,
        CollegeClass,
        CollegeMajorClass,
        FocusClass,
        ExtraCurricular
    )
    from core.models import ActivityRecord, EducationRecord


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

def create_minimal_person(age_years):
    """Create a minimal person object for testing without full initialization."""
    from types import SimpleNamespace
    person = SimpleNamespace()
    person.id = "test_person_id"
    person.ageYears = age_years
    person.ageHours = age_years * 365 * 24
    person.ageDays = age_years * 365
    person.firstname = "TestPerson"
    person.lastname = "TestFamily"
    person.sex = "Male"
    person.pronoun = "He"
    person.education = "None"
    person.occupation = 'preschool'
    person.elementary_school = None
    person.high_school = None
    person.college = None
    person.current_education = None
    person.activities = []
    person.activityRecords = []
    person.peakEnergy = 100  # Add for update_focus tests
    person.energy = 100  # Add for getPeakEnergy
    person.habits = []  # Add for getPeakEnergy
    person.job = None  # Add for getPeakEnergy
    person.schedules = []  # Add for getPeakEnergy
    return person


def create_minimal_player(age_years):
    """Create a minimal player object for testing without full initialization."""
    from types import SimpleNamespace
    player = SimpleNamespace()
    player.c = create_minimal_person(age_years)
    player.date = str(date.today().strftime('%m-%d'))
    player.messageQueue = []
    player.extraCurriculars = getExtraCurriculars()
    player.elementary_schools = getSchools()[0]
    player.high_schools = getSchools()[1]
    player.colleges = getColleges()
    player.majors = getMajors(player.colleges)
    return player


@pytest.fixture
def newborn_player():
    """Create a player with a newborn character (age 0)."""
    return create_minimal_player(0)


@pytest.fixture
def child_player():
    """Create a player with a child character (age 8)."""
    player = create_minimal_player(8)
    player.c.education = "3rd"
    return player


@pytest.fixture
def teen_player():
    """Create a player with a teenager character (age 16)."""
    player = create_minimal_player(16)
    player.c.education = "11th"
    return player


@pytest.fixture
def college_player():
    """Create a player with a college student character (age 19)."""
    player = create_minimal_player(19)
    player.c.education = "associate_degree"
    return player


@pytest.fixture
def enrolled_elementary_player(child_player):
    """Create a child player enrolled in elementary school."""
    child_player.c.elementary_school = child_player.elementary_schools[0]
    child_player.c.activities.append(child_player.c.elementary_school)

    # Create education record
    edu_record = EducationRecord(
        educationLevel="3rd",
        location=child_player.c.elementary_school,
        date=child_player.date
    )
    edu_record.focus = "Balanced"
    edu_record.GPA = 75
    child_player.c.activityRecords.append(edu_record)
    child_player.c.current_education = edu_record
    child_player.c.occupation = 'student'

    return child_player


@pytest.fixture
def enrolled_highschool_player(teen_player):
    """Create a teen player enrolled in high school."""
    teen_player.c.high_school = teen_player.high_schools[0]
    teen_player.c.activities.append(teen_player.c.high_school)

    # Create education record
    edu_record = EducationRecord(
        educationLevel="11th",
        location=teen_player.c.high_school,
        date=teen_player.date
    )
    edu_record.focus = "Work Hard"
    edu_record.GPA = 85
    teen_player.c.activityRecords.append(edu_record)
    teen_player.c.current_education = edu_record
    teen_player.c.occupation = 'student'

    return teen_player


# ============================================================================
# SCHOOL ENROLLMENT TESTS (6 tests)
# ============================================================================

def test_set_education_elementary_school(child_player):
    """Test enrolling a child in elementary school."""
    # Arrange
    assert child_player.c.ageYears == 8
    assert child_player.c.elementary_school is None

    # Act
    setEducation(child_player, child_player.c)

    # Assert
    assert child_player.c.elementary_school is not None
    assert child_player.c.elementary_school in child_player.elementary_schools
    assert child_player.c.occupation == 'student'
    assert child_player.c.education == "3rd"


def test_set_education_high_school(teen_player):
    """Test enrolling a teenager in high school."""
    # Arrange
    assert teen_player.c.ageYears == 16
    assert teen_player.c.high_school is None

    # Act
    setEducation(teen_player, teen_player.c)

    # Assert
    assert teen_player.c.high_school is not None
    assert teen_player.c.high_school in teen_player.high_schools
    assert teen_player.c.occupation == 'student'
    assert teen_player.c.education == "11th"


@patch('random.random')
def test_set_education_college(mock_random, college_player):
    """Test enrolling an adult in college."""
    # Arrange - ensure college enrollment
    # The logic in setEducation is: collegeRatio >= 0.6 triggers college
    # Then nested checks for continuing/doctorate
    mock_random.return_value = 0.65
    assert college_player.c.ageYears == 19
    assert college_player.c.college is None

    # Act
    setEducation(college_player, college_player.c)

    # Assert
    assert college_player.c.college is not None
    assert college_player.c.college in college_player.colleges
    assert college_player.c.occupation == 'school'
    # For age 19, could be associate_degree, bachelors_degree, or doctorate_degree
    # depending on the nested logic
    assert college_player.c.education in ["associate_degree", "college yr 3",
                                           "bachelors_degree", "doctorate_degree"]


def test_set_education_validates_age(newborn_player):
    """Test that education is set appropriately for different ages."""
    # Arrange - newborn (age 0)
    assert newborn_player.c.ageYears == 0

    # Act
    setEducation(newborn_player, newborn_player.c)

    # Assert - Age 0 gets assigned elementary school in the current code
    # (even though they shouldn't be enrolled yet - this is how the code works)
    # The code checks age < 14 for elementary, so age 0 gets elementary school assigned
    assert newborn_player.c.elementary_school is not None
    assert newborn_player.c.occupation == 'work'  # Not student until age > 4


def test_set_education_creates_education_record(child_player):
    """Test that EducationRecord is created when setting education."""
    # Arrange
    initial_record_count = len(child_player.c.activityRecords)

    # Act
    setEducation(child_player, child_player.c)

    # Assert
    assert len(child_player.c.activityRecords) > initial_record_count

    # Find the education record by checking type attribute
    edu_record = None
    for record in child_player.c.activityRecords:
        if hasattr(record, 'type') and record.type == 'education':
            edu_record = record
            break

    assert edu_record is not None
    assert hasattr(edu_record, 'educationLevel')
    assert edu_record.educationLevel == "3rd"
    assert hasattr(edu_record, 'GPA')
    assert edu_record.GPA == 75  # Default GPA
    assert edu_record.type == "education"


def test_set_education_updates_current_education(child_player):
    """Test that current_education pointer is updated."""
    # Arrange
    assert child_player.c.current_education is None

    # Act
    setEducation(child_player, child_player.c)

    # Assert
    assert child_player.c.current_education is not None
    assert hasattr(child_player.c.current_education, 'type')
    assert child_player.c.current_education.type == 'education'
    assert hasattr(child_player.c.current_education, 'educationLevel')
    assert child_player.c.current_education.educationLevel == "3rd"


# ============================================================================
# EDUCATION PROGRESSION TESTS (4 tests)
# ============================================================================

def test_handle_education_increases_gpa_with_work_hard(enrolled_elementary_player):
    """Test that GPA increases when focus is 'Work Hard'."""
    # Arrange
    enrolled_elementary_player.c.current_education.focus = 'Work Hard'
    initial_gpa = enrolled_elementary_player.c.current_education.GPA

    # Act - run multiple times to see increase
    for _ in range(50):
        handleEducation(enrolled_elementary_player.c)

    # Assert - GPA should increase on average with Work Hard focus
    final_gpa = enrolled_elementary_player.c.current_education.GPA
    assert final_gpa >= initial_gpa  # Should increase or stay same


def test_handle_education_decreases_gpa_with_slack_off(enrolled_elementary_player):
    """Test that GPA can decrease when focus is 'Slack Off'."""
    # Arrange
    enrolled_elementary_player.c.current_education.focus = 'Slack Off'
    enrolled_elementary_player.c.current_education.GPA = 75

    # Act - run multiple times
    for _ in range(50):
        handleEducation(enrolled_elementary_player.c)

    # Assert - GPA should decrease or stay same with Slack Off
    final_gpa = enrolled_elementary_player.c.current_education.GPA
    assert final_gpa <= 75  # Should decrease or stay same


def test_handle_education_gpa_boundaries(enrolled_elementary_player):
    """Test that GPA stays within 0-100 boundaries."""
    # Arrange - Test upper boundary
    enrolled_elementary_player.c.current_education.GPA = 99
    enrolled_elementary_player.c.current_education.focus = 'Work Hard'

    # Act
    for _ in range(20):
        handleEducation(enrolled_elementary_player.c)

    # Assert
    assert enrolled_elementary_player.c.current_education.GPA <= 100
    assert enrolled_elementary_player.c.current_education.GPA >= 0

    # Arrange - Test lower boundary
    enrolled_elementary_player.c.current_education.GPA = 1
    enrolled_elementary_player.c.current_education.focus = 'Slack Off'

    # Act
    for _ in range(20):
        handleEducation(enrolled_elementary_player.c)

    # Assert
    assert enrolled_elementary_player.c.current_education.GPA >= 0
    assert enrolled_elementary_player.c.current_education.GPA <= 100


def test_handle_education_balanced_focus(enrolled_elementary_player):
    """Test that Balanced focus provides moderate GPA changes."""
    # Arrange
    enrolled_elementary_player.c.current_education.focus = 'Balanced'
    enrolled_elementary_player.c.current_education.GPA = 75

    # Act
    for _ in range(30):
        handleEducation(enrolled_elementary_player.c)

    # Assert - With balanced, GPA should stay relatively stable
    final_gpa = enrolled_elementary_player.c.current_education.GPA
    assert 60 <= final_gpa <= 90  # Should stay in reasonable range


# ============================================================================
# FOCUS MANAGEMENT TESTS (3 tests)
# ============================================================================

def test_update_focus_changes_current_focus(enrolled_elementary_player):
    """Test that update_focus successfully changes activity focus."""
    # Arrange
    activity_id = enrolled_elementary_player.c.current_education.id
    original_focus = enrolled_elementary_player.c.current_education.focus
    assert original_focus == "Balanced"

    # Act
    with patch('builtins.print'):  # Suppress print statements
        update_focus(enrolled_elementary_player, activity_id, 'Work Hard')

    # Assert
    assert enrolled_elementary_player.c.current_education.focus == 'Work Hard'
    assert enrolled_elementary_player.c.current_education.focus != original_focus


def test_get_focus_returns_current_focus():
    """Test that getFocus returns the correct focus object by name."""
    # Arrange
    focus_name = 'Work Hard'

    # Act
    focus = getFocus(focus_name)

    # Assert
    assert focus is not None
    assert isinstance(focus, FocusClass)
    assert focus.focus_name == 'Work Hard'
    assert focus.id == 1
    assert focus.energyModifier == 10


def test_focus_affects_performance():
    """Test that different focus types have different energy modifiers."""
    # Arrange & Act
    work_hard = getFocus('Work Hard')
    slack_off = getFocus('Slack Off')
    socialize = getFocus('Socialize')
    balanced = getFocus('Balanced')

    # Assert
    assert work_hard.energyModifier == 10
    assert slack_off.energyModifier == -10
    assert socialize.energyModifier == 10
    assert balanced.energyModifier == 0


# ============================================================================
# EXTRACURRICULAR TESTS (4 tests)
# ============================================================================

def test_set_extracurricular_adds_activity(enrolled_elementary_player):
    """Test that setExtracurricular adds activity to person."""
    # Arrange
    extracurriculars = getExtraCurriculars()
    choir = extracurriculars[0]  # Choir
    initial_activity_count = len(enrolled_elementary_player.c.activities)
    initial_record_count = len(enrolled_elementary_player.c.activityRecords)

    # Act
    with patch('builtins.print'):  # Suppress print
        setExtracurricular(
            enrolled_elementary_player.c,
            choir,
            enrolled_elementary_player.date
        )

    # Assert
    assert len(enrolled_elementary_player.c.activities) == initial_activity_count + 1
    assert len(enrolled_elementary_player.c.activityRecords) == initial_record_count + 1
    assert choir in enrolled_elementary_player.c.activities


@patch('character.character_manager.create_classmates')
def test_apply_for_extracurricular_requires_conditions(mock_create_classmates, enrolled_elementary_player):
    """Test applying for an extracurricular activity."""
    # Arrange
    mock_create_classmates.return_value = enrolled_elementary_player
    extracurriculars = getExtraCurriculars()
    enrolled_elementary_player.extraCurriculars = extracurriculars
    choir = extracurriculars[0]

    # Act
    applyForExtracurricular(enrolled_elementary_player, choir.id)

    # Assert
    assert choir in enrolled_elementary_player.c.activities
    assert "You have applied for Choir." in enrolled_elementary_player.messageQueue
    mock_create_classmates.assert_called_once()


def test_quit_extracurricular_removes_activity(enrolled_elementary_player):
    """Test that quitting an extracurricular removes it from activities."""
    # Arrange
    extracurriculars = getExtraCurriculars()
    choir = extracurriculars[0]
    enrolled_elementary_player.extraCurriculars = extracurriculars

    # Add extracurricular first
    with patch('builtins.print'):
        setExtracurricular(
            enrolled_elementary_player.c,
            choir,
            enrolled_elementary_player.date
        )

    assert choir in enrolled_elementary_player.c.activities

    # Act
    quitExtraCurricular(enrolled_elementary_player, choir.id)

    # Assert
    assert choir not in enrolled_elementary_player.c.activities
    assert "You have quit Choir." in enrolled_elementary_player.messageQueue


def test_extracurricular_affects_stats():
    """Test that extracurriculars have energy costs."""
    # Arrange
    extracurriculars = getExtraCurriculars()

    # Act & Assert
    choir = extracurriculars[0]  # Choir
    musical_theater = extracurriculars[1]  # Musical Theater
    debate_team = extracurriculars[2]  # Debate Team

    assert choir.energyModifier == 20
    assert musical_theater.energyModifier == 30
    assert debate_team.energyModifier == 20


# ============================================================================
# GPA CALCULATION TESTS (5 tests)
# ============================================================================

def test_gpa_calculation_formula(enrolled_elementary_player):
    """Test that GPA is calculated correctly from performance."""
    # Arrange
    enrolled_elementary_player.c.current_education.GPA = 50
    enrolled_elementary_player.c.current_education.focus = 'Work Hard'

    # Act
    handleEducation(enrolled_elementary_player.c)

    # Assert - GPA should be an integer between 0 and 100
    gpa = enrolled_elementary_player.c.current_education.GPA
    assert isinstance(gpa, int)
    assert 0 <= gpa <= 100


def test_gpa_weighted_by_focus():
    """Test that focus affects GPA progression."""
    # Arrange - Set up two scenarios
    player1 = create_minimal_player(10)
    setEducation(player1, player1.c)
    player1.c.current_education.focus = 'Work Hard'
    player1.c.current_education.GPA = 50

    player2 = create_minimal_player(10)
    setEducation(player2, player2.c)
    player2.c.current_education.focus = 'Slack Off'
    player2.c.current_education.GPA = 50

    # Act - Run education for both
    for _ in range(30):
        handleEducation(player1.c)
        handleEducation(player2.c)

    # Assert - Work Hard should generally lead to higher GPA than Slack Off
    # Note: Due to randomness, we can't guarantee specific values,
    # but over many iterations, Work Hard should trend higher
    assert player1.c.current_education.GPA >= player2.c.current_education.GPA or \
           abs(player1.c.current_education.GPA - player2.c.current_education.GPA) < 20


def test_gpa_boundaries():
    """Test that GPA stays within 0.0-100 range."""
    # Arrange
    player = create_minimal_player(10)
    setEducation(player, player.c)

    # Test upper boundary
    player.c.current_education.GPA = 95
    player.c.current_education.focus = 'Work Hard'

    # Act
    for _ in range(50):
        handleEducation(player.c)

    # Assert
    assert 0 <= player.c.current_education.GPA <= 100

    # Test lower boundary
    player.c.current_education.GPA = 5
    player.c.current_education.focus = 'Slack Off'

    # Act
    for _ in range(50):
        handleEducation(player.c)

    # Assert
    assert 0 <= player.c.current_education.GPA <= 100


def test_gpa_progression_over_time_work_hard(enrolled_elementary_player):
    """Test that GPA progresses appropriately over multiple updates."""
    # Arrange
    enrolled_elementary_player.c.current_education.GPA = 60
    enrolled_elementary_player.c.current_education.focus = 'Work Hard'
    gpa_values = [60]

    # Act - Track GPA over time
    for _ in range(100):
        handleEducation(enrolled_elementary_player.c)
        gpa_values.append(enrolled_elementary_player.c.current_education.GPA)

    # Assert - GPA should generally increase with Work Hard focus
    final_gpa = gpa_values[-1]
    assert final_gpa >= 60  # Should be at least equal or higher


def test_gpa_progression_over_time_slack_off(enrolled_elementary_player):
    """Test that GPA can decrease over time with Slack Off focus."""
    # Arrange
    enrolled_elementary_player.c.current_education.GPA = 70
    enrolled_elementary_player.c.current_education.focus = 'Slack Off'
    gpa_values = [70]

    # Act - Track GPA over time
    for _ in range(100):
        handleEducation(enrolled_elementary_player.c)
        gpa_values.append(enrolled_elementary_player.c.current_education.GPA)

    # Assert - GPA should generally decrease or stay same with Slack Off
    final_gpa = gpa_values[-1]
    assert final_gpa <= 70  # Should be less than or equal


# ============================================================================
# SCHOOL DATA TESTS (4 tests)
# ============================================================================

def test_get_schools_returns_list():
    """Test that getSchools returns lists of elementary and high schools."""
    # Act
    elementary_schools, high_schools = getSchools()

    # Assert
    assert isinstance(elementary_schools, list)
    assert isinstance(high_schools, list)
    assert len(elementary_schools) == 6
    assert len(high_schools) == 6

    # Verify structure
    for school in elementary_schools:
        assert isinstance(school, ElementarySchoolClass)
        assert hasattr(school, 'title')
        assert hasattr(school, 'student_count')
        assert hasattr(school, 'energyModifier')

    for school in high_schools:
        assert isinstance(school, HighSchoolClass)
        assert hasattr(school, 'title')
        assert hasattr(school, 'GPA_avg')


def test_get_colleges_returns_list():
    """Test that getColleges returns list of colleges."""
    # Act
    colleges = getColleges()

    # Assert
    assert isinstance(colleges, list)
    assert len(colleges) == 10

    # Verify structure
    for college in colleges:
        assert isinstance(college, CollegeClass)
        assert hasattr(college, 'title')
        assert hasattr(college, 'cost')
        assert hasattr(college, 'GPA_req')
        assert hasattr(college, 'ACT_req')
        assert hasattr(college, 'specialization')


def test_get_majors_returns_list():
    """Test that getMajors returns list of college majors."""
    # Arrange
    colleges = getColleges()

    # Act
    majors = getMajors(colleges)

    # Assert
    assert isinstance(majors, list)
    assert len(majors) == 15

    # Verify structure
    for major in majors:
        assert isinstance(major, CollegeMajorClass)
        assert hasattr(major, 'title')
        assert hasattr(major, 'related_jobs')
        assert hasattr(major, 'colleges')
        assert len(major.related_jobs) > 0


def test_get_focuses_returns_list():
    """Test that getFocuses returns list of focus types."""
    # Act
    focuses = getFocuses()

    # Assert
    assert isinstance(focuses, list)
    assert len(focuses) == 4

    # Verify all focus types exist
    focus_names = [f.focus_name for f in focuses]
    assert 'Work Hard' in focus_names
    assert 'Slack Off' in focus_names
    assert 'Socialize' in focus_names
    assert 'Balanced' in focus_names

    # Verify structure
    for focus in focuses:
        assert isinstance(focus, FocusClass)
        assert hasattr(focus, 'id')
        assert hasattr(focus, 'focus_name')
        assert hasattr(focus, 'energyModifier')


# ============================================================================
# EDGE CASES TESTS (4 tests)
# ============================================================================

@patch('random.random')
def test_set_education_while_already_enrolled(mock_random, enrolled_elementary_player):
    """Test setting education when already enrolled."""
    # Arrange - Player already has education
    mock_random.return_value = 0.5
    initial_activities = len(enrolled_elementary_player.c.activities)
    initial_records = len(enrolled_elementary_player.c.activityRecords)

    # Act - Try to set education again
    setEducation(enrolled_elementary_player, enrolled_elementary_player.c)

    # Assert - Should add another school (e.g., advancing grades)
    assert len(enrolled_elementary_player.c.activityRecords) >= initial_records


def test_handle_education_without_enrollment():
    """Test that handleEducation is a no-op if not enrolled."""
    # Arrange - Create person without current_education
    person = create_minimal_person(10)
    assert person.current_education is None

    # Act - Should not raise error
    handleEducation(person)

    # Assert - No changes should occur
    assert person.current_education is None


def test_extracurricular_capacity_limits():
    """Test that extracurricular list has reasonable size."""
    # Act
    extracurriculars = getExtraCurriculars()

    # Assert - Should have 9 activities
    assert len(extracurriculars) == 9

    # Verify all are unique
    ids = [e.id for e in extracurriculars]
    assert len(ids) == len(set(ids))


def test_random_focus_returns_valid_focus():
    """Test that randomFocus returns a valid focus object."""
    # Act
    focus = randomFocus()

    # Assert
    assert focus is not None
    assert isinstance(focus, FocusClass)
    assert focus.focus_name in ['Work Hard', 'Slack Off', 'Socialize', 'Balanced']


# ============================================================================
# SCHOOL CLASS TESTS (3 tests)
# ============================================================================

def test_elementary_school_class_initialization():
    """Test ElementarySchoolClass initialization."""
    # Act
    school = ElementarySchoolClass(
        'Elementary',
        'Test Elementary',
        'Public',
        300,
        20,
        None
    )

    # Assert
    assert school.title == 'Test Elementary'
    assert school.public_private == 'Public'
    assert school.student_count == 300
    assert school.teacher_student_ratio == 20
    assert school.type == 'elementary_school'
    assert school.energyModifier == 15


def test_high_school_class_initialization():
    """Test HighSchoolClass initialization."""
    # Act
    school = HighSchoolClass(
        'High',
        'Test High School',
        'Private',
        800,
        15,
        3.5,
        None
    )

    # Assert
    assert school.title == 'Test High School'
    assert school.public_private == 'Private'
    assert school.student_count == 800
    assert school.GPA_avg == 3.5
    assert school.type == 'high_school'
    assert school.energyModifier == 20


def test_college_class_initialization():
    """Test CollegeClass initialization."""
    # Act
    college = CollegeClass(
        'College',
        'Test University',
        'Public',
        10000,
        3.0,
        25,
        'Engineering',
        15000,
        None
    )

    # Assert
    assert college.title == 'Test University'
    assert college.public_private == 'Public'
    assert college.attendance == 10000
    assert college.GPA_req == 3.0
    assert college.ACT_req == 25
    assert college.specialization == 'Engineering'
    assert college.cost == 15000
    assert college.type == 'college'
    assert college.energyModifier == 20


# ============================================================================
# SUMMARY STATISTICS
# ============================================================================
# Total tests: 33 test cases
# - School Enrollment: 6 tests
# - Education Progression: 4 tests
# - Focus Management: 3 tests
# - Extracurricular Activities: 4 tests
# - GPA Calculation: 5 tests
# - School Data Retrieval: 4 tests
# - Edge Cases: 4 tests
# - School Classes: 3 tests