###########################################################################
#
# Copyright (c) 2021-2023 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    heat_disinfect.py
#
# @author  (last)      Sean Nash
# @date    (last)      17-Mar-2023
# @author  (original)  Dara Navaei
# @date    (original)  27-Feb-2021
#
############################################################################

import struct
from enum import unique
from logging import Logger
from ..common.msg_defs import MsgIds, MsgFieldPositions
from ..protocols.CAN import DenaliMessage, DenaliChannels
from ..utils.base import AbstractSubSystem, publish, DialinEnum
from ..utils.conversions import integer_to_bytearray, bytearray_to_integer, bytearray_to_float


@unique
class HeatDisinfectStates(DialinEnum):
    DG_HEAT_DISINFECT_STATE_START = 0
    DG_HEAT_DISINFECT_STATE_DRAIN_R1 = 1
    DG_HEAT_DISINFECT_STATE_DRAIN_R2 = 2
    DG_HEAT_DISINFECT_STATE_FLUSH_DRAIN = 3
    DG_HEAT_DISINFECT_STATE_FLUSH_CIRCULATION = 4
    DG_HEAT_DISINFECT_STATE_FLUSH_R1_AND_R2 = 5
    DG_HEAT_DISINFECT_STATE_FLUSH_R2_AND_DRAIN_R1 = 6
    DG_HEAT_DISINFECT_STATE_FLUSH_DRAIN_R2 = 7
    DG_HEAT_DISINFECT_STATE_FLUSH_DRAIN_R1 = 8
    DG_HEAT_DISINFECT_STATE_FILL_WITH_WATER = 9
    DG_HEAT_DISINFECT_STATE_DISINFECT_R1_TO_R2 = 10
    DG_HEAT_DISINFECT_STATE_FILL_R2_WITH_HOT_WATER = 11
    DG_HEAT_DISINFECT_STATE_DISINFECT_R2_TO_R1 = 12
    DG_HEAT_DISINFECT_STATE_COOL_DOWN_HEATERS = 13
    DG_HEAT_DISINFECT_STATE_MIX_DRAIN_R1 = 14
    DG_HEAT_DISINFECT_STATE_MIX_DRAIN_R2 = 15
    DG_HEAT_DISINFECT_STATE_RINSE_R1_TO_R2 = 16
    DG_HEAT_DISINFECT_STATE_RINSE_R2_TO_R1_AND_DRAIN_R1 = 17
    DG_HEAT_DISINFECT_STATE_RINSE_CIRCULATION = 18
    DG_HEAT_DISINFECT_STATE_CANCEL_BASIC_PATH = 19
    DG_HEAT_DISINFECT_STATE_CANCEL_WATER_PATH = 20
    DG_HEAT_DISINFECT_STATE_COMPLETE = 21


@unique
class HeatCancellationModes(DialinEnum):
    CANCELLATION_MODE_NONE = 0
    CANCELLATION_MODE_BASIC = 1
    CANCELLATION_MODE_HOT = 2
    CANCELLATION_MODE_COLD = 3


@unique
class NelsonSupportModes(DialinEnum):
    NELSON_NONE = 0
    NELSON_INOCULATE = 1
    NELSON_HEAT_DISINFECT = 2
    NELSON_POS_CONTROL_HEAT_DISINFECT = 3
    NELSON_CHEM_DISINFECT = 4
    NELSON_DRAIN_SAMPLE = 5
    NUM_OF_NELSON_SUPPORT = 6


