###########################################################################
#
# 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 ROValveStates(DialinEnum):
    VALVE_STATE_CLOSED = 0
    VALVE_STATE_OPEN = 1


@unique
class ROValveNames(DialinEnum):
    M4_VWI = 0                         # Valve (M4 VWi)
    P39_VROD = 1                        # Valve (P39 VROd)
    P6_VFF = 2                         # Valve (P6 VFF)
    P11_VPI = 3                         # Valve (P11 VPi)
    P33_VCR = 4                         # Valve (P33 VCr)
    P34_VCB = 5                         # Valve (P34 VCb)
    P37_VCD = 6                         # Valve (P37 VCd)
    M7_VFB = 7                         # Valve (M7 VFB)
    P20_SPP = 8                         # Valve (P20 SPP)

class ROValves(AbstractSubSystem):
    """
        Dialin API sub-class for RO 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.ro_valves_states_timestamp = 0.0

        if self.can_interface is not None:
            channel_id = DenaliChannels.ro_sync_broadcast_ch_id
            msg_id = MsgIds.MSG_ID_RO_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_vwi_state= {"id": ROValveNames.M4_VWI.value, "state": DEENERGIZED}
        self.p39_vrod_state = {"id": ROValveNames.P39_VROD.value, "state": DEENERGIZED}
        self.p6_vff_state = {"id": ROValveNames.P6_VFF.value, "state": DEENERGIZED}
        self.p11_vpi_state = {"id": ROValveNames.P11_VPI.value, "state": DEENERGIZED}
        self.p33_vcr_state = {"id": ROValveNames.P33_VCR.value, "state": DEENERGIZED}
        self.p34_vcb_state = {"id": ROValveNames.P34_VCB.value, "state": DEENERGIZED}
        self.p37_vcd_state = {"id": ROValveNames.P37_VCD.value, "state": DEENERGIZED}
        self.m7_vfb_state = {"id": ROValveNames.M7_VFB.value, "state": DEENERGIZED}
        self.p20_spp_state = {"id": ROValveNames.P20_SPP.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(ROValveNames))]

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

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

        @return: All valve states
        """
        return [
            self.m4_vwi_state.get("state"),
            self.p39_vrod_state.get("state"),
            self.p6_vff_state.get("state"),
            self.p11_vpi_state.get("state"),
            self.p33_vcr_state.get("state"),
            self.p34_vcb_state.get("state"),
            self.p37_vcd_state.get("state"),
            self.m7_vfb_state.get("state"),
            self.p20_spp_state.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([
        "ro_valves_states_timestamp",
        "valve_states_all",
        "m4_vwi_state",
        "p39_vrod_state",
        "p6_vff_state",
        "p11_vpi_state",
        "p33_vcr_state",
        "p34_vcb_state",
        "p37_vcd_state",
        "m7_vfb_state",
        "p20_spp_state",
        "valve_states_enum"
    ])
    def _handler_valves_sync(self, message, timestamp=0.0):
        """
        Handles published RO valves states message.

        @param message:  published RO 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_vwi_state["state"] = self._binary_to_valve_state(vst[0] & 1)
        self.p39_vrod_state["state"] = self._binary_to_valve_state(vst[0] & 2)
        self.p6_vff_state["state"] = self._binary_to_valve_state(vst[0] & 4)
        self.p11_vpi_state["state"] = self._binary_to_valve_state(vst[0] & 8)
        self.p33_vcr_state["state"] = self._binary_to_valve_state(vst[0] & 16)
        self.p34_vcb_state["state"] = self._binary_to_valve_state(vst[0] & 32)
        self.p37_vcd_state["state"] = self._binary_to_valve_state(vst[0] & 64)
        self.m7_vfb_state["state"] = self._binary_to_valve_state(vst[0] & 128)
        self.p20_spp_state["state"] = self._binary_to_valve_state(vst[0] & 256)

        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] = ROValveStates(valve_state_number).name
            start = end
            end += 1

        self.ro_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 RO.
            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_ro_ch_id,
                                              message_id=MsgIds.MSG_ID_RO_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 RO valve state override command.
        Constraints:
            Must be logged into RO.
            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_ro_ch_id,
                                              message_id=MsgIds.MSG_ID_RO_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 RO valve state override command.
        Constraints:
            Must be logged into RO.
            Given interval must be non-zero and a multiple of the RO 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_ro_ch_id,
                                              message_id=MsgIds.MSG_ID_RO_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST.value,
                                              payload=payload)

        self.logger.debug("override RO 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