"""
The In-Line Blood Pressure ui class
"""
# Python
import os
# Qt
from PySide2 import QtWidgets
from PySide2.QtCore import Slot
# parent
from simulator.dynamicloader import DynamicLoader
# hd Simulator
from simulator.interface import SimulationInterface
from dialin.ui.hd_simulator import TXStates
# plugin specific
from dialin.common import Ranges


class Loader(DynamicLoader):
    """
    The In-Line Blood Pressure ui class
    """
    btnAVPressuresAccept: QtWidgets.QPushButton
    btnAVPressuresReject: QtWidgets.QPushButton

    lblArterialTitle: QtWidgets.QLabel
    lblVenousTitle: QtWidgets.QLabel
    lblAVPressuresAction: QtWidgets.QLabel
    lblArterialLimitLow: QtWidgets.QLabel
    lblArterialLimitHigh: QtWidgets.QLabel
    lblVenousLimitLow: QtWidgets.QLabel
    lblVenousLimitHigh: QtWidgets.QLabel

    spnAVPressuresRejectReason: QtWidgets.QSpinBox
    spnArterialLimitLow: QtWidgets.QSpinBox
    spnArterialLimitHigh: QtWidgets.QSpinBox
    spnVenousLimitLow: QtWidgets.QSpinBox
    spnVenousLimitHigh: QtWidgets.QSpinBox

    sldArterialValue: QtWidgets.QSlider
    sldVenousValue: QtWidgets.QSlider

    def __init__(self, interface: SimulationInterface):
        super().__init__(os.path.dirname(__file__), interface)
        self.saline_requested_state = TXStates.SALINE_BOLUS_STATE_IDLE

    def _init_loader(self):
        """
        finds and creates widgets
        :return: none
        """
        self.lblArterialTitle = self.find_label('lblArterialTitle')
        self.lblVenousTitle = self.find_label('lblVenousTitle')
        self.lblArterialLimitLow = self.find_label('lblArterialLimitLow')
        self.lblArterialLimitHigh = self.find_label('lblArterialLimitHigh')
        self.lblVenousLimitLow = self.find_label('lblVenousLimitLow')
        self.lblVenousLimitHigh = self.find_label('lblVenousLimitHigh')
        self.lblAVPressuresAction = self.find_label('lblAVPressuresAction')

        self.btnAVPressuresAccept = self.find_button('btnAVPressuresAccept')
        self.btnAVPressuresReject = self.find_button('btnAVPressuresReject')

        self.spnArterialLimitLow = self.find_spinbox('spnArterialLimitLow')
        self.spnArterialLimitHigh = self.find_spinbox('spnArterialLimitHigh')
        self.spnVenousLimitLow = self.find_spinbox('spnVenousLimitLow')
        self.spnVenousLimitHigh = self.find_spinbox('spnVenousLimitHigh')
        self.spnAVPressuresRejectReason = self.find_spinbox('spnAVPressuresRejectReason')

        self.sldArterialValue = self.find_slider('sldArterialValue')
        self.sldVenousValue = self.find_slider('sldVenousValue')

    def _init_widgets(self):
        """
        initializes the widgets' properties
        :return: none
        """
        self.lblArterialTitle.setText(
            f"{self.lblArterialTitle.text()} [{Ranges.ARTERIAL_PRESSURE_MINIMUM},{Ranges.ARTERIAL_PRESSURE_MAXIMUM}]"
        )
        self.lblVenousTitle.setText(
            f"{self.lblVenousTitle.text()} [{Ranges.VENOUS_PRESSURE_MINIMUM},{Ranges.VENOUS_PRESSURE_MAXIMUM}]"
        )

        self.lblArterialLimitLow.setText(f"{Ranges.ARTERIAL_PRESSURE_LOW_MIN}\n{Ranges.ARTERIAL_PRESSURE_LOW_MAX}")
        self.lblArterialLimitHigh.setText(f"{Ranges.ARTERIAL_PRESSURE_HIGH_MIN}\n{Ranges.ARTERIAL_PRESSURE_HIGH_MAX}")
        self.lblVenousLimitLow.setText(f"{Ranges.VENOUS_PRESSURE_LOW_MIN}\n{Ranges.VENOUS_PRESSURE_LOW_MAX}")
        self.lblVenousLimitHigh.setText(f"{Ranges.VENOUS_PRESSURE_HIGH_MIN}\n{Ranges.VENOUS_PRESSURE_HIGH_MAX}")

        self.sldArterialValue.setMinimum(Ranges.ARTERIAL_PRESSURE_MINIMUM)
        self.sldArterialValue.setMaximum(Ranges.ARTERIAL_PRESSURE_MAXIMUM)
        self.sldArterialValue.setValue(0)
        self.sldVenousValue.setMinimum(Ranges.VENOUS_PRESSURE_MINIMUM)
        self.sldVenousValue.setMaximum(Ranges.VENOUS_PRESSURE_MAXIMUM)
        self.sldVenousValue.setValue(0)

        self.spnArterialLimitLow.setMinimum(Ranges.ARTERIAL_PRESSURE_LOW_MIN)
        self.spnArterialLimitLow.setMaximum(Ranges.ARTERIAL_PRESSURE_LOW_MAX)
        self.spnArterialLimitLow.setValue(Ranges.ARTERIAL_PRESSURE_LOW_DEF)

        self.spnArterialLimitHigh.setMinimum(Ranges.ARTERIAL_PRESSURE_HIGH_MIN)
        self.spnArterialLimitHigh.setMaximum(Ranges.ARTERIAL_PRESSURE_HIGH_MAX)
        self.spnArterialLimitHigh.setValue(Ranges.ARTERIAL_PRESSURE_HIGH_DEF)

        self.spnVenousLimitLow.setMinimum(Ranges.VENOUS_PRESSURE_LOW_MIN)
        self.spnVenousLimitLow.setMaximum(Ranges.VENOUS_PRESSURE_LOW_MAX)
        self.spnVenousLimitLow.setValue(Ranges.VENOUS_PRESSURE_LOW_DEF)

        self.spnVenousLimitHigh.setMinimum(Ranges.VENOUS_PRESSURE_HIGH_MIN)
        self.spnVenousLimitHigh.setMaximum(Ranges.VENOUS_PRESSURE_HIGH_MAX)
        self.spnVenousLimitHigh.setValue(Ranges.VENOUS_PRESSURE_HIGH_DEF)

    def _init_connections(self):
        """
        initializes the widgets connections
        :return: none
        """
        # sending the CANBus message when slider value changed
        self.sldArterialValue.valueChanged.connect(self.do_pressures_data)
        self.sldVenousValue.valueChanged.connect(self.do_pressures_data)

        # sending the CANBus message when accepted or rejected
        self.btnAVPressuresAccept.clicked.connect(self.do_pressures_limits_accept)
        self.btnAVPressuresReject.clicked.connect(self.do_pressures_limits_reject)

    @Slot()
    def do_pressures_data(self):
        """
        sends the pressures values message with given value on the screen
        :return: none
        """
        self.interface.hd.cmd_set_pressure_occlusion_data(
            self.sldArterialValue.value(),
            self.sldVenousValue.value(),
            0, 0, 0
        )

    @Slot()
    def do_pressures_limits_accept(self):
        """
        sends the pressures values message with given value on the screen
        :return: none
        """
        # vAccepted, vReason, vArterialLow, vArterialHigh, vVenousLow, vVenousHigh
        self.interface.hd.cmd_send_treatment_adjust_pressures_limit_response(
            True, 0,
            self.spnArterialLimitLow.value(),
            self.spnArterialLimitHigh.value(),
            self.spnVenousLimitLow.value(),
            self.spnVenousLimitHigh.value()
        )
        self.lblAVPressuresAction.setText('Accepted ')

    @Slot()
    def do_pressures_limits_reject(self):
        """
        sends the pressures values message with given value on the screen
        :return: none
        """
        reason = self.spnAVPressuresRejectReason.value()
        self.interface.hd.cmd_send_treatment_adjust_pressures_limit_response(
            False, reason,
            self.spnArterialLimitLow.value(),
            self.spnArterialLimitHigh.value(),
            self.spnVenousLimitLow.value(),
            self.spnVenousLimitHigh.value()
        )
        self.lblAVPressuresAction.setText('Rejected ' + "{}".format(reason))