"""Native single-device LibreVNA service used by acquisition and device-limit queries."""

from __future__ import annotations

from dataclasses import dataclass, field

from python_app.hardware_full.librevna_backends import NativeLibreVnaBackend
from python_app.hardware_full.librevna_driver.models import SweepResult
from python_app.models.run_config_model import RadarSweepModel


@dataclass(slots=True)
class LibreVnaService:
    """Provide the native single-device API; factories select mock acquisition."""

    serial: str | None = None
    strict_protocol_version: int = 14
    backend_mode: str = "auto"
    _backend: NativeLibreVnaBackend = field(init=False, repr=False)

    def __post_init__(self) -> None:
        if self.backend_mode.strip().lower() not in {"auto", "native"}:
            raise ValueError(f"Unsupported native LibreVNA backend mode: {self.backend_mode}")
        self._backend = NativeLibreVnaBackend(self.serial, self.strict_protocol_version)

    def open(self) -> None:
        self._backend.open()

    def close(self) -> None:
        self._backend.close()

    def configure(self, sweep: RadarSweepModel) -> None:
        self._backend.configure(sweep)

    def read_device_limits(self) -> dict[str, float | int]:
        opened_here = not self._backend.is_open
        try:
            if opened_here:
                self.open()
            return self._backend.read_device_limits()
        finally:
            if opened_here:
                self.close()

    def acquire(self) -> SweepResult:
        return self._backend.acquire()