###########################################################################
#
# Copyright (c) 2020-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    valves.py
#
# @author  (last)      Micahel Garthwaite
# @date    (last)      17-Aug-2023
# @author  (original)  Peman Montazemi
# @date    (original)  19-May-2020
#
############################################################################

import struct
from enum import unique
from logging import Logger
from collections import OrderedDict

from .constants import NO_RESET
from leahi_dialin.common.msg_defs import MsgIds
from leahi_dialin.protocols.CAN import DenaliMessage, DenaliChannels
from leahi_dialin.utils.base import AbstractSubSystem, publish, DialinEnum
from leahi_dialin.utils.checks import check_broadcast_interval_override_ms
from leahi_dialin.utils.conversions import integer_to_bytearray

# Valve states
ENERGIZED = True
DEENERGIZED = False


@unique
class FPValveStates(DialinEnum):
    VALVE_STATE_CLOSED = 0
    VALVE_STATE_OPEN = 1


@unique
class FPValveNames(DialinEnum):
    M4_VALV = 0                             # Valve (M4 VWi)
    P39_VALV = 1                            # Valve (P39 VROd)
    P6_VALV = 2                             # Valve (P6 VFF)
    P11_VALV = 3                            # Valve (P11 VPi)
    P33_VALV = 4                            # Valve (P33 VCr)
    P34_VALV = 5                            # Valve (P34 VCb)
    P37_VALV = 6                            # Valve (P37 VCd)

class FPValves(AbstractSubSystem):
    """
        Dialin API sub-class for FP valve related commands.
    """

    # Valves states publish message field positions
    START_POS_VALVES_STATES = DenaliMessage.PAYLOAD_START_INDEX
    END_POS_VALVES_STATES = START_POS_VALVES_STATES + 2  # Valves States come in as a U16 value (2 bytes)

    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.valves_sensed_states = OrderedDict()
        self.fp_valves_states_timestamp = 0.0

        if self.can_interface is not None:
            channel_id = DenaliChannels.fp_sync_broadcast_ch_id
            msg_id = MsgIds.MSG_ID_FP_VALVES_STATES_DATA.value
            self.can_interface.register_receiving_publication_function(channel_id, msg_id, self._handler_valves_sync)

        self.valve_states_all = 0x0000
        self.m4_valv = {"id": FPValveNames.M4_VALV.value, "state": DEENERGIZED}
        self.p39_valv = {"id": FPValveNames.P39_VALV.value, "state": DEENERGIZED}
        self.p6_valv = {"id": FPValveNames.P6_VALV.value, "state": DEENERGIZED}
        self.p11_valv = {"id": FPValveNames.P11_VALV.value, "state": DEENERGIZED}
        self.p33_valv = {"id": FPValveNames.P33_VALV.value, "state": DEENERGIZED}
        self.p34_valv = {"id": FPValveNames.P34_VALV.value, "state": DEENERGIZED}
        self.p37_valv = {"id": FPValveNames.P37_VALV.value, "state": DEENERGIZED}

        # NOTE: The len function counts the enums with the same number only once. This is not the case in the DG valves
        # class because each valve must have a unique ID.
        self.valve_states_enum = [0 for _ in range(len(FPValveNames))]

        for valve in FPValveNames.__members__:
            self.valves_sensed_states[valve] = ''

    def get_valve_states(self):
        """
        Gets the valve states

        @return: All valve states
        """
        return [
            self.m4_valv.get("state"),
            self.p39_valv.get("state"),
            self.p6_valv.get("state"),
            self.p11_valv.get("state"),
            self.p33_valv.get("state"),
            self.p34_valv.get("state"),
            self.p37_valv.get("state"),
        ]

    @staticmethod
    def sort_by_id(observation):
        """
        Converts a published dictionary of valve state information to an ordered list
        of tuples.

        @param observation: dictionary of the observed valve states
        @return: a list of tuples of the valve states
        """

        result = []
        for key, value in observation.items():
            if isinstance(value, dict):
                result.append((key, value.get("id", None), value.get("state", None)))

        result = sorted(result, key=lambda each: each[1])
        return result

    @staticmethod
    def _binary_to_valve_state(binary) -> bool:
        """
        @param binary: binary value
        @return: 1 = energized, otherwise de-energized
        """

        if binary != 0:
            return ENERGIZED
        else:
            return DEENERGIZED

    @publish([
        "fp_valves_states_timestamp",
        "valve_states_all",
        "m4_valv",
        "p39_valv",
        "p6_valv",
        "p11_valv",
        "p33_valv",
        "p34_valv",
        "p37_valv",
        "valve_states_enum"
    ])
    def _handler_valves_sync(self, message, timestamp=0.0):
        """
        Handles published FP valves states message.

        @param message:  published FP valves states message
        @return: none
        """

        vst = struct.unpack('H', bytearray(message['message'][self.START_POS_VALVES_STATES:self.END_POS_VALVES_STATES]))
        self.valve_states_all = vst[0]
        # Extract each valve state from U16 valves states using bit-masking
        self.m4_valv["state"] = self._binary_to_valve_state(vst[0] & 1)
        self.p39_valv["state"] = self._binary_to_valve_state(vst[0] & 2)
        self.p6_valv["state"] = self._binary_to_valve_state(vst[0] & 4)
        self.p11_valv["state"] = self._binary_to_valve_state(vst[0] & 8)
        self.p33_valv["state"] = self._binary_to_valve_state(vst[0] & 16)
        self.p34_valv["state"] = self._binary_to_valve_state(vst[0] & 32)
        self.p37_valv["state"] = self._binary_to_valve_state(vst[0] & 64)

        start = self.END_POS_VALVES_STATES
        end = start + 1
        for valve_id in self.valves_sensed_states:
            valve_state_number = struct.unpack('B', bytearray(message['message'][start:end]))[0]
            self.valves_sensed_states[valve_id] = FPValveStates(valve_state_number).name
            start = end
            end += 1

        self.fp_valves_states_timestamp = timestamp

    def cmd_valve_sensed_state_override(self, valve: int, state: bool, reset: int = NO_RESET) -> int:
        """
        Constructs and sends the valve sensed state override command.
        Constraints:
            Must be logged into FP.
            Given valve ID must be one of the valve IDs listed below.

        @param valve:  unsigned int - valve ID
        @param state:  bool - valve state
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        rst = integer_to_bytearray(reset)
        ste = integer_to_bytearray(int(state))
        vlv = integer_to_bytearray(valve)
        payload = rst + ste + vlv

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_fp_ch_id,
                                              message_id=MsgIds.MSG_ID_FP_VALVE_SENSED_STATE_OVERRIDE_REQUEST.value,
                                              payload=payload)

        self.logger.debug("Override valve sensed state")

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

    def cmd_valve_override(self, valve: int, state: int, reset: int = NO_RESET) -> int:
        """
        Constructs and sends the FP valve state override command.
        Constraints:
            Must be logged into FP.
            Given valve ID must be one of the valve IDs listed below.

        @param valve:  unsigned int - valve ID
        @param state:  int - valve state
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise
        """

        rst = integer_to_bytearray(reset)
        ste = integer_to_bytearray(int(state))
        vlv = integer_to_bytearray(valve)
        payload = rst + ste + vlv

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_fp_ch_id,
                                              message_id=MsgIds.MSG_ID_FP_VALVE_CMD_STATE_OVERRIDE_REQUEST.value,
                                              payload=payload)

        self.logger.debug("Override valve state")

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

    def cmd_valve_broadcast_interval_override(self, ms: int, reset: int = NO_RESET) -> int:
        """
        Constructs and sends the FP valve state override command.
        Constraints:
            Must be logged into FP.
            Given interval must be non-zero and a multiple of the FP general task interval (50 ms).

        @param ms:  unsigned int - broadcast interval (in ms)
        @param reset:  integer - 1 to reset a previous override, 0 to override
        @return: 1 if successful, zero otherwise

        """

        if not check_broadcast_interval_override_ms(ms):
            return False

        rst = integer_to_bytearray(reset)
        ivl = integer_to_bytearray(ms)
        payload = rst + ivl

        message = DenaliMessage.build_message(channel_id=DenaliChannels.dialin_to_fp_ch_id,
                                              message_id=MsgIds.MSG_ID_FP_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST.value,
                                              payload=payload)

        self.logger.debug("override FP valves states publish interval")

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

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