from unittest.mock import Mock
from target_simulator.simulation.simulation_controller import SimulationController

class DummyComm:
    def __init__(self, use_json=False, send_results=None):
        self.is_open = True
        self._use_json_protocol = use_json
        self._send_calls = []
        self._send_results = send_results

    def send_commands(self, cmds):
        print('DummyComm.send_commands called with', cmds)
        self._send_calls.append(cmds)
        if callable(self._send_results):
            return self._send_results(cmds)
        if isinstance(self._send_results, list):
            if len(self._send_results) >= len(self._send_calls):
                return self._send_results[len(self._send_calls) - 1]
            return self._send_results[-1]
        return True

    def send_scenario(self, scenario):
        print('DummyComm.send_scenario called')
        return True

    def router(self):
        return None

class DummyCommManager:
    def __init__(self, target_comm=None):
        self.target_communicator = target_comm

class DummyHub:
    def __init__(self, active_sequence=None):
        self._seq = list(active_sequence) if active_sequence is not None else []
    def has_active_real_targets(self):
        if self._seq:
            return self._seq.pop(0)
        return False
    def reset(self): pass
    def get_ownship_state(self): return {}
    def set_simulation_origin(self, origin): pass

class DummyScenario:
    def __init__(self):
        class T:
            _total_duration_s = 5.0
        self.targets=[T()]
        self.name='dummy'
    def get_all_targets(self): return self.targets
    def reset_simulation(self): pass

class DummyMainView:
    def __init__(self):
        self.is_simulation_running = type('V', (), {'get': lambda s: False, 'set': lambda s,v: print('is_simulation_running.set', v)})()
        self.update_time = type('V', (), {'get': lambda s: 1.0})()
        self.time_multiplier = 1.0
        self.scenario = DummyScenario()
        self.ppi_widget = type('P', (), {'clear_trails': lambda s: None, 'clear_previews': lambda s: None})()
        self.sim_slider_var = type('V', (), {'get': lambda s: 0.0, 'set': lambda s,v: None})()
        self.simulation_engine = None
        self.current_archive = None
        self._start_in_progress_main = False
        self.simulation_controls = type('C', (), {'sim_slider_var': type('V', (), {'set': lambda s,v: None})(), 'show_notice': lambda *a, **k: None})()
    def _update_simulation_progress_display(self): pass
    def _update_button_states(self): pass
    def _refresh_analysis_list(self): pass
    def show_status_message(self, text, timeout_ms=None): print('show_status_message', text)
    def after(self, delay_ms, func, *args, **kwargs): return func(*args, **kwargs)
    def clear_status_message(self): pass

# patch SimulationEngine used in controller
class DummyEngine:
    def __init__(self, communicator=None, simulation_hub=None):
        self.started=False
    def set_time_multiplier(self,v): pass
    def set_update_interval(self,v): pass
    def load_scenario(self,s): print('engine.load_scenario')
    def start(self): print('engine.start called'); self.started=True
    def stop(self): self.started=False
    def is_running(self): return self.started

import target_simulator.simulation.simulation_controller as scmod
scmod.SimulationEngine = DummyEngine

comm = DummyComm(use_json=False, send_results=[True])
cm = DummyCommManager(comm)
hub = DummyHub()
controller = SimulationController(cm, hub, config_manager=None, logger=Mock())
mv = DummyMainView()
print('Calling reset directly...')
ok = controller._reset_radar_state_no_ui(mv)
print('reset returned', ok)
print('comm._send_calls after reset =', comm._send_calls)

print('\nNow calling start_simulation...')
controller.start_simulation(mv)
print('after start, mv.simulation_engine =', mv.simulation_engine)
if mv.simulation_engine:
    print('engine.is_running()', mv.simulation_engine.is_running())
print('comm._send_calls final =', comm._send_calls)