from DialIn.CoreCANProtocol import (DenaliMessage,
                                    DenaliChannels)
import struct
from utils import integer_to_byte_array, RESET


class HDAlarms:
    """
    \class HD_Alarms

    \brief Hemodialysis Device (HD) Dialin API sub-class for alarm related commands.
    """

    # alarms message IDs
    MSG_ID_HD_ALARMS_PUBLISHED_STATUS = 0x0002
    MSG_ID_HD_ALARM_ACTIVATE = 0x0003
    MSG_ID_HD_ALARM_CLEAR = 0x0004
    MSG_ID_HD_ALARM_LAMP_OVERRIDE = 0x8004
    MSG_ID_HD_ALARM_STATE_OVERRIDE = 0x8006
    MSG_ID_HD_ALARM_TIME_OVERRIDE = 0x8007

    # Alarm lamp patterns
    HD_ALARM_LAMP_PATTERN_OFF = 0
    HD_ALARM_LAMP_PATTERN_OK = 1
    HD_ALARM_LAMP_PATTERN_FAULT = 2
    HD_ALARM_LAMP_PATTERN_HIGH = 3
    HD_ALARM_LAMP_PATTERN_MEDIUM = 4
    HD_ALARM_LAMP_PATTERN_LOW = 5
    HD_ALARM_LAMP_PATTERN_MANUAL = 6

    # Alarm status message field positions
    START_POS_ALARM_STATE = DenaliMessage.PAYLOAD_START_INDEX
    END_POS_ALARM_STATE = START_POS_ALARM_STATE + 4
    START_POS_ALARM_TOP = END_POS_ALARM_STATE
    END_POS_ALARM_TOP = START_POS_ALARM_TOP + 4
    START_POS_ALARM_SILENCE_EXPIRES_IN = END_POS_ALARM_TOP
    END_POS_ALARM_SILENCE_EXPIRES_IN = START_POS_ALARM_SILENCE_EXPIRES_IN + 4
    START_POS_ALARM_ESCALATES_IN = END_POS_ALARM_SILENCE_EXPIRES_IN
    END_POS_ALARM_ESCALATES_IN = START_POS_ALARM_ESCALATES_IN + 4
    START_POS_ALARMS_FLAGS = END_POS_ALARM_ESCALATES_IN
    END_POS_ALARMS_FLAGS = START_POS_ALARMS_FLAGS + 2

    START_POS_ALARM_ID = DenaliMessage.PAYLOAD_START_INDEX
    END_POS_ALARM_ID = START_POS_ALARM_ID + 2

    def __init__(self, can_interface):
        """
        HD_Alarms constructor

        \param outer_instance: reference to the HD (outer) class.

        \returns HD_Alarms object.
        """
        self.can_interface = can_interface

        if self.can_interface is not None:
            channel_id = DenaliChannels.hd_alarm_broadcast_ch_id
            msg_id = self.MSG_ID_HD_ALARMS_PUBLISHED_STATUS
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self.handler_alarms_status_sync)

            channel_id = DenaliChannels.hd_alarm_broadcast_ch_id
            msg_id = self.MSG_ID_HD_ALARM_ACTIVATE
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self.handler_alarm_activate)
            channel_id = DenaliChannels.hd_alarm_broadcast_ch_id
            msg_id = self.MSG_ID_HD_ALARM_CLEAR
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self.handler_alarm_clear)

        # composite alarm status based on latest HD alarm status broadcast message
        self.alarms_state = 0
        self.alarm_top = 0
        self.alarms_silence_expires_in = 0
        self.alarms_escalates_in = 0
        self.alarms_flags = 0

        # alarm states based on received HD alarm activation and alarm clear messages
        self.alarm_states = [False] * 50

    def handler_alarms_status_sync(self, message):
        """
        Handles published alarms status messages.  alarms status data are captured
        for reference.

        \param message:  published blood flow data message
        \returns none
        """

        self.alarms_state = int.from_bytes(bytearray(
            message['message'][self.START_POS_ALARM_STATE:self.END_POS_ALARM_STATE]),
            byteorder=DenaliMessage.BYTE_ORDER)
        self.alarm_top = int.from_bytes(bytearray(
            message['message'][self.START_POS_ALARM_TOP:self.END_POS_ALARM_TOP]),
            byteorder=DenaliMessage.BYTE_ORDER)
        self.alarms_silence_expires_in = int.from_bytes(bytearray(
            message['message'][self.START_POS_ALARM_SILENCE_EXPIRES_IN:self.END_POS_ALARM_SILENCE_EXPIRES_IN]),
            byteorder=DenaliMessage.BYTE_ORDER)
        self.alarms_escalates_in = int.from_bytes(bytearray(
            message['message'][self.START_POS_ALARM_ESCALATES_IN:self.END_POS_ALARM_ESCALATES_IN]),
            byteorder=DenaliMessage.BYTE_ORDER)
        self.alarms_flags = int.from_bytes(bytearray(
            message['message'][self.START_POS_ALARMS_FLAGS:self.END_POS_ALARMS_FLAGS]),
            byteorder=DenaliMessage.BYTE_ORDER)

    def handler_alarm_activate(self, message):
        """
        Handles published HD alarm activation messages.

        \param message:  published HD alarm activation message
        \returns none
        """

        alarm_id = struct.unpack('<H', bytearray(message['message'][self.START_POS_ALARM_ID:self.END_POS_ALARM_ID]))
        self.alarm_states[alarm_id[0]] = True

    def handler_alarm_clear(self, message):
        """
        Handles published HD alarm clear messages.

        \param message:  published HD alarm clear message
        \returns none
        """

        alarm_id = struct.unpack('<H', bytearray(message['message'][self.START_POS_ALARM_ID:self.END_POS_ALARM_ID]))
        self.alarm_states[alarm_id[0]] = False

    def cmd_alarm_state_override(self, reset, state, alarm):
        """
        Constructs and sends the alarm state override command

        \param reset:  integer - 1 to reset a previous override, 0 to override
        \param state:  integer - 1 for alarm active, 0 for alarm inactive
        \param alarm:  integer - ID of alarm to override
        \returns 1 if successful, zero otherwise
        """

        rst = integer_to_byte_array(reset)
        sta = integer_to_byte_array(state)
        alm = integer_to_byte_array(alarm)
        payload = rst + sta + alm

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_ALARM_STATE_OVERRIDE,
                                              payload=payload)

        print("override alarm state")

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

        # If there is content...
        if received_message is not None:
            # print(received_message)
            if reset == RESET:
                str_res = "reset back to normal"
            else:
                str_res = ("active" if state != 0 else "inactive")
            print("Alarm state 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:
            print("Timeout!!!!")
            return False

    def cmd_alarm_time_override(self, reset, time_ms, alarm):
        """
        Constructs and sends the alarm time override command

        \param reset:  integer - 1 to reset a previous override, 0 to override
        \param time_ms:  integer - time (in ms) since alarm was activated
        \param alarm:  integer - ID of alarm to override
        \returns 1 if successful, zero otherwise
        """

        rst = integer_to_byte_array(reset)
        ms = integer_to_byte_array(time_ms)
        alm = integer_to_byte_array(alarm)
        payload = rst + ms + alm

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_ALARM_TIME_OVERRIDE,
                                              payload=payload)

        print("override alarm time since activated")

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

        # If there is content...
        if received_message is not None:
            # print(received_message)
            if reset == RESET:
                str_res = "reset back to normal"
            else:
                str_res = str(time_ms)
            print("Alarm time since activated overridden to " + str_res + " ms: " + str(
                received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False

    def cmd_alarm_lamp_pattern_override(self, reset, pattern):
        """
        Constructs and sends the alarm lamp pattern override command.

        \param reset:  integer - 1 to reset a previous override, 0 to override
        \param pattern:  integer - ID of alarm lamp pattern to override with
        \returns 1 if successful, zero otherwise

        \details Patterns: \n
            0 = off \n
            1 = ok \n
            2 = fault \n
            3 = high \n
            4 = medium \n
            5 = low \n
            6 = manual
        """
        rst = integer_to_byte_array(reset)
        pat = integer_to_byte_array(pattern)
        payload = rst + pat

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_hd_ch_id,
                                              message_id=self.MSG_ID_HD_ALARM_LAMP_OVERRIDE,
                                              payload=payload)

        print("override alarm lamp pattern")

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

        # If there is content...
        if received_message is not None:
            print(received_message)
            if reset == RESET:
                str_pat = "reset back to normal"
            elif pattern == self.HD_ALARM_LAMP_PATTERN_OFF:
                str_pat = "off"
            elif pattern == self.HD_ALARM_LAMP_PATTERN_OK:
                str_pat = "ok"
            elif pattern == self.HD_ALARM_LAMP_PATTERN_FAULT:
                str_pat = "fault"
            elif pattern == self.HD_ALARM_LAMP_PATTERN_HIGH:
                str_pat = "high"
            elif pattern == self.HD_ALARM_LAMP_PATTERN_MEDIUM:
                str_pat = "medium"
            elif pattern == self.HD_ALARM_LAMP_PATTERN_LOW:
                str_pat = "low"
            else:
                str_pat = "manual"
            print("Alarm lamp pattern overridden to " + str_pat + ":" +
                  str(received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]))
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            print("Timeout!!!!")
            return False