import struct
import time
import math
from collections import OrderedDict
from ..common.msg_defs import MsgIds, MsgFieldPositions
from ..protocols.CAN import (DenaliMessage, DenaliChannels)
from ..utils.base import _AbstractSubSystem, _publish
from ..utils.nv_ops_utils import NVOpsUtils
from logging import Logger


class DGScheduledRunsNVRecord(_AbstractSubSystem):
    """

    Dialysate Generator (DG) Dialin API sub-class for scheduled runs commands.
    """

    SCHEDULED_RUNS_RECORD_START_INDEX = 6
    SCHEDULED_RECORD_SPECS_BYTES = 12
    SCHEDULED_RECORDS_SPECS_BYTE_ARRAY = 3

    MAX_PART_NUMBER_BYTES = 10
    MAX_SERIAL_NUMBER_BYTES = 15

    DEFAULT_SCHEDULED_RUNS_DATE_VALUE = 0
    DEFAULT_SCHEDULED_RUNS_CRC_VALUE = 0
    DEFAULT_SCHEDULED_RUNS_PADDING_VALUE = 0

    CURRENT_MESSAGE_NUM_INDEX = 0
    TOTAL_MESSAGES_NUM_INDEX = 4
    PAYLOAD_LENGTH_INDEX = 8
    PAYLOAD_START_INDEX = 12

    SCHEDULED_RUNS_DATA_TYPE_INDEX = 0
    SCHEDULED_RUNS_VALUE_INDEX = 1

    TARGET_BYTES_TO_SEND_TO_FW = 150
    MIN_PAYLOAD_BYTES_SPACE = 4

    RTC_RAM_MAX_BYTES_TO_WRITE = 64

    PAYLOAD_CURRENT_MSG_INDEX = 0
    PAYLOAD_TOTAL_MSG_INDEX = 1
    PAYLOAD_SCHEDULED_RUNS_BYTES_INDEX = 2

    # Delay in between each payload transfer
    _PAYLOAD_TRANSFER_DELAY_S = 0.2
    _DIALIN_RECORD_UPDATE_DELAY_S = 0.2

    def __init__(self, can_interface, logger: Logger):
        """

        @param can_interface: Denali CAN Messenger object
        """

        super().__init__()

        self.can_interface = can_interface
        self.logger = logger
        self.current_message = 0
        self.total_messages = 0
        self.received_msg_length = 0
        self._is_getting_runs_in_progress = False
        self._write_fw_data_to_excel = True
        self.cal_data = 0
        self.raw_scheduled_runs_record = []
        self._utilities = NVOpsUtils(logger=self.logger)

        # DG scheduled runs main record as an ordered dictionary
        self.dg_scheduled_runs_record = self._prepare_dg_scheduled_runs_record()

        if self.can_interface is not None:

            channel_id = DenaliChannels.dg_to_dialin_ch_id
            msg_id = MsgIds.MSG_ID_DG_SEND_SCHEDULED_RUNS_RECORD.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_dg_scheduled_runs_record)

    def cmd_request_dg_scheduled_runs_record(self):
        """
        Handles getting DG scheduled runs record from firmware.

        @return: 1 upon success, False otherwise
        """
        if self._is_getting_runs_in_progress is not True:
            self._is_getting_runs_in_progress = True
            # Clear the list for the next call
            self.raw_scheduled_runs_record.clear()

            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
                                                  message_id=MsgIds.MSG_ID_DG_GET_SCHEDULED_RUNS_RECORD.value)

            self.logger.debug('Getting DG scheduled runs record')

            received_message = self.can_interface.send(message)

            # 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

        self.logger.debug("Request cancelled: an existing request is in progress.")
        return False

    def _handler_dg_scheduled_runs_record(self, message):
        """
        Handles published DG scheduled runs record messages. DG scheduled runs records are captured for processing and
        updating the DG scheduled runs record.

        @param message:  published DG scheduled runs record data message

        @return: None
        """
        curr = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
        total = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
        length = struct.unpack('i', bytearray(
            message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0]

        self.current_message = curr
        self.total_messages = total
        self.received_msg_length = length
        # The end of scheduled runs record payload is from the start index + 12 bytes for the current message + total
        # messages + the length of scheduled runs record. The rest is the CAN messaging CRC and is not
        # needed.
        end_of_data_index = self.SCHEDULED_RUNS_RECORD_START_INDEX + self.SCHEDULED_RECORD_SPECS_BYTES + self.received_msg_length

        # Get the scheduled runs data only
        self.cal_data = message['message'][self.SCHEDULED_RUNS_RECORD_START_INDEX:end_of_data_index]

        # Continue getting calibration_record records until the all the messages are received. Concatenate the
        # calibration_record records to each other
        if self.current_message <= self.total_messages:
            self.raw_scheduled_runs_record += (message['message'][self.SCHEDULED_RUNS_RECORD_START_INDEX +
                                                                  self.SCHEDULED_RECORD_SPECS_BYTES:end_of_data_index])
            if self.current_message == self.total_messages:
                # Done receiving the messages
                self._is_getting_runs_in_progress = False
                # If all the messages have been received, call another function to process the raw data
                self._update_dg_scheduled_record_from_fw()
                self._handler_received_complete_dg_scheduled_runs_record()

    @_publish(["dg_scheduled_runs_record"])
    def _handler_received_complete_dg_scheduled_runs_record(self):
        """
        Publishes the received scheduled runs record

        @return: None
        """
        self.logger.debug("Received a complete dg scheduled runs record.")

    def _update_dg_scheduled_record_from_fw(self):
        """
        Handles parsing the scheduled runs messages that were received from DG firmware.

        @return: None
        """
        raw_payload_temp_start_index = 0
        # Convert the concatenated raw data into a byte array since the struct library requires byte arrays.
        self.raw_scheduled_runs_record = bytearray(self.raw_scheduled_runs_record)

        # Loop through the keys for the main calibration_record dictionary
        # DG_Calibration : {pressure_sensors : { ppi : { gain: ['<f', 12.3], offset: ['<f', 5.67]}}, ...}
        # Get the list of keys of the main dictionary (i.e. pressure_sensors, temperature_sensors, ....}
        # These keys are the list of hardware groups
        for group in self.dg_scheduled_runs_record.keys():
            # All the hardware groups (i.e pressure sensors) are nested dictionaries, except the final CRC. So it is
            # unpacked exceptionally here. The CRC is an unsigned 16-bit (short).
            if group == 'crc':
                # Get the data type ( it must be '<H')
                data_type = self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
                # Check the data type of the crc
                value_bytes = self._get_data_type_bytes(data_type)
                # Unpack the data
                data = struct.unpack(data_type, self.raw_scheduled_runs_record[raw_payload_temp_start_index:
                                                                    raw_payload_temp_start_index + value_bytes])[0]
                self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_VALUE_INDEX] = data
            elif group == 'padding':
                # Get the data type
                data_type = self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
                # Check the data type of the padding values (they are unsigned chars)
                value_bytes = self._get_data_type_bytes(data_type)
                # Get the length of the padding list
                padding_length = len(self.dg_scheduled_runs_record[group][self.SCHEDULED_RUNS_VALUE_INDEX])
                # Add the length of the padding bytes to the payload start address
                raw_payload_temp_start_index += padding_length * value_bytes
            # The rest of the groups are hardware which are layered dictionaries
            else:
                # If the value is not a CRC, it is nested dictionary of different hardware groups
                # Loop through the values of each key to get the list of the hardware in a hardware group (i.e
                # pressure_sensors have ppi, ppo, ...)
                for hardware_group in self.dg_scheduled_runs_record[group].keys():
                    # Each hardware has a set of calibration_record values (i.e ppi: {gain: ['<f',  12.3]}.
                    # Loop though those
                    for hardware in self.dg_scheduled_runs_record[group][hardware_group]:
                        # The values of the dictionary of each hardware is a list of its data type as well as its value
                        # which the first index is data type
                        data_type = self.dg_scheduled_runs_record[group][hardware_group][hardware][
                            self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
                        value_bytes = self._get_data_type_bytes(data_type)
                        # Unpack the values to written to the dictionary
                        data = struct.unpack(data_type, self.raw_scheduled_runs_record[raw_payload_temp_start_index:
                                                                            raw_payload_temp_start_index +
                                                                            value_bytes])[0]
                        # Update the index of the raw payload for the next read
                        raw_payload_temp_start_index += value_bytes
                        self.dg_scheduled_runs_record[group][hardware_group][hardware]\
                                                     [self.SCHEDULED_RUNS_VALUE_INDEX] = data

    def _prepare_dg_scheduled_runs_record(self):
        """
        Handles assembling the sub dictionaries of each hardware group to make the main DG system record.

        @return: (OrderedDict) the assembled dg scheduled runs record
        """

        scheduled_runs = self._prepare_scheduled_runs()

        # Build the CRC of the main record
        record_crc = OrderedDict({'crc': ['<H', self.DEFAULT_SCHEDULED_RUNS_CRC_VALUE]})

        # The second element of the hardware groups are the byte sizes, add them to calculate the overall byte size.
        groups_byte_size = scheduled_runs[1] + self._get_data_type_bytes(record_crc['crc']
                                                                                 [self.SCHEDULED_RUNS_DATA_TYPE_INDEX])
        # Calculate the padding size:
        # If bytes in the dictionary % max write bytes to EEPROM (16) is 0, not padding is needed
        # Else padding = (ceil(dictionary bytes/max write to EEPROM (16)) * max write to EEPROM (16)) - dictionary bytes
        if (groups_byte_size % self.RTC_RAM_MAX_BYTES_TO_WRITE) == 0:
            padding_size = 0
        else:
            padding_size = (math.ceil(groups_byte_size / self.RTC_RAM_MAX_BYTES_TO_WRITE) *
                            self.RTC_RAM_MAX_BYTES_TO_WRITE) - groups_byte_size
        # Create the padding dictionary as list of unsigned char. All the elements are 0.
        padding = OrderedDict({'padding': ['<B', [self.DEFAULT_SCHEDULED_RUNS_PADDING_VALUE] * padding_size]})

        result = OrderedDict({**scheduled_runs[0], **padding, **record_crc})
        return result

    def _prepare_scheduled_runs(self):
        """
        Handles creating the scheduled service dictionary.

        @return: scheduled service dictionary and the byte size of this hardware group
        """
        hardware_names = ['flush', 'heat_disinfect', 'chemical_disinfect']
        group_byte_size = 0
        group_name = 'scheduled_runs'
        hardware_group = OrderedDict({group_name: OrderedDict()})
        hardware = OrderedDict()

        for i in hardware_names:

            hardware[i] = {'last_run_date': ['<i', self.DEFAULT_SCHEDULED_RUNS_DATE_VALUE],
                           'crc': ['<H', self.DEFAULT_SCHEDULED_RUNS_CRC_VALUE]}
            # Calculate the size of the bytes in this hardware group
            group_byte_size += self._calculate_group_byte_size(hardware[i])
        hardware_group[group_name] = hardware

        return hardware_group, group_byte_size

    def _calculate_group_byte_size(self, group):
        """
        Handles calculating the byte size of the values of the provided dictionary.

        @param group: the dictionary that is passed to calculate the byte size
        @return: calculated byte size
        """
        byte_size = 0

        for key in group.keys():
            data_type = group[key][self.SCHEDULED_RUNS_DATA_TYPE_INDEX]
            current_byte_size = self._get_data_type_bytes(data_type)
            byte_size += current_byte_size

        return byte_size

    @staticmethod
    def _get_data_type_bytes(data):
        """
        Handles converting the string representation of the bytes of the data types in a struct to numbers.
        This is a static method.

        @param data: the data to be converted to bytes in number
        @return: calculated byte size
        """
        number_of_bytes = 0
        # Unsigned integer = i
        # Signed integer = I
        # Float = f. All 4 bytes.
        if data == '<i' or data == '<f':
            number_of_bytes = 4
        # Unsigned short = H. 2 bytes.
        elif data == '<H':
            number_of_bytes = 2
        # Unsigned char = B. 1 byte.
        elif data == '<B' or data == '<c':
            number_of_bytes = 1

        return number_of_bytes

    def cmd_set_dg_scheduled_runs_record(self, dg_scheduled_runs_record: OrderedDict):
        """
        Handles updating the DG system record with the newest calibration_record data of a hardware and sends it to FW.

        @return: True upon success, False otherwise
        """

        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_scheduled_runs_record)

        self.logger.debug('Setting DG scheduled runs started')

        # Update all the data packets with the last message count since is the number of messages that firmware
        # should receive
        for packet in record_packets:
            # Sleep to let the firmware receive and process the data
            time.sleep(self._PAYLOAD_TRANSFER_DELAY_S)

            # Convert the list packet to a bytearray
            payload = b''.join(packet)

            message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
                                                  message_id=MsgIds.MSG_ID_DG_SET_SCHEDULED_RUNS_RECORD.value,
                                                  payload=payload)

            received_message = self.can_interface.send(message)

            # If there is no content...
            if received_message is None:
                self.logger.debug("Timeout!!!!")
                return False

        self.logger.debug("Finished sending DG scheduled runs record.")
        return True