class HeatDisinfect(AbstractSubSystem):
    """
        Heat Disinfection class with APIs to set the timing of each of the stages.
    """

    def __init__(self, can_interface, logger: Logger):
        super().__init__()

        self.can_interface = can_interface
        self.logger = logger

        self.heat_disinfect_state = 0
        self.heat_disinfect_ui_state = 0
        self.overall_elapsed_time = 0
        self.state_elapsed_time = 0
        self.heat_disinfect_target_time = 0
        self.disinfect_ro_77_time_s = 0
        self.disinfect_ro_82_time_s = 0
        self.disinfect_r_77_time_s = 0
        self.disinfect_r_82_time_s = 0
        self.cancellation_mode = 0
        self.r1_level = 0
        self.r2_level = 0
        self.dg_heat_disinfection_time_timestamp = 0.0
        self.dg_heat_disinfection_data_timestamp = 0.0

        if self.can_interface is not None:
            channel_id = DenaliChannels.dg_sync_broadcast_ch_id
            msg_id = MsgIds.MSG_ID_DG_HEAT_DISINFECT_DATA.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_heat_disinfect_sync)

            channel_id = DenaliChannels.dg_to_ui_ch_id
            msg_id = MsgIds.MSG_ID_DG_HEAT_DISINFECT_TIME_DATA.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_heat_disinfect_to_ui_sync)

    def clear_heat_disinfect_info(self) -> None:
        """
        Clears public class properties that are updated by the handler.
        Specifically properties updated  by the DG broadcast message
        MSG_ID_DG_HEAT_DISINFECT_DATA.

        @returns none
        """

        self.heat_disinfect_state = 0
        self.overall_elapsed_time = 0
        self.state_elapsed_time = 0
        self.cancellation_mode = 0
        self.r1_level = 0
        self.r2_level = 0
        self.heat_disinfect_ui_state = 0

    @publish(["dg_heat_disinfection_time_timestamp","heat_disinfect_target_time", "heat_disinfect_count_down_time"])
    def _handler_heat_disinfect_to_ui_sync(self, message, timestamp=0.0):
        """
        Handles published heat disinfect message

        @param message:  published heat disinfect UI data message
        @returns none
        """
        disinfect_target_time = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
        ro_77 = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
        ro_82 = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0]
        r_77 = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0]
        r_82 = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5]))[0]

        payload = message['message']
        index = DenaliMessage.PAYLOAD_START_INDEX
        disinfect_target_time, index = bytearray_to_integer(payload, index, False)
        disinfect_count_down_time, index = bytearray_to_integer(payload, index, False)

        self.heat_disinfect_target_time = int(disinfect_target_time / 1000)
        self.disinfect_ro_77_time_s = ro_77
        self.disinfect_ro_82_time_s = ro_82
        self.disinfect_r_77_time_s = r_77
        self.disinfect_r_82_time_s = r_82
        self.dg_heat_disinfection_time_timestamp = timestamp

    @publish(["dg_heat_disinfection_data_timestamp","heat_disinfect_state", "overall_elapsed_time",
              "state_elapsed_time", "cancellation_mode", "r1_level", "r2_level", "heat_disinfect_ui_state"])
    def _handler_heat_disinfect_sync(self, message, timestamp):
        """
        Handles published heat disinfect message

        @param message:  published heat disinfect data message
        @returns none
        """

        payload = message['message']
        index = DenaliMessage.PAYLOAD_START_INDEX
        state, index = bytearray_to_integer(payload, index, False)
        elapsed_time, index = bytearray_to_integer(payload, index, False)
        state_elapsed_time, index = bytearray_to_integer(payload, index, False)
        cancellation_mode, index = bytearray_to_integer(payload, index, False)
        r1, index = bytearray_to_float(payload, index, False)
        r2, index = bytearray_to_float(payload, index, False)
        ui_state, index = bytearray_to_integer(payload, index, False)

        self.heat_disinfect_state = state
        self.overall_elapsed_time = int(elapsed_time / 1000)
        self.state_elapsed_time = int(state_elapsed_time / 1000)
        self.cancellation_mode = cancellation_mode
        self.r1_level = r1
        self.r2_level = r2
        self.heat_disinfect_ui_state = ui_state
        self.dg_heat_disinfection_data_timestamp = timestamp

    def get_heat_disinfect_state(self) -> int:
        """
        Gets Heat Disinfection State

        @return: (int)
        """
        return self.heat_disinfect_state

    def get_heat_disinfect_heat_disinfect_target_time(self) -> int:
        """
        Gets Heat Disinfection target time

        @return: (int)
        """
        return self.heat_disinfect_target_time

    def get_heat_disinfect_heat_disinfect_count_down_time(self) -> int:
        """
        Gets Heat Disinfection count down time

        @return: (int)
        """
        return self.heat_disinfect_count_down_time

    def get_heat_disinfect_overall_elapsed_time(self) -> int:
        """
        Gets Heat Disinfection overall elapsed time

        @return: (int)
        """
        return self.overall_elapsed_time

    def get_heat_disinfect_state_elapsed_time(self) -> int:
        """
        Gets Heat Disinfection state elapsed time

        @return: (int)
        """
        return self.heat_disinfect_target_time

    def get_heat_disinfect_cancellation_mode(self) -> int:
        """
        Gets Heat Disinfection cancellation mode

        @return: (int)
        """
        return self.cancellation_mode

    def get_heat_disinfect_r1_level(self) -> int:
        """
        Gets Heat Disinfection r1 level

        @return: (int)
        """
        return self.r1_level

    def get_heat_disinfect_r2_level(self) -> int:
        """
        Gets Heat Disinfection r2 level

        @return: (int)
        """
        return self.r2_level

    def get_heat_disinfect_heat_disinfect_ui_state(self) -> int:
        """
        Gets Heat Disinfection UI state

        @return: (int)
        """
        return self.heat_disinfect_state

    def cmd_set_nelson_support_mode(self, support: int):
        """
        Constructs and sends a command to set the firmware to a certain Nelson support
        Constraints:
            Must be logged into DG. This code only works on a firmware that has been built in debug mode.

        @param support: (int) the type of Nelson support
            NELSON_NONE = 0
            NELSON_INOCULATE = 1
            NELSON_HEAT_DISINFECT = 2
            NELSON_POS_CONTROL_CHEM_DISINFECT = 3
            NELSON_POS_CONTROL_HEAT_DISINFECT = 4
            NELSON_CHEM_DISINFECT = 5
            NELSON_DRAIN_SAMPLE = 6
            NUM_OF_NELSON_SUPPORT = 7
        @returns none
        """
        payload = integer_to_bytearray(support)
        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
                                              message_id=MsgIds.MSG_ID_DG_NELSON_DISINFECT_SUPPORT.value,
                                              payload=payload)

        self.logger.debug("Setting Nelson support to " + NelsonSupportModes(support).name)
        received_message = self.can_interface.send(message, 0)

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