test_scoring_algorithm.py

"""
Test script for V1 scoring algorithm functions.
This validates the core scoring logic before notebook execution.
"""

from src.contracts.common import Position
from src.contracts.timeline import (
    ChampionStats,
    DamageStats,
    Frame,
    MatchTimeline,
    ParticipantFrame,
)


def create_mock_timeline() -> MatchTimeline:
    """Create a minimal mock timeline for testing."""

    # Create mock participant frame
    champion_stats = ChampionStats(
        health=580, health_max=580, attack_damage=60, armor=35, magic_resist=32
    )

    damage_stats = DamageStats(total_damage_done_to_champions=15000, total_damage_taken=8000)

    participant_frame = ParticipantFrame(
        participant_id=1,
        champion_stats=champion_stats,
        damage_stats=damage_stats,
        current_gold=12000,
        total_gold=15000,
        level=15,
        minions_killed=180,
        jungle_minions_killed=20,
        position=Position(x=1000, y=1000),
        xp=15000,
    )

    # Create frame with events
    frame = Frame(
        timestamp=1800000,  # 30 minutes
        participant_frames={"1": participant_frame},
        events=[
            # Kill event
            {
                "type": "CHAMPION_KILL",
                "timestamp": 600000,
                "killerId": 1,
                "victimId": 6,
                "assistingParticipantIds": [2, 3],
            },
            # Dragon kill
            {
                "type": "ELITE_MONSTER_KILL",
                "timestamp": 900000,
                "killerId": 1,
                "monsterType": "DRAGON",
            },
            # Ward placed
            {
                "type": "WARD_PLACED",
                "timestamp": 300000,
                "creatorId": 1,
                "wardType": "YELLOW_TRINKET",
            },
            # Item purchased
            {
                "type": "ITEM_PURCHASED",
                "timestamp": 1200000,
                "participantId": 1,
                "itemId": 3031,  # Infinity Edge
            },
        ],
    )

    # Create timeline
    timeline = MatchTimeline(
        metadata={
            "data_version": "2",
            "match_id": "TEST_MATCH_001",
            "participants": ["test-puuid-1", "test-puuid-2"],
        },
        info={
            "frame_interval": 60000,
            "frames": [frame],
            "game_id": 123456,
            "participants": [
                {"participant_id": 1, "puuid": "test-puuid-1"},
                {"participant_id": 2, "puuid": "test-puuid-2"},
            ],
        },
    )

    return timeline


def test_combat_efficiency():
    """Test combat efficiency calculation."""
    timeline = create_mock_timeline()

    # Extract combat metrics
    kills = 0
    deaths = 0
    assists = 0

    for frame in timeline.info.frames:
        for event in frame.events:
            if event.get("type") == "CHAMPION_KILL":
                if event.get("killerId") == 1:
                    kills += 1
                if event.get("victimId") == 1:
                    deaths += 1
                if 1 in event.get("assistingParticipantIds", []):
                    assists += 1

    kda = (kills + assists) / max(deaths, 1)
    kda_score = min(kda / 10, 1.0)

    print("🎯 Combat Efficiency Test:")
    print(f"   Kills: {kills}, Deaths: {deaths}, Assists: {assists}")
    print(f"   KDA: {kda:.2f}")
    print(f"   KDA Score (normalized): {kda_score:.3f}")

    # Get damage stats
    last_frame = timeline.info.frames[-1]
    participant_frame = last_frame.participant_frames.get("1")

    if participant_frame:
        damage = participant_frame.damage_stats.total_damage_done_to_champions
        gold = participant_frame.total_gold
        damage_efficiency = damage / max(gold / 1000, 1)

        print(f"   Damage to Champions: {damage}")
        print(f"   Total Gold: {gold}")
        print(f"   Damage Efficiency: {damage_efficiency:.2f} damage per 1k gold")

    assert kills > 0, "Should have at least one kill"
    assert kda > 0, "KDA should be positive"
    print("   ✅ Combat efficiency calculation works!")
    return True


