###########################################################################
#
# 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)      Zoltan Miskolci
# @date    (last)      09-Jan-2026
# @author  (original)  Peman Montazemi
# @date    (original)  19-May-2020
#
############################################################################

import struct
from logging import Logger
from collections import OrderedDict

from leahi_dialin.common.constants import NO_RESET
from leahi_dialin.common.fp_defs import fp_enum_repository, BETA_IOFP_VALVE_OFFSET
from leahi_dialin.common.msg_defs import MsgIds
from leahi_dialin.common.override_templates import cmd_generic_broadcast_interval_override, cmd_generic_override
from leahi_dialin.protocols.CAN import DenaliMessage, DenaliChannels
from leahi_dialin.utils.base import AbstractSubSystem, publish
from leahi_dialin.utils.conversions import integer_to_bytearray


# Valve states
ENERGIZED = True
DEENERGIZED = False


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

    # Valves states publish message field positions
    START_IO_VALVES_STATES = DenaliMessage.PAYLOAD_START_INDEX
    END_IO_VALVES_STATES = START_IO_VALVES_STATES + 1  # IO Valves States come in as a U08 value (1 byte)
    START_FP_VALVES_STATES = END_IO_VALVES_STATES
    END_FP_VALVES_STATES = START_FP_VALVES_STATES + 1  # FP Valves States come in as a U08 value (1 byte)

    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
            self.msg_id_fp_valves_states_data = MsgIds.MSG_ID_FP_VALVES_STATES_DATA.value
            self.can_interface.register_receiving_publication_function(channel_id, self.msg_id_fp_valves_states_data, self._handler_valves_sync)

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

        # NOTE: The len function counts the enums with the same number only once.
        self.valve_states_enum = [0 for _ in range(fp_enum_repository.FPValveNames.NUM_OF_FP_VALVES.value - 1)]

        for valve in fp_enum_repository.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.m12_valv.get("state"),
            self.p11_valv.get("state"),
            self.p33_valv.get("state"),
            self.p34_valv.get("state"),
            self.p37_valv.get("state"),
            self.p39_valv.get("state"),
            self.p6_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([
        "msg_id_fp_valves_states_data",
        "valve_states_all",
        "m4_valv",
        "m12_valv",
        "p11_valv",
        "p33_valv",
        "p34_valv",
        "p37_valv",
        "p39_valv",
        "p6_valv",
        "valve_states_enum",
        "fp_valves_states_timestamp"
    ])
    def _handler_valves_sync(self, message, timestamp=0.0):
        """
        Handles published FP valves states message.

        @param message:  published FP valves states message
        @return: none
        """
        # Extract each valve state from U08 valves states using bit-masking
        io_valves = struct.unpack('B', bytearray(message['message'][self.START_IO_VALVES_STATES:self.END_IO_VALVES_STATES]))
        self.m4_valv["state"] = self._binary_to_valve_state(io_valves[0] & 1)
        self.m12_valv["state"] = self._binary_to_valve_state(io_valves[0] & 2)
        self.valve_states_all = io_valves[0]

        # Extract each valve state from U08 valves states using bit-masking
        fp_valves = struct.unpack('B', bytearray(message['message'][self.START_FP_VALVES_STATES:self.END_FP_VALVES_STATES]))
        self.p11_valv["state"] = self._binary_to_valve_state(fp_valves[0] & 1)
        self.p33_valv["state"] = self._binary_to_valve_state(fp_valves[0] & 2)
        self.p34_valv["state"] = self._binary_to_valve_state(fp_valves[0] & 4)
        self.p37_valv["state"] = self._binary_to_valve_state(fp_valves[0] & 8)
        self.p39_valv["state"] = self._binary_to_valve_state(fp_valves[0] & 16)
        self.p6_valv["state"] = self._binary_to_valve_state(fp_valves[0] & 32)
        self.valve_states_all += fp_valves[0] << 8

        # Updating Valve_states_enum
        for i in range(0, fp_enum_repository.FPValveNames.NUM_OF_FP_VALVES.value - 1):
            self.valve_states_enum[i] = eval(f'self.{fp_enum_repository.FPValveNames(i).name.lower()}["state"]')
        
        # Extract each valve sensed state from U08 valves states using bit-masking
        start = self.END_FP_VALVES_STATES
        end = start + 1
        for valve_id in self.valves_sensed_states:
            if valve_id.lower().startswith('num'):
                continue
            self.valves_sensed_states[valve_id] = struct.unpack('B', bytearray(message['message'][start:end]))[0]
            start = end
            end += 1
        self.fp_valves_states_timestamp = timestamp


    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
        """
        return cmd_generic_broadcast_interval_override(
            ms = ms,
            reset = reset,
            channel_id = DenaliChannels.dialin_to_fp_ch_id,
            msg_id = MsgIds.MSG_ID_FP_VALVE_PUBLISH_INTERVAL_OVERRIDE_REQUEST,
            module_name = 'FP Valves',
            logger = self.logger,
            can_interface = self.can_interface)


    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

        valve_name = fp_enum_repository.FPValveNames(valve).name.split('_')[0]
        return cmd_generic_override(
            payload = payload,
            reset = reset,
            channel_id = DenaliChannels.dialin_to_fp_ch_id,
            msg_id = MsgIds.MSG_ID_FP_VALVE_SENSED_STATE_OVERRIDE_REQUEST,
            entity_name = f'FP {valve_name} Valve sensed state',
            override_text = str(state),
            logger = self.logger,
            can_interface = self.can_interface)


    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 + BETA_IOFP_VALVE_OFFSET)
        payload = rst + ste + vlv

        valve_name = fp_enum_repository.FPValveNames(valve).name.split('_')[0]
        return cmd_generic_override(
            payload = payload,
            reset = reset,
            channel_id = DenaliChannels.dialin_to_fp_ch_id,
            msg_id = MsgIds.MSG_ID_FP_VALVE_CMD_STATE_OVERRIDE_REQUEST,
            entity_name = f'FP {valve_name} Valve state',
            override_text = str(state),
            logger = self.logger,
            can_interface = self.can_interface)