"""Live workers pass the operator's cal_path into FingerRuntime / Sensor.open."""

from __future__ import annotations

import sys
import types
from pathlib import Path

APP_ROOT = Path(__file__).resolve().parents[2]
BOX_CONFIG = APP_ROOT / "apps" / "studio" / "config" / "sensors" / "box" / "sensor.json"


class _TrackingSensor:
    opened: dict = {}

    def __init__(self, source, **kwargs):
        type(self).opened = {"source": source, **kwargs}
        self.connected = True

    def configure(self, **kwargs):
        return ()

    def get_img(self):
        return None

    def disconnect(self):
        self.connected = False


class _TrackingRuntime:
    opened: dict = {}
    tactile = types.SimpleNamespace(raw_sensor=None)
    capture = None

    @classmethod
    def open(cls, **kwargs):
        cls.opened = dict(kwargs)
        return cls()

    def warmup(self, *, color=False):
        return None

    def close(self):
        return None


def _install_fake_orisys(*, sensor_cls=None, runtime_cls=None):
    saved = {name: sys.modules.get(name) for name in ("orisys", "orisys.finger")}
    module = types.ModuleType("orisys")
    module.__version__ = "fake"
    module.Sensor = sensor_cls or _TrackingSensor
    finger = types.ModuleType("orisys.finger")
    finger.FingerRuntime = runtime_cls or _TrackingRuntime
    module.finger = finger
    sys.modules["orisys"] = module
    sys.modules["orisys.finger"] = finger
    return saved


def _restore(saved) -> None:
    for name, module in saved.items():
        if module is None:
            sys.modules.pop(name, None)
        else:
            sys.modules[name] = module


def _mode(config: Path, label: str = "fixture"):
    return types.SimpleNamespace(
        config_ref=str(config),
        label=lambda: label,
        fps=30.0,
    )


def test_sdk_worker_open_passes_cal_path(monkeypatch, tmp_path):
    from orisys_app_shared.acquisition import sdk_worker as mod

    saved = _install_fake_orisys(sensor_cls=_TrackingSensor)
    _TrackingSensor.opened = {}
    config = BOX_CONFIG if BOX_CONFIG.is_file() else tmp_path / "sensor.json"
    if not config.is_file():
        config.write_text("{}", encoding="utf-8")
    cal = tmp_path / "force_calibration.json"
    cal.write_text("{}", encoding="utf-8")
    mode = _mode(config, "box-fixture")
    try:
        monkeypatch.setattr(mod, "orisys_importable", lambda: (True, ""))
        monkeypatch.setattr(mod, "loaded_calibration_version", lambda _s: "")
        monkeypatch.setattr(mod, "loaded_path", lambda _s: None)
        monkeypatch.setattr(mod, "load_fixed_mode", lambda _ref: mode)
        worker = mod.SdkAcquisitionWorker()
        # Set the session fields the open path reads — do not start a thread.
        worker._mode = mode
        worker._video_source = 0
        worker._session_id = 1
        worker._session_cal_path = str(cal)
        worker._stop.clear()
        opened = worker._open_session(1, None)
        assert opened is not None
        assert _TrackingSensor.opened.get("cal_path") == str(cal)
        # ``start`` itself stores the path for that open.
        worker2 = mod.SdkAcquisitionWorker()
        monkeypatch.setattr(worker2, "stop", lambda: None)
        monkeypatch.setattr(worker2, "_run", lambda *_a, **_k: None)
        worker2.start(0, config_ref=config, cal_path=cal)
        assert worker2._session_cal_path == str(cal)
    finally:
        _restore(saved)


def test_finger_worker_open_passes_cal_path_and_device_id(monkeypatch, tmp_path):
    from orisys_app_shared.acquisition import finger_worker as mod

    saved = _install_fake_orisys(runtime_cls=_TrackingRuntime)
    _TrackingRuntime.opened = {}
    config = tmp_path / "sensor.json"
    config.write_text("{}", encoding="utf-8")
    cal = tmp_path / "DD02-14.json"
    cal.write_text("{}", encoding="utf-8")
    mode = _mode(config, "finger-fixture")
    try:
        monkeypatch.setattr(mod, "orisys_importable", lambda: (True, ""))
        monkeypatch.setattr(mod, "load_fixed_mode", lambda _ref: mode)
        monkeypatch.setattr(mod, "resolve_finger_export_dir", lambda _ref: None)
        monkeypatch.setattr(mod, "loaded_calibration_version", lambda _s: "")
        monkeypatch.setattr(mod, "loaded_path", lambda _s: None)
        import orisys.finger as finger_mod

        monkeypatch.setattr(finger_mod, "FingerRuntime", _TrackingRuntime)
        worker = mod.FingerAcquisitionWorker()
        worker._mode = mode
        worker._video_source = 0
        worker._session_id = 1
        worker._session_cal_path = str(cal)
        worker._session_device_id = "DD02-14"
        worker._export_dir = None
        worker._stop.clear()
        opened = worker._open_runtime(1, None)
        assert opened is not None
        assert _TrackingRuntime.opened.get("cal_path") == str(cal)
        assert _TrackingRuntime.opened.get("device_id") == "DD02-14"

        worker2 = mod.FingerAcquisitionWorker()
        monkeypatch.setattr(worker2, "stop", lambda: None)
        monkeypatch.setattr(worker2, "_run", lambda *_a, **_k: None)
        worker2.start(
            0, config_ref=config, cal_path=cal, device_id="DD02-14"
        )
        assert worker2._session_cal_path == str(cal)
        assert worker2._session_device_id == "DD02-14"
    finally:
        _restore(saved)


def test_workers_omit_cal_path_when_none_is_chosen(monkeypatch, tmp_path):
    from orisys_app_shared.acquisition import finger_worker as mod

    saved = _install_fake_orisys(runtime_cls=_TrackingRuntime)
    _TrackingRuntime.opened = {}
    config = tmp_path / "sensor.json"
    config.write_text("{}", encoding="utf-8")
    mode = _mode(config, "finger-fixture")
    try:
        monkeypatch.setattr(mod, "orisys_importable", lambda: (True, ""))
        monkeypatch.setattr(mod, "load_fixed_mode", lambda _ref: mode)
        monkeypatch.setattr(mod, "resolve_finger_export_dir", lambda _ref: None)
        monkeypatch.setattr(mod, "loaded_calibration_version", lambda _s: "")
        monkeypatch.setattr(mod, "loaded_path", lambda _s: None)
        import orisys.finger as finger_mod

        monkeypatch.setattr(finger_mod, "FingerRuntime", _TrackingRuntime)
        worker = mod.FingerAcquisitionWorker()
        worker._mode = mode
        worker._video_source = 0
        worker._session_id = 1
        worker._session_cal_path = None
        worker._session_device_id = None
        worker._export_dir = None
        worker._stop.clear()
        opened = worker._open_runtime(1, None)
        assert opened is not None
        assert "cal_path" not in _TrackingRuntime.opened
        assert "device_id" not in _TrackingRuntime.opened
    finally:
        _restore(saved)