"""Laser-controller setup applied before Kamil ADC acquisition.

This mirrors the legacy ``device_main`` command sequence: connect to the laser
controller, reset it, and apply either manual or variation mode per
``radar.laser_control``. The wire protocol is unchanged from the standalone tool;
only its home moved into the project.
"""

from __future__ import annotations

import logging

from python_app.models.run_config_model import RunConfigModel

logger = logging.getLogger(__name__)


def apply_kamil_adc_laser_control(config: RunConfigModel) -> bool:
    """Apply configured laser settings via the device_main command sequence.

    Returns ``True`` when settings were applied, ``False`` when laser control is
    disabled. The controller is always disconnected before returning.
    """
    laser = config.radar.laser_control
    if not laser.enabled:
        logger.debug("Kamil ADC laser control disabled; skipping")
        return False

    _validate_laser_control_config(config)

    from python_app.hardware_full.laser_control.controller import (
        DEVICE_MAIN_MESSAGE_ID,
        LaserController,
    )
    from python_app.hardware_full.laser_control.models import VariationType

    controller = LaserController(
        port=laser.port,
        pi_coeff1_p=laser.pi_coeff1_p,
        pi_coeff1_i=laser.pi_coeff1_i,
        pi_coeff2_p=laser.pi_coeff2_p,
        pi_coeff2_i=laser.pi_coeff2_i,
    )
    try:
        controller.connect()
        controller.reset()
        mode = laser.mode.strip().lower()
        logger.info("Applying Kamil ADC laser control in %s mode", mode)
        if mode == "manual":
            manual = laser.manual
            controller.set_manual_mode(
                temp1=manual.temp1,
                temp2=manual.temp2,
                current1=manual.current1,
                current2=manual.current2,
                message_id=DEVICE_MAIN_MESSAGE_ID,
            )
            return True
        if mode == "variation":
            variation = laser.variation
            try:
                variation_type = VariationType[variation.variation_type]
            except KeyError as exc:
                raise ValueError(
                    f"Unsupported radar.laser_control.variation.variation_type: {variation.variation_type}"
                ) from exc

            controller.set_manual_mode(
                temp1=variation.static_temp1,
                temp2=variation.static_temp2,
                current1=variation.static_current1,
                current2=variation.static_current2,
                message_id=DEVICE_MAIN_MESSAGE_ID,
            )
            controller.start_variation(
                variation_type=variation_type,
                params={
                    "static_temp1": variation.static_temp1,
                    "static_temp2": variation.static_temp2,
                    "static_current1": variation.static_current1,
                    "static_current2": variation.static_current2,
                    "min_value": variation.min_value,
                    "max_value": variation.max_value,
                    "step": variation.step,
                    "time_step": variation.time_step,
                    "delay_time": variation.delay_time,
                },
            )
            return True
        raise RuntimeError(f"Unsupported laser_control mode: {laser.mode}")
    finally:
        controller.disconnect()


def _validate_laser_control_config(config: RunConfigModel) -> None:
    laser = config.radar.laser_control
    if not laser.port:
        raise ValueError("radar.laser_control.port is required when laser_control is enabled")
    mode = laser.mode.strip().lower()
    if mode not in {"manual", "variation"}:
        raise ValueError("radar.laser_control.mode must be 'manual' or 'variation'")
    if mode == "variation" and not laser.variation.variation_type:
        raise ValueError("radar.laser_control.variation.variation_type is required")