###########################################################################
#
# Copyright (c) 2021-2024 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    system_record.py
#
# @author  (last)      Michael Garthwaite
# @date    (last)      03-Oct-2023
# @author  (original)  Dara Navaei
# @date    (original)  10-Feb-2021
#
############################################################################
import struct
import time
from collections import OrderedDict
from enum import unique
from logging import Logger
from time import sleep
from ..common.msg_defs import MsgIds, MsgFieldPositions
from ..protocols.CAN import DenaliMessage, DenaliChannels
from ..utils.base import AbstractSubSystem, DialinEnum, publish
from ..utils.nv_ops_utils import NVOpsUtils, NVUtilsObserver, NVRecordsDG
from ..utils.conversions import integer_to_bytearray


@unique
class MFGLocation(DialinEnum):
    MFG_LOCATION_FACTORY = 0


class DGSystemNVRecord(AbstractSubSystem):
    """

    Dialysate Generator (DG) Dialin API sub-class for system record commands.
    """

    _RECORD_SPECS_BYTES = 12
    _DEFAULT_MFG_LOCATION = MFGLocation.MFG_LOCATION_FACTORY.value
    _MAX_PN_BYTES = 10
    _MAX_SN_BYTES = 20
    _DEFAULT_TIME_VALUE = 0
    _DEFAULT_CRC_VALUE = 0

    # Maximum allowed bytes that are allowed to be written to EEPROM in firmware
    # The padding size then is calculated to be divisions of 16
    _EEPROM_MAX_BYTES_TO_WRITE = 16

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

    _FIRMWARE_STACK_NAME = 'DG'

    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_sys_in_progress = False
        self._sys_data = 0
        self._raw_system_record = []
        self._utilities = NVOpsUtils(logger=self.logger)
        # System main record
        self.dg_system_record = self._prepare_dg_system_record()
        self.dg_system_record_timestamp=0.0

        if self.can_interface is not None:
            channel_id = DenaliChannels.dg_to_dialin_ch_id
            msg_id = MsgIds.MSG_ID_DG_SEND_SYSTEM_RECORD.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_dg_system_sync)

    def cmd_reset_dg_system_record(self) -> bool:
        """
        Handles resetting DG system record.

        @return: True if successful, False otherwise
        """
        self.dg_system_record = self._prepare_dg_system_record()
        self.dg_system_record = self._utilities.reset_fw_system_service_record(self.dg_system_record)
        status = self.cmd_set_dg_system_record(self.dg_system_record)

        return status

    def get_dg_system_record(self) -> dict:
        """
        Handles getting DG system record per user's request.
            NOTE: In order to get the latest system record, use cmd_request_dg_system_record first
            to fetch the system record from the firmware.

        @return: DG system record dictionary
        """
        return self.dg_system_record['system_record']

    def cmd_get_dg_system_record_report(self, report_destination: str = None):
        """
        Handles getting DG system_record record from firmware and writing it to excel.

        @param report_destination: (str) the destination that the report should be written to

        @return: none
        """
        # Prepare the excel report
        self._utilities.prepare_excel_report(self._FIRMWARE_STACK_NAME, self._utilities.SYSTEM_RECORD_TAB_NAME,
                                             report_destination, protect_sheet=True)

        observer = NVUtilsObserver("dg_system_record")
        # Attach the observer to the list
        self.attach(observer)

        # Request the DG system record and set and observer class to callback when the system record is read back
        self.cmd_request_dg_system_record()

        while not observer.received:
            sleep(0.1)
        # Pass the DG system record to the function to write the excel
        self._utilities.write_fw_record_to_excel(self.dg_system_record)

    def cmd_request_dg_system_record(self) -> int:
        """
        Handles getting DG system record from firmware.

        @return: 1 upon success, False otherwise
        """
        if self._is_getting_sys_in_progress is not True:
            # Receiving the system record is in progress
            self._is_getting_sys_in_progress = True
            # Clear the list for the next call
            self._raw_system_record.clear()

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

            self.logger.debug('Getting DG system 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 cmd_dg_system_record_crc_override(self, crc: int) -> bool:
        """
        Handles setting DG system_record CRC override.

        @param crc: (int) the CRC override value

        @return: True if successful, False otherwise
        """
        # This command does not have a reset but since the corresponding payload structure in firmware requires a reset
        # so the payload length is the same when it is received in the firmware.
        reset_byte_array = integer_to_bytearray(0)
        crc_value = integer_to_bytearray(crc)
        dg_record = integer_to_bytearray(NVRecordsDG.NVDATAMGMT_SYSTEM_RECORD.value)
        payload = reset_byte_array + crc_value + dg_record

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

        self.logger.debug("Overriding DG system record CRC to: " + str(crc))

        # Send message
        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.error("Timeout!!!!")
            return False

    def _handler_dg_system_sync(self, message, timestamp=0.0):
        """
        Handles published DG system record messages. HD system records are captured for
        processing and updating the DG system record.

        @param message:  published DG system 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 calibration_record record payload is from the start index + 12 bytes for the current message +total
        # messages + the length of calibration_record. The rest is the CAN messaging CRC that is not needed
        # to be kept
        end_of_data_index = MsgFieldPositions.START_POS_FIELD_1 + self._RECORD_SPECS_BYTES + self._received_msg_length

        # Get the data only and not specs of it (i.e current message number)
        self._sys_data = message['message'][MsgFieldPositions.START_POS_FIELD_1:end_of_data_index]

        # Continue getting calibration_record records until the all the calibration_record messages are received.
        # Concatenate the calibration_record records to each other
        if self._current_message <= self._total_messages:
            self._raw_system_record += (message['message'][MsgFieldPositions.START_POS_FIELD_1
                                                           + self._RECORD_SPECS_BYTES:end_of_data_index])
            if self._current_message == self._total_messages:
                # Done with receiving the messages
                self._is_getting_sys_in_progress = False
                # If all the messages have been received, call another function to process the raw data
                self._utilities.process_received_record_from_fw(self.dg_system_record, self._raw_system_record)
                self.dg_system_record_timestamp = timestamp
                self._handler_received_complete_dg_system_record()

    @publish(["dg_system_record_timestamp","dg_system_record"])
    def _handler_received_complete_dg_system_record(self):
        """
        Publishes the received system record

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

    def cmd_set_dg_system_record_excel_to_fw(self, report_address: str) -> bool:
        """
        Handles setting the system data that is in an excel report to the firmware.

        @param report_address: (str) the address in which its data must be written from excel

        @return: none
        """

        # Request the DG calibration record and set and observer class to callback when the calibration record is read
        # back
        self.cmd_request_dg_system_record()
        observer = NVUtilsObserver("dg_system_record")
        # Attach the observer to the list
        self.attach(observer)
        while not observer.received:
            sleep(0.1)
        self._utilities.write_excel_record_to_fw_record(self.dg_system_record, report_address,
                                                        self._utilities.SYSTEM_RECORD_TAB_NAME)

        ret =self.cmd_set_dg_system_record(self.dg_system_record)
        return ret

    def cmd_set_dg_system_record(self, dg_system_record: OrderedDict) -> bool:
        """
        Handles updating the DG system and sends it to FW.

        @param dg_system_record: (OrderedDict) the dg system record to be sent
        @return: True upon success, False otherwise
        """
        transfer_status = 1
        record_packets = self._utilities.prepare_record_to_send_to_fw(dg_system_record)

        self.logger.debug('Setting DG system record')

        # 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_SYSTEM_RECORD.value,
                                                  payload=payload)

            received_message = self.can_interface.send(message)

            # If there is no content...
            if received_message is None:
                self.logger.warning("DG ACK not received!")
                continue
            elif transfer_status == 0:
                self.logger.debug("Sending DG system record failed")
                return False

            transfer_status = received_message['message'][6]

        if transfer_status == 1:
            self.logger.debug("Finished sending DG system record.")
            return True

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

        @return: (OrderedDict) the assembled dg system record
        """
        result = OrderedDict()
        groups_byte_size = 0
        # create a list of the functions of the sub dictionaries
        functions = [self._prepare_system_record()]

        for function in functions:
            # Update the groups bytes size so far to be use to padding later
            groups_byte_size += function[1]
            # Update the calibration record
            result.update(function[0])

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

        # Get the groups byte size
        groups_byte_size += self._utilities.calculate_group_byte_size(record_crc)

        # Get the padding size to create a dictionary from it
        padding_size = self._utilities.calculate_padding_byte_size(groups_byte_size, self._EEPROM_MAX_BYTES_TO_WRITE)

        # Create the padding dictionary as list of unsigned char. All the elements are 0.
        padding = OrderedDict({'padding': ['<B', [self._DEFAULT_CRC_VALUE] * padding_size]})

        # Update the dictionary with the padding and record crc dictionaries
        result.update(padding)
        result.update(record_crc)

        return result

    def _prepare_system_record(self):
        """
        Handles creating the system record dictionary.

        @return: system record dictionary and the byte size of this group
        """
        groups_byte_size = 0
        system_records = OrderedDict(
            {'system_record':
                {'top_level_pn': ['<c', self._utilities.DEFAULT_CHAR_VALUE * self._MAX_PN_BYTES, self._MAX_PN_BYTES],
                 'top_level_sn': ['<c', self._utilities.DEFAULT_CHAR_VALUE * self._MAX_SN_BYTES, self._MAX_SN_BYTES],
                 'mfg_location': ['<B', self._DEFAULT_MFG_LOCATION], 'mfg_date': ['<i', self._DEFAULT_TIME_VALUE],
                 'crc': ['<H', self._DEFAULT_CRC_VALUE]}})

        for record in system_records.keys():
            groups_byte_size += self._utilities.calculate_group_byte_size(system_records[record])

        return system_records, groups_byte_size