"""
The In-Line Blood Pressure ui class
"""
import os
from simulator.dynamicloader import DynamicLoader
from PySide2 import QtWidgets
from PySide2.QtCore import Slot
from dialin.common import Ranges
from dialin.ui import TXStates, EResponse


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):
        super().__init__(os.path.dirname(__file__))
        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.hd_simulator.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.hd_simulator.cmd_send_treatment_adjust_pressures_limit_response(
            EResponse.Accepted, 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.hd_simulator.cmd_send_treatment_adjust_pressures_limit_response(
            EResponse.Rejected, reason,
            self.spnArterialLimitLow.value(),
            self.spnArterialLimitHigh.value(),
            self.spnVenousLimitLow.value(),
            self.spnVenousLimitHigh.value()
        )
        self.lblAVPressuresAction.setText('Rejected ' + "{}".format(reason))