def test_economic_management():
    """Test economic management calculation."""
    timeline = create_mock_timeline()

    last_frame = timeline.info.frames[-1]
    participant_frame = last_frame.participant_frames.get("1")

    print("\n💰 Economic Management Test:")
    if participant_frame:
        game_duration_min = last_frame.timestamp / 60000
        total_cs = participant_frame.minions_killed + participant_frame.jungle_minions_killed
        cs_per_min = total_cs / game_duration_min

        print(f"   Game Duration: {game_duration_min:.1f} min")
        print(f"   Total CS: {total_cs}")
        print(f"   CS/min: {cs_per_min:.2f}")
        print(f"   Total Gold: {participant_frame.total_gold}")

        # Normalize CS efficiency
        cs_efficiency = min(cs_per_min / 10, 1.0)
        print(f"   CS Efficiency (normalized): {cs_efficiency:.3f}")

        assert cs_per_min > 0, "CS/min should be positive"
        print("   ✅ Economic management calculation works!")
        return True

    return False


def test_objective_control():
    """Test objective control calculation."""
    timeline = create_mock_timeline()

    epic_monsters = 0
    total_epic_monsters = 0

    print("\n🐉 Objective Control Test:")
    for frame in timeline.info.frames:
        for event in frame.events:
            if event.get("type") == "ELITE_MONSTER_KILL":
                total_epic_monsters += 1
                if event.get("killerId") == 1:
                    epic_monsters += 1

    participation = epic_monsters / max(total_epic_monsters, 1)

    print(f"   Epic Monsters Secured: {epic_monsters}")
    print(f"   Total Epic Monsters: {total_epic_monsters}")
    print(f"   Participation Rate: {participation:.1%}")

    assert epic_monsters > 0, "Should have secured at least one epic monster"
    print("   ✅ Objective control calculation works!")
    return True


def test_vision_control():
    """Test vision control calculation."""
    timeline = create_mock_timeline()

    wards_placed = 0

    print("\n👁️  Vision Control Test:")
    for frame in timeline.info.frames:
        for event in frame.events:
            if event.get("type") == "WARD_PLACED" and event.get("creatorId") == 1:
                wards_placed += 1

    game_duration_min = timeline.info.frames[-1].timestamp / 60000
    wards_per_min = wards_placed / game_duration_min

    print(f"   Wards Placed: {wards_placed}")
    print(f"   Wards per Min: {wards_per_min:.2f}")

    ward_placement_rate = min(wards_per_min / 2, 1.0)
    print(f"   Ward Placement Rate (normalized): {ward_placement_rate:.3f}")

    assert wards_placed > 0, "Should have placed at least one ward"
    print("   ✅ Vision control calculation works!")
    return True


def test_timeline_helper_methods():
    """Test MatchTimeline helper methods."""
    timeline = create_mock_timeline()

    print("\n🔧 Timeline Helper Methods Test:")

    # Test get_participant_by_puuid
    participant_id = timeline.get_participant_by_puuid("test-puuid-1")
    print(f"   get_participant_by_puuid: {participant_id}")
    assert participant_id == 1, "Should find participant 1"

    # Test get_events_by_type
    kill_events = timeline.get_events_by_type("CHAMPION_KILL")
    print(f"   get_events_by_type('CHAMPION_KILL'): {len(kill_events)} events")
    assert len(kill_events) > 0, "Should find kill events"

    # Test get_participant_frame_at_time
    frame = timeline.get_participant_frame_at_time(1, 1800000)
    print(f"   get_participant_frame_at_time: {frame is not None}")
    assert frame is not None, "Should find participant frame"

    # Test get_kill_participation
    kp = timeline.get_kill_participation(1)
    print(f"   get_kill_participation: {kp:.1f}%")
    assert kp >= 0, "Kill participation should be non-negative"

    print("   ✅ All helper methods work!")
    return True


def main():
    """Run all tests."""
    print("=" * 60)
    print("V1 Scoring Algorithm Core Function Tests")
    print("=" * 60)

    try:
        test_combat_efficiency()
        test_economic_management()
        test_objective_control()
        test_vision_control()
        test_timeline_helper_methods()

        print("\n" + "=" * 60)
        print("🎉 ALL TESTS PASSED!")
        print("=" * 60)
        print("\n✅ Core scoring algorithm functions validated")
        print("✅ Ready for notebook execution with real data")
        print("✅ P2 Phase deliverables confirmed working")

    except AssertionError as e:
        print(f"\n❌ TEST FAILED: {e}")
        return False
    except Exception as e:
        print(f"\n❌ UNEXPECTED ERROR: {e}")
        import traceback

        traceback.print_exc()
        return False

    return True


if __name__ == "__main__":
    success = main()
    exit(0 if success else 1)