"""Factory for synchronized LibreVNA matrices and the shared physical mock."""

from __future__ import annotations

from typing import Protocol

from python_app.models.dataset_model import SweepCollection
from python_app.models.run_config_model import RadarSweepModel, RunConfigModel


class MatrixRadarService(Protocol):
    """Common API for radars that emit a full combo matrix per acquisition."""

    def open(self) -> None:
        """Open hardware connections."""

    def close(self) -> None:
        """Close hardware connections."""

    def configure(self, sweep: RadarSweepModel) -> None:
        """Apply sweep settings to the radar."""

    def acquire_collection(self, collection_id: int = 1) -> SweepCollection:
        """Acquire one complete virtual switch matrix in canonical combo order."""
        ...

    def recover(self) -> None:
        """Reconnect to the radar after a transient acquisition failure."""


def create_acquisition_service(config: RunConfigModel) -> MatrixRadarService:
    """Create a native matrix service or the shared single/multi mock scene."""
    if config.radar.driver_mode == "mock" and config.radar.model in {
        RunConfigModel.LIBREVNA_MODEL, RunConfigModel.LIBREVNA_MULTI_MODEL,
    }:
        from python_app.hardware_full.point_target_mock_service import PointTargetMockService

        return PointTargetMockService(config)
    if config.radar.model != RunConfigModel.LIBREVNA_MULTI_MODEL:
        raise RuntimeError("matrix radar service factory requires a matrix-mode radar.model")

    from python_app.hardware_full.multi_device_service import MultiDeviceLibreVnaService

    inner = MultiDeviceLibreVnaService(
        master_serial=config.radar.serial,
        slave_serials=list(config.radar.multi_device.slave_serials),
        force_external_reference=config.radar.multi_device.force_external_reference,
        recovery_attempts=config.radar.multi_device.recovery_attempts,
        backend_mode=config.radar.driver_mode,
        switch_substage_count=config.matrix_stimulus_switch_positions,
    )
    out_physical = config.matrix_output_switch_positions
    in_physical = config.matrix_input_switch_positions
    if out_physical <= 1 and in_physical <= 1:
        return inner

    from python_app.hardware_full.switched_matrix_radar_service import (
        SwitchedMatrixRadarService,
        build_physical_switch,
    )

    return SwitchedMatrixRadarService(
        inner=inner,
        output_switch=build_physical_switch(config.output_switch, out_physical, config.radar.driver_mode),
        input_switch=build_physical_switch(config.input_switch, in_physical, config.radar.driver_mode),
        inner_output_positions=config.matrix_virtual_output_positions,
        inner_input_positions=RunConfigModel.MULTI_DEVICE_INPUT_POSITIONS,
        settling_ms=config.runtime.settling_ms,
    )


create_matrix_radar_service = create_acquisition_service