###########################################################################
#
# 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    service_record.py
#
# @author  (last)      Dara Navaei
# @date    (last)      19-Dec-2022
# @author  (original)  Dara Navaei
# @date    (original)  14-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, publish, DialinEnum
from ..utils.nv_ops_utils import NVOpsUtils, NVUtilsObserver, NVRecords
from ..utils.conversions import integer_to_bytearray


@unique
class ServiceLocation(DialinEnum):
    SERVICE_LOCATION_FACTORY = 0
    SERVICE_LOCATION_FIELD = 1


class HDServiceNVRecords(AbstractSubSystem):
    """

    Hemodialysis Device (HD) Dialin API sub-class for service record commands.
    """

    # The default service time interval is 6 months in seconds
    _DEFAULT_SERVICE_INTERVAL_S = 15768000
    _RECORD_SPECS_BYTES = 12
    _DEFAULT_SERVICE_LOCATION = ServiceLocation.SERVICE_LOCATION_FACTORY.value
    _DEFAULT_TIME_VALUE = 0
    _DEFAULT_CRC_VALUE = 0
    _FIRMWARE_STACK_NAME = 'HD'

    # Maximum allowed bytes to be written to RTC RAM
    _RTC_RAM_MAX_BYTES_TO_WRITE = 64

    # 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_service_in_progress = False
        self._write_fw_data_to_excel = True
        self._service_data = 0
        self._raw_service_record = []
        self._utilities = NVOpsUtils(logger=self.logger)
        self.hd_service_record = self._prepare_hd_service_record()

        if self.can_interface is not None:
            channel_id = DenaliChannels.hd_to_dialin_ch_id
            msg_id = MsgIds.MSG_ID_HD_SEND_SERVICE_RECORD.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id,
                                                                       self._handler_hd_service_sync)

    def cmd_reset_hd_service_record(self) -> bool:
        """
        Handles resetting HD service record.

        @return: True if successful, False otherwise
        """
        self.hd_service_record = self._prepare_hd_service_record()
        self.hd_service_record = self._utilities.reset_fw_system_service_record(self.hd_service_record)
        status = self.cmd_set_hd_service_record(self.hd_service_record)

        return status

    def cmd_request_hd_service_record(self) -> int:
        """
        Handles getting HD service record from firmware.

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

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

            self.logger.debug('Getting HD service 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_hd_service_record_crc_override(self, crc: int) -> bool:
        """
        Handles setting HD service_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)
        hd_record = integer_to_bytearray(NVRecords.NVDATAMGMT_SERVICE_RECORD.value)
        payload = reset_byte_array + crc_value + hd_record

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

        self.logger.debug("Overriding HD service 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_hd_service_sync(self, message):
        """
        Handles published HD system record messages. HD system records are captured for
        processing and updating the HD system record.

        @param message:  published HD 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._service_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_service_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_service_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.hd_service_record, self._raw_service_record)
                self._handler_received_complete_hd_service_record()

    @publish(["hd_service_record"])
    def _handler_received_complete_hd_service_record(self):
        """
        Publishes the received service record

        @return: None
        """
        self.logger.debug("Received a complete hd service record.")

    def cmd_set_hd_service_record(self, hd_service_record: OrderedDict) -> bool:
        """
        Handles updating the HD system and sends it to FW.

        @param hd_service_record: (OrderedDict) the hd service record to be sent
        @return: True upon success, False otherwise
        """

        self.logger.debug('Setting HD service record')

        record_packets = self._utilities.prepare_record_to_send_to_fw(hd_service_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_hd_ch_id,
                                                  message_id=MsgIds.MSG_ID_HD_SET_SERVICE_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 HD service record.")
        return True

    def _prepare_hd_service_record(self):
        """
        Handles assembling the sub dictionaries of each group to make the main HD service record.

        @return: (OrderedDict) an assembled hd service record
        """
        result = OrderedDict()
        groups_byte_size = 0
        # create a list of the functions of the sub dictionaries
        functions = [self._prepare_service_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._RTC_RAM_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_service_record(self):
        """
        Handles creating the service record dictionary.

        @return: service record dictionary and the byte size of this group
        """
        groups_byte_size = 0
        service_records = OrderedDict({'service_record':
                                      {'service_location': ['<B', self._DEFAULT_SERVICE_LOCATION],
                                       'last_service_date_epoch': ['<i', self._DEFAULT_TIME_VALUE],
                                       'service_interval': ['<i', self._DEFAULT_SERVICE_INTERVAL_S],
                                       'last_reset_date_epoch': ['<i', self._DEFAULT_TIME_VALUE],
                                       'crc': ['<H', self._DEFAULT_CRC_VALUE]}})

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

        return service_records, groups_byte_size

    def cmd_set_dg_service_record_excel_to_fw(self, report_address: str):
        """
        Handles setting the service record 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 service record and set and observer class to callback when the record is read back
        self.cmd_request_hd_service_record()
        observer = NVUtilsObserver("hd_service_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.hd_service_record, report_address,
                                                        self._utilities.SERVICE_RECORD_TAB_NAME)

        self.cmd_set_hd_service_record(self.hd_service_record)

    def cmd_get_hd_service_record(self, report_address: str = None):
        """
         Publicly accessible function to request the HD service record and write the record to excel.

         @param report_address: the address that the report needs to be written to. The default is None so it picks an
         address and writes the excel report.

         @return: none
         """

        # Create the excel report
        self._utilities.prepare_excel_report(self._FIRMWARE_STACK_NAME, self._utilities.SERVICE_RECORD_TAB_NAME,
                                             report_address, protect_sheet=True)

        # Create an object of the observer class to observe the dictionary
        observer = NVUtilsObserver("hd_service_record")
        # Attach the observer to the list
        self.attach(observer)

        # Request the latest software configuration record from firmware
        self.cmd_request_hd_service_record()
        # Wait until data has been received from firmware
        while not observer.received:
            sleep(0.1)
        # Write the updated values from excel to firmware
        self._utilities.write_fw_record_to_excel(self.hd_service_record)