from logging import Logger
from ..common.msg_defs import MsgIds, MsgFieldPositions
from ..common.test_config_defs import DGTestConfigOptions
from ..protocols.CAN import DenaliMessage, DenaliChannels
from .constants import NO_RESET
from ..utils.conversions import integer_to_bytearray, bytearray_to_integer
from ..utils.base import AbstractSubSystem, publish


class DGTestConfig(AbstractSubSystem):
    """

    Dialysate Generator (DG) Dialin API sub-class for setting and getting the test configurations.
    """

    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.dg_test_configs = dict()
        self.dg_test_configs_response_timestamp = 0.0

        self._reset_test_configs_record()

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

    def cmd_get_test_config_status(self, config: int):
        """
        Returns the status of a test config

        @param config: (int) Test config to set
        @return: the status of a test config
        """
        return self.dg_test_configs[DGTestConfigOptions(config).name]

    def cmd_set_test_config(self, config: int, reset: int = NO_RESET):
        """
        Constructs and sends the DG test config
        Constraints:
            Must be logged into DG.

        @param config: (int) Test config to set
        @param reset: (int) 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """
        reset_value = integer_to_bytearray(reset)
        c = integer_to_bytearray(config)
        payload = reset_value + c

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

        if reset == NO_RESET:
            self.logger.debug("Setting {}".format(DGTestConfigOptions(config).name))
        else:
            self.logger.debug("Resetting {}".format(DGTestConfigOptions(config).name))

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

        # If there is no 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

    def cmd_request_test_config_status_from_fw(self):
        """
        Constructs and sends the DG test configs request
        Constraints:
            Must be logged into DG.

        @return: 1 if successful, zero otherwise
        """
        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
                                              message_id=MsgIds.MSG_ID_DG_GET_TEST_CONFIGURATION.value)

        self.logger.debug('Getting DG test configuration record')

        received_message = self.can_interface.send(message)

        # If there is content...
        if received_message is not None:
            self._reset_test_configs_record()
            self.logger.debug("Received FW ACK after requesting DG test configuration record.")
            # response payload is OK or not OK
            return received_message['message'][DenaliMessage.PAYLOAD_START_INDEX]
        else:
            self.logger.debug("Timeout!!!!")
            return False

    def cmd_reset_all_test_configs(self):
        """
        Constructs and sends the DG test configs reset all
        Constraints:
            Must be logged into DG.

        @return: 1 if successful, zero otherwise
        """
        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_dg_ch_id,
                                              message_id=MsgIds.MSG_ID_DG_RESET_ALL_TEST_CONFIGURATIONS.value)

        self.logger.debug("Resetting all DG test configurations")

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

        # If there is no 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

    @publish(['dg_test_configs'])
    def _handler_dg_test_config_sync(self, message, timestamp=0.0):
        """
        Handles published test configuration status messages.

        @param message:  published DG test configurations message
        @return: None
        """
        payload = message['message']
        index = MsgFieldPositions.START_POS_FIELD_1

        for config in DGTestConfigOptions.__members__:
            if 'NUM_OF_TEST_CONFIGS' not in config:
                config_value, index = bytearray_to_integer(payload, index, False)
                self.dg_test_configs[config] = config_value

        self.dg_test_configs_response_timestamp = timestamp

    def _reset_test_configs_record(self):
        """
        Resets the test configuration dictionary

        @return: None
        """
        for config in DGTestConfigOptions.__members__:
            # Loop through the list of the test configuration and set the values to 0xFFFFFFFF
            if 'NUM_OF_TEST_CONFIGS' not in config:
                self.dg_test_configs[config] = 0xFFFFFFFF