"""Dashboard runtime bridge.

Wraps Phase2SUMOController with observers that populate DashboardState.
The existing controller is NOT modified.

Usage:
    python dashboard_runner.py [--emergency] [--steps N] [--gui]
"""

from __future__ import annotations

import argparse
import sys
import threading
from pathlib import Path

ROOT = Path(__file__).resolve().parent
SRC = ROOT / "src"
for p in (str(SRC), str(ROOT)):
    if p not in sys.path:
        sys.path.insert(0, p)

import uvicorn

from dashboard_state import state
from integration.sumo_decision_controller import Phase2SUMOController, SUMO_CMD, EMERGENCY_SUMO_CONFIG

_controller_thread: threading.Thread | None = None
_stop_flag = threading.Event()
_runner_lock = threading.Lock()


def is_simulation_running() -> bool:
    global _controller_thread
    return _controller_thread is not None and _controller_thread.is_alive()


def stop_simulation() -> bool:
    global _controller_thread
    if not is_simulation_running():
        return False
    _stop_flag.set()
    return True


def start_simulation(emergency: bool = False, steps: int = 200, gui: bool = False) -> bool:
    global _controller_thread
    with _runner_lock:
        if is_simulation_running():
            return False
        _stop_flag.clear()
        _controller_thread = threading.Thread(
            target=run_controller,
            args=(emergency, steps, gui),
            daemon=True,
        )
        _controller_thread.start()
        return True


def _build_step_observer(traci_ref: list, predictor_ref: list):
    """Returns a step observer that samples TraCI state into DashboardState."""

    def observer():
        traci = traci_ref[0]
        if traci is None:
            return
        try:
            sim_time = float(traci.simulation.getTime())
            vehicle_ids = list(traci.vehicle.getIDList())
            state.update_vehicles(len(vehicle_ids))
            state.update_system(
                "running",
                sim_time,
                prediction_available=predictor_ref[0] is not None,
            )
        except Exception:
            pass

    return observer


def _build_decision_observer(traci_ref: list):
    """Returns a decision observer that records decisions and junction state."""

    def observer(record: dict):
        state.add_decision(record)
        state.add_log("decision", **record)

        traci = traci_ref[0]
        if traci is None:
            return
        try:
            junction_id = record.get("junction")
            if junction_id:
                sim_time = float(traci.simulation.getTime())
                # Collect per-junction data
                try:
                    phase_index = traci.trafficlight.getPhase(junction_id)
                    phase_state = traci.trafficlight.getRedYellowGreenState(junction_id)
                    next_switch = traci.trafficlight.getNextSwitch(junction_id)
                    remaining = max(0.0, next_switch - sim_time)
                except Exception:
                    phase_index = None
                    phase_state = None
                    remaining = None

                safety = record.get("safety", {})
                state.update_junction(junction_id, {
                    "current_phase_index": phase_index,
                    "current_phase_state": phase_state,
                    "remaining_time": remaining,
                    "last_decision": record.get("selected") or record.get("selected_phase"),
                    "decision_method": record.get("method"),
                    "safety_approved": safety.get("approved"),
                    "safety_checks": safety.get("checks"),
                    "emergency_active": record.get("emergency_active", False),
                    "emergency_vehicle_id": record.get("emergency_vehicle_id"),
                    "simulation_time": sim_time,
                })
        except Exception:
            pass

    return observer


def run_controller(emergency: bool, steps: int, gui: bool):
    import traci as _traci

    traci_ref = [None]
    predictor_ref = [None]

    # Monkey-patch traci.start to capture the connection
    _original_start = _traci.start

    def _patched_start(cmd, **kwargs):
        result = _original_start(cmd, **kwargs)
        traci_ref[0] = _traci
        return result

    _traci.start = _patched_start

    step_obs = _build_step_observer(traci_ref, predictor_ref)
    decision_obs = _build_decision_observer(traci_ref)

    import shutil, os
    sumo_cmd = list(SUMO_CMD)
    if gui:
        gui_exe = shutil.which("sumo-gui")
        if gui_exe:
            sumo_cmd = [gui_exe, sumo_cmd[1], sumo_cmd[2]]

    if emergency:
        sumo_cmd = [sumo_cmd[0], "-c", str(EMERGENCY_SUMO_CONFIG)]

    state.add_log("system_start", mode="emergency_demo" if emergency else "normal")
    state.update_system("running", 0.0)

    controller = Phase2SUMOController(
        sumo_cmd=sumo_cmd,
        total_steps=steps,
        emergency_enabled=emergency,
        step_observer=step_obs,
        decision_observer=decision_obs,
    )

    # Patch simulation step to observe stop requests
    _orig_step = controller._simulation_step

    def _interruptible_step():
        if _stop_flag.is_set():
            raise StopIteration("Simulation stopped by user")
        _orig_step()

    controller._simulation_step = _interruptible_step

    # Patch predictor availability after build
    _orig_run = controller.run

    def _patched_run():
        try:
            _orig_run()
        except StopIteration:
            print("[dashboard_runner] Simulation cancelled early")
        finally:
            state.update_system("stopped", state.simulation_time)
            state.add_log("system_complete")

    controller.run = _patched_run
    controller.run()


def main():
    parser = argparse.ArgumentParser(description="Run dashboard + traffic controller")
    parser.add_argument("--emergency", action="store_true")
    parser.add_argument("--steps", type=int, default=200)
    parser.add_argument("--gui", action="store_true")
    parser.add_argument("--api-port", type=int, default=8000)
    parser.add_argument("--api-only", action="store_true",
                        help="Start only the API server without running SUMO")
    args = parser.parse_args()

    from dashboard_api import app

    if not args.api_only:
        start_simulation(emergency=args.emergency, steps=args.steps, gui=args.gui)

    # Run FastAPI in main thread
    uvicorn.run(app, host="0.0.0.0", port=args.api_port, log_level="warning")


if __name__ == "__main__":
    main()