"""Simulator logic tests."""

import sys
import os
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from services.simulator import (
    create_demo_venue,
    create_demo_queue_stations,
    create_demo_event,
    Simulator,
    PHASE_PROFILES,
)
from services.crowd_service import CrowdService
from services.queue_service import QueueService
from services.notification_service import NotificationService


def _make_simulator():
    """Create a simulator for testing."""
    venue = create_demo_venue()
    event = create_demo_event()
    crowd = CrowdService()
    queue = QueueService()
    notif = NotificationService()

    stations = create_demo_queue_stations()
    queue.register_stations(stations)

    return Simulator(venue, queue, crowd, notif, event)


class TestDemoData:
    """Test demo data creation."""

    def test_venue_has_zones(self):
        venue = create_demo_venue()
        assert len(venue.zones) > 10
        assert venue.name == "Wankhede Stadium"
        assert venue.total_capacity == 50000

    def test_venue_zones_have_coordinates(self):
        venue = create_demo_venue()
        for zone in venue.zones:
            assert zone.lat != 0 or zone.lng != 0

    def test_queue_stations_created(self):
        stations = create_demo_queue_stations()
        assert len(stations) > 10
        categories = set(s.category for s in stations)
        assert "food" in categories
        assert "restroom" in categories
        assert "entry" in categories

    def test_event_created(self):
        event = create_demo_event()
        assert "IPL" in event.name
        assert event.sport == "Cricket"


class TestSimulator:
    """Test simulation engine."""

    def test_single_tick(self):
        sim = _make_simulator()
        sim.tick()
        # After a tick, venue should have some crowd
        assert sim.venue.total_current > 0

    def test_multiple_ticks(self):
        sim = _make_simulator()
        for _ in range(5):
            sim.tick()
        assert sim._tick_count == 5

    def test_phase_change(self):
        sim = _make_simulator()
        sim.set_phase("halftime")
        assert sim.event.current_phase == "halftime"

    def test_all_phases_valid(self):
        for phase in PHASE_PROFILES:
            sim = _make_simulator()
            sim.set_phase(phase)
            sim.tick()
            # Should not crash for any phase

    def test_speed_control(self):
        sim = _make_simulator()
        sim.set_speed(2.0)
        assert sim._speed == 2.0

    def test_speed_clamped(self):
        sim = _make_simulator()
        sim.set_speed(100)
        assert sim._speed == 10.0
        sim.set_speed(0)
        assert sim._speed == 0.1

    def test_status_output(self):
        sim = _make_simulator()
        sim.tick()
        status = sim.get_status()
        assert "running" in status
        assert "phase" in status
        assert "tick_count" in status
        assert "venue_occupancy" in status

    def test_callback_fires(self):
        sim = _make_simulator()
        called = []
        sim.set_update_callback(lambda: called.append(True))
        sim.tick()
        assert len(called) == 1

    def test_halftime_increases_food_queues(self):
        sim = _make_simulator()
        sim.set_phase("halftime")
        for _ in range(10):
            sim.tick()

        # During halftime, food queues should be busy
        food_stations = [
            s for s in sim.queue_service._stations.values()
            if s.category == "food"
        ]
        total_in_food = sum(s.current_length for s in food_stations)
        assert total_in_food > 0