###########################################################################
#
# Copyright (c) 2019-2021 Diality Inc. - All Rights Reserved.
#
# THIS CODE MAY NOT BE COPIED OR REPRODUCED IN ANY FORM, IN PART OR IN
# WHOLE, WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT OWNER.
#
# @file    hemodialysis_device.py
#
# @author  (last)      Dara Navaei
# @date    (last)      12-Nov-2021
# @author  (original)  Peter Lucia
# @date    (original)  02-Apr-2020
#
############################################################################
import struct

from .accelerometer import HDAccelerometer
from .air_bubbles import HDAirBubbles
from .air_trap import HDAirTrap
from .alarms import HDAlarms
from .blood_flow import HDBloodFlow
from .blood_leak import HDBloodLeak
from .buttons import HDButtons
from .calibration_record import HDCalibrationNVRecord
from .dialysate_inlet_flow import HDDialysateInletFlow
from .dialysate_outlet_flow import HDDialysateOutletFlow
from .fluid_leak import HDFluidLeak
from .pressure_occlusion import HDPressureOcclusion
from .pretreatment import HDPreTreatment
from .rtc import HDRTC
from .service_record import HDServiceNVRecords
from .switches import HDSwitches
from .temperatures import HDTemperatures
from .fans import HDFans
from .constants import NO_RESET, RESET
from .syringe_pump import HDSyringePump
from .system_record import HDSystemNVRecords
from .treatment import HDTreatment
from .ui_proxy import HDUIProxy
from .valves import HDValves
from .voltages import HDVoltages
from .watchdog import HDWatchdog
from ..common.hd_defs import HDOpModes
from .hd_events import HDEvents
from .reservoirs import HDReservoirs
from ..common.msg_defs import MsgIds, MsgFieldPositions
from ..protocols.CAN import DenaliMessage, DenaliCanMessenger, DenaliChannels
from ..utils.base import AbstractSubSystem, publish, LogManager
from ..utils.checks import check_broadcast_interval_override_ms
from ..utils.conversions import integer_to_bytearray, unsigned_short_to_bytearray


class HD(AbstractSubSystem):
    """
    Hemodialysis Device (HD) Dialin object API.
    It provides the basic interface to communicate with the HD firmware.
    """

    # HD login password
    HD_LOGIN_PASSWORD = '123'

    def __init__(self, can_interface="can0", log_level=None):
        """
        HD object provides test/service commands for the HD sub-system.

            >> hd_object = HD('can0')
            >> hd_object = HD(can_interface='can0', log_level="DEBUG")

        Possible log levels:
        ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL", "CAN_ONLY", "PRINT_ONLY"]

        @param can_interface: (str) CANBus interface name, e.g. "can0"
        @param log_level: (str) Logging level, defaults to None
        """

        super().__init__()
        self._log_manager = LogManager(log_level=log_level, log_filepath=self.__class__.__name__ + ".log")
        self.logger = self._log_manager.logger

        # Create listener
        self.can_interface = DenaliCanMessenger(can_interface=can_interface,
                                                logger=self.logger,
                                                log_can=self._log_manager.log_level == "CAN_ONLY")
        self.can_interface.start()

        # register handler for HD operation mode broadcast messages
        if self.can_interface is not None:
            channel_id = DenaliChannels.hd_sync_broadcast_ch_id
            msg_id = MsgIds.MSG_ID_HD_OP_MODE.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_hd_op_mode_sync)

        # create properties
        self.hd_operation_mode = HDOpModes.MODE_INIT.value
        self.hd_operation_sub_mode = 0
        self.hd_logged_in = False
        self.hd_set_logged_in_status(False)
        self.hd_no_transmit_msg_list = [0,0,0,0,0,0,0,0]

        # Create command groups
        self.accel = HDAccelerometer(self.can_interface, self.logger)
        self.air_bubbles = HDAirBubbles(self.can_interface, self.logger)
        self.air_trap = HDAirTrap(self.can_interface, self.logger)
        self.alarms = HDAlarms(self.can_interface, self.logger)
        self.blood_leak = HDBloodLeak(self.can_interface, self.logger)
        self.bloodflow = HDBloodFlow(self.can_interface, self.logger)
        self.buttons = HDButtons(self.can_interface, self.logger)
        self.calibration_record = HDCalibrationNVRecord(self.can_interface, self.logger)
        self.dialysate_inlet_flow = HDDialysateInletFlow(self.can_interface, self.logger)
        self.dialysate_outlet_flow = HDDialysateOutletFlow(self.can_interface, self.logger)
        self.fluid_leak = HDFluidLeak(self.can_interface, self.logger)
        self.pressure_occlusion = HDPressureOcclusion(self.can_interface, self.logger)
        self.pretreatment = HDPreTreatment(self.can_interface, self.logger)
        self.rtc = HDRTC(self.can_interface, self.logger)
        self.service_record = HDServiceNVRecords(self.can_interface, self.logger)
        self.switches = HDSwitches(self.can_interface, self.logger)
        self.syringe_pump = HDSyringePump(self.can_interface, self.logger)
        self.system_record = HDSystemNVRecords(self.can_interface, self.logger)
        self.treatment = HDTreatment(self.can_interface, self.logger)
        self.ui = HDUIProxy(self.can_interface, self.logger)
        self.valves = HDValves(self.can_interface, self.logger)
        self.voltages = HDVoltages(self.can_interface, self.logger)
        self.calibration_record = HDCalibrationNVRecord(self.can_interface, self.logger)
        self.system_record = HDSystemNVRecords(self.can_interface, self.logger)
        self.service_record = HDServiceNVRecords(self.can_interface, self.logger)
        self.switches = HDSwitches(self.can_interface, self.logger)
        self.temperatures = HDTemperatures(self.can_interface, self.logger)
        self.fans = HDFans(self.can_interface, self.logger)
        self.watchdog = HDWatchdog(self.can_interface, self.logger)
        self.hd_events = HDEvents(self.can_interface, self.logger)
        self.hd_reservoirs = HDReservoirs(self.can_interface, self.logger)

    def get_operation_mode(self):
        """
        Gets the HD operation mode

        @return: The hd operation mode
        """
        return self.hd_operation_mode

    def get_hd_logged_in(self):
        """
        Gets the logged in status of the HD

        @return: True if HD is logged in, False if not
        """
        return self.hd_logged_in

    def get_hd_blocked_msg_list(self):
        """
        Gets the current list of message IDs that HD will prevent transmission of.

        @return: List of message IDs blocked from transmission
        """
        return self.hd_no_transmit_msg_list

    @publish(["hd_logged_in"])
    def hd_set_logged_in_status(self, logged_in: bool = False):
        """
        Callback for HD logged in status change.
        @param logged_in boolean logged in status for HD
        @return: none
        """
        self.hd_logged_in = logged_in

    @publish(["hd_operation_mode"])
    def _handler_hd_op_mode_sync(self, message):
        """
        Handles published HD operation mode messages.  Current HD operation mode
        is captured for reference.

        @param message:  published HD operation mode broadcast message
        @return: None
        """
        mode = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))
        smode = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))

        self.hd_operation_mode = mode[0]
        self.hd_operation_sub_mode = smode[0]

    def cmd_log_in_to_hd(self, resend: bool = False) -> int:
        """
        Constructs and sends a login command via CAN bus.  Login required before \n
        other commands can be sent to the HD.

        @param resend: (bool) if False (default), try to login once. Otherwise, tries to login indefinitely
        @return: 1 if logged in, 0 if log in failed
        """

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_TESTER_LOGIN_REQUEST.value,
                                              payload=list(map(int, map(ord, self.HD_LOGIN_PASSWORD))))

        self.logger.debug("Logging in...")

        # Send message
        received_message = self.can_interface.send(message, resend=resend)

        if received_message is not None:
            if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1:
                self.logger.debug("Success: Logged In")
                self.hd_set_logged_in_status(True)
            else:
                self.logger.debug("Failure: Log In Failed.")
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Login Timeout!!!!")
            return False

    def cmd_hd_request_calibration_data(self) -> int:
        """
        Constructs and sends an HD calibration data request command via CAN bus.
        Constraints:
            Must be logged into HD.

        \returns response message if received, False if no response received

        @return: 1 if successful, zero otherwise

        """
        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_GET_CALIBRATION_RECORD.value)

        self.logger.debug("requesting HD calibration data.")

        # Send message
        received_message = self.can_interface.send(message)

        if received_message is not None:
            if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1:
                self.logger.debug("HD calibration data request accepted.")
            else:
                self.logger.debug("HD calibration data request failed.")
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_hd_set_operation_mode(self, new_mode: int = 0) -> int:
        """
        Constructs and sends a set operation mode request command via CAN bus.
        Constraints:
            Must be logged into HD.
            Transition from current to requested op mode must be legal.

        @param new_mode:  ID of operation mode to transition to
            HD_OP_MODE_FAULT = 0
            HD_OP_MODE_SERVICE = 1
            HD_OP_MODE_INIT_POST = 2
            HD_OP_MODE_STANDBY = 3
            HD_OP_MODE_TREATMENT_PARAMS = 4
            HD_OP_MODE_PRE_TREATMENT = 6
            HD_OP_MODE_TREATMENT = 7
            HD_OP_MODE_POST_TREATMENT = 8

        @return: 1 if successful, zero otherwise

        """

        payload = integer_to_bytearray(new_mode)

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_SET_OP_MODE_REQUEST.value,
                                              payload=payload)

        self.logger.debug("Requesting HD mode change to " + str(new_mode))

        # Send message
        received_message = self.can_interface.send(message)

        if received_message is not None:
            if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1:
                self.logger.debug("Success: Mode change accepted")
            else:
                self.logger.debug("Failure: Mode change rejected.")
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("HD mode change request Timeout!!!!")
            return False

    def cmd_hd_safety_shutdown_override(self, active: bool = True, reset: int = NO_RESET) -> int:
        """
        Constructs and sends an HD safety shutdown override command via CAN bus.
        Constraints:
            Must be logged into HD.

        \returns response message if received, False if no response received

        @param active:  boolean - True to activate safety shutdown, False to deactivate
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise

        """

        if active:
            sft = 1
        else:
            sft = 0
        rst = integer_to_bytearray(reset)
        saf = integer_to_bytearray(sft)
        payload = rst + saf

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_SAFETY_SHUTDOWN_OVERRIDE.value,
                                              payload=payload)

        self.logger.debug("overriding HD safety shutdown")

        # Send message
        received_message = self.can_interface.send(message)

        if received_message is not None:
            if received_message['message'][DenaliMessage.PAYLOAD_START_INDEX] == 1:
                self.logger.debug("Safety shutdown signal overridden")
            else:
                self.logger.debug("Safety shutdown signal override failed.")
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_hd_software_reset_request(self) -> None:
        """
        Constructs and sends an HD software reset request via CAN bus.
        Constraints:
            Must be logged into HD.

        @return: None
        """

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_SOFTWARE_RESET_REQUEST.value)

        self.logger.debug("requesting HD software reset")

        # Send message
        self.can_interface.send(message, 0)
        self.logger.debug("Sent request to HD to reset...")
        self.hd_set_logged_in_status(False)

    def cmd_op_mode_broadcast_interval_override(self, ms: int = 250, reset: int = NO_RESET):
        """
        Constructs and sends the HD operation mode broadcast interval override command
        Constraints:
            Must be logged into HD.
            Given interval must be non-zero and a multiple of the HD general task interval (50 ms).

        @param ms:  integer - interval (in ms) to override with
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        if not check_broadcast_interval_override_ms(ms):
            return False

        rst = integer_to_bytearray(reset)
        mis = integer_to_bytearray(ms)
        payload = rst + mis

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_OP_MODE_DATA_PUBLISH_INTERVAL_OVERRIDE.value,
                                              payload=payload)

        self.logger.debug("override operation mode data broadcast interval")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            if reset == RESET:
                str_res = "reset back to normal: "
            else:
                str_res = str(ms) + " ms: "
            self.logger.debug("Operation mode data broadcast interval overridden to " + str_res +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_standby_mode_broadcast_interval_override(self, ms: int = 250, reset: int = NO_RESET):
        """
        Constructs and sends the standby mode broadcast interval override command
        Constraints:
            Must be logged into HD.
            Given interval must be non-zero and a multiple of the HD general task interval (50 ms).

        @param ms:  integer - interval (in ms) to override with
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        if not check_broadcast_interval_override_ms(ms):
            return False

        rst = integer_to_bytearray(reset)
        mis = integer_to_bytearray(ms)
        payload = rst + mis

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_STANDBY_DATA_PUBLISH_INTERVAL_OVERRIDE.value,
                                              payload=payload)

        self.logger.debug("override standby mode data broadcast interval")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            if reset == RESET:
                str_res = "reset back to normal: "
            else:
                str_res = str(ms) + " ms: "
            self.logger.debug("Standby mode data broadcast interval overridden to " + str_res +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_pre_treatment_mode_broadcast_interval_override(self, ms: int = 250, reset: int = NO_RESET):
        """
        Constructs and sends the pre-treatment mode broadcast interval override command
        Constraints:
            Must be logged into HD.
            Given interval must be non-zero and a multiple of the HD general task interval (50 ms).

        @param ms:  integer - interval (in ms) to override with
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        if not check_broadcast_interval_override_ms(ms):
            return False

        rst = integer_to_bytearray(reset)
        mis = integer_to_bytearray(ms)
        payload = rst + mis

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_PRE_TREATMENT_DATA_PUBLISH_INTERVAL_OVERRIDE.value,
                                              payload=payload)

        self.logger.debug("override pre-treatment mode broadcast interval")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            if reset == RESET:
                str_res = "reset back to normal: "
            else:
                str_res = str(ms) + " ms: "
            self.logger.debug("Pre-treatment mode data broadcast interval overridden to " + str_res +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_treatment_mode_broadcast_interval_override(self, ms: int = 250, reset: int = NO_RESET):
        """
        Constructs and sends the treatment mode broadcast interval override command
        Constraints:
            Must be logged into HD.
            Given interval must be non-zero and a multiple of the HD general task interval (50 ms).

        @param ms:  integer - interval (in ms) to override with
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        if not check_broadcast_interval_override_ms(ms):
            return False

        rst = integer_to_bytearray(reset)
        mis = integer_to_bytearray(ms)
        payload = rst + mis

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_TREATMENT_DATA_PUBLISH_INTERVAL_OVERRIDE.value,
                                              payload=payload)

        self.logger.debug("override treatment mode data broadcast interval")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            if reset == RESET:
                str_res = "reset back to normal: "
            else:
                str_res = str(ms) + " ms: "
            self.logger.debug("Treatment mode data broadcast interval overridden to " + str_res +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_post_treatment_mode_broadcast_interval_override(self, ms: int = 250, reset: int = NO_RESET):
        """
        Constructs and sends the post-treatment mode broadcast interval override command
        Constraints:
            Must be logged into HD.
            Given interval must be non-zero and a multiple of the HD general task interval (50 ms).

        @param ms:  integer - interval (in ms) to override with
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        if not check_broadcast_interval_override_ms(ms):
            return False

        rst = integer_to_bytearray(reset)
        mis = integer_to_bytearray(ms)
        payload = rst + mis

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_POST_TREATMENT_DATA_PUBLISH_INTERVAL_OVERRIDE.value,
                                              payload=payload)

        self.logger.debug("override post-treatment mode data broadcast interval")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            if reset == RESET:
                str_res = "reset back to normal: "
            else:
                str_res = str(ms) + " ms: "
            self.logger.debug("Post-treatment mode data broadcast interval overridden to " + str_res +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_block_hd_message_transmissions(self, msg1: int = 0, msg2: int = 0, msg3: int = 0, msg4: int = 0,
                                           msg5: int = 0, msg6: int = 0, msg7: int = 0, msg8: int = 0):
        """
        Constructs and sends a block hd message transmission request
        Constraints:
            Must be logged into HD.

        @param msg1:  integer - 1st message ID to block HD from transmitting
        @param msg2:  integer - 2nd message ID to block HD from transmitting
        @param msg3:  integer - 3rd message ID to block HD from transmitting
        @param msg4:  integer - 4th message ID to block HD from transmitting
        @param msg5:  integer - 5th message ID to block HD from transmitting
        @param msg6:  integer - 6th message ID to block HD from transmitting
        @param msg7:  integer - 7th message ID to block HD from transmitting
        @param msg8:  integer - 8th message ID to block HD from transmitting
        @return: 1 if successful, zero otherwise
        """
        # Save blocked message(s) list
        self.hd_no_transmit_msg_list[0] = msg1
        self.hd_no_transmit_msg_list[1] = msg2
        self.hd_no_transmit_msg_list[2] = msg3
        self.hd_no_transmit_msg_list[3] = msg4
        self.hd_no_transmit_msg_list[4] = msg5
        self.hd_no_transmit_msg_list[5] = msg6
        self.hd_no_transmit_msg_list[6] = msg7
        self.hd_no_transmit_msg_list[7] = msg8
        # Build message payload
        m1 = unsigned_short_to_bytearray(msg1)
        m2 = unsigned_short_to_bytearray(msg2)
        m3 = unsigned_short_to_bytearray(msg3)
        m4 = unsigned_short_to_bytearray(msg4)
        m5 = unsigned_short_to_bytearray(msg5)
        m6 = unsigned_short_to_bytearray(msg6)
        m7 = unsigned_short_to_bytearray(msg7)
        m8 = unsigned_short_to_bytearray(msg8)
        payload = m1 + m2 + m3 + m4 + m5 + m6 + m7 + m8

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=MsgIds.MSG_ID_HD_BLOCK_MESSAGE_TRANSMISSION.value,
                                              payload=payload)

        self.logger.debug("request HD block transmission of message(s)")

        # Send message
        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            self.logger.debug("Given messages blocked." +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False