from PySide6.QtCore import QObject, QTimer, Signal, Slot, Property
from PySide6.QtSerialBus import QModbusTcpClient, QModbusDevice, QModbusDataUnit
import struct
from functools import partial

# verifier l'ordre des registres attendus par l'automate (big endian / little endian)


class ConnectionHandler(QObject):

    # Signals for UI updates
    connectionStatusChanged = Signal(bool)
    errorOccurred = Signal(str)

    vitesseReelUpdated = Signal(float)
    courantReelUpdated = Signal(float)
    CpReelUpdated = Signal(float)
    CmaxReelUpdated = Signal(float)
    XmaxReelUpdated = Signal(float)
    penteReelUpdated = Signal(float)
    WpReelUpdated = Signal(float)
    T1ReelUpdated = Signal(float)
    T2ReelUpdated = Signal(float)

    def __init__(self, parent=None):
        super().__init__(parent)

        self._modbus_device = QModbusTcpClient(self)
        self._is_connected = False

        self._connection_check_timer = QTimer(self)
        self._connection_check_timer.setInterval(300)
        self._connection_check_timer.timeout.connect(self._read_all_registers)

        # Connect Modbus signals
        self._modbus_device.stateChanged.connect(self._on_state_changed)
        self._modbus_device.errorOccurred.connect(self._on_error)

        # List of registers to decode
        self._float_map = {
            1: self.vitesseReelUpdated,
            3: self.courantReelUpdated,
            5: self.CpReelUpdated,
            7: self.penteReelUpdated,
            9: self.T1ReelUpdated,
            11: self.T2ReelUpdated,
            13: self.XmaxReelUpdated,
            15: self.WpReelUpdated,
            17: self.CmaxReelUpdated,
        }

    # -------------------------------
    # Properties
    # -------------------------------

    @Property(bool, notify=connectionStatusChanged)
    def is_connected(self):
        return self._is_connected
    

    # -------------------------------
    # Connection handling
    # -------------------------------

    @Slot(list, int, int)
    def connect_button_clicked(self, ip_parts, port, server_address):

        self._server_address = server_address

        # Validate IP address
        try:
            ip_clean = ".".join(str(int(float(p))) for p in ip_parts[:4])
        except (ValueError, TypeError):
            self.errorOccurred.emit("Invalid IP address format")
            return

        print(f"[PY] Attempting connection to {ip_clean}:{port} (server={server_address})")

        # Prevent connection spam
        state = self._modbus_device.state()

        if state == QModbusDevice.ConnectingState:
            self.errorOccurred.emit("Already connecting... please wait.")
            return

        if state == QModbusDevice.ConnectedState:
            print("[PY] Disconnecting from Modbus...")
            self._modbus_device.disconnectDevice()
            return

        # Set connection parameters
        self._modbus_device.setConnectionParameter(QModbusDevice.NetworkAddressParameter, ip_clean)
        self._modbus_device.setConnectionParameter(QModbusDevice.NetworkPortParameter, port)
        self._modbus_device.setTimeout(2000)
        self._modbus_device.setNumberOfRetries(3)

        # Initiate connection
        if not self._modbus_device.connectDevice():
            # Only catches immediate internal errors
            self.errorOccurred.emit("Failed to start Modbus connection")
            print("[PY] connectDevice() returned False")
        else:
            print("[PY] connectDevice() initiated (asynchronous)")


    def _on_state_changed(self, state):

        print(f"[PY] Modbus state changed: {state}")
        connected = (state == QModbusDevice.ConnectedState)

        if connected != self._is_connected:
            self._is_connected = connected
            self.connectionStatusChanged.emit(connected)

        if connected:
            print("[PY] Connection successful, starting read timer.")
            self._connection_check_timer.start()
        else:
            print("[PY] Connection closed.")
            self._connection_check_timer.stop()

    def _on_error(self, error):
        if error != QModbusDevice.NoError:
            msg = self._modbus_device.errorString()
            print(f"[PY] Modbus error: {msg}")
            self.errorOccurred.emit(msg)

    # -------------------------------
    # Reading optimized
    # -------------------------------

    def _read_all_registers(self):
        """Reads 17 registers in one Modbus request"""

        if self._modbus_device.state() != QModbusDevice.ConnectedState:
            return

        start_addr = 1
        count = 18   # we need 18 registers so that address 17 has 2 registers

        unit = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, start_addr, count)

        reply = self._modbus_device.sendReadRequest(unit, self._server_address)

        if not reply:
            print("[PY] Read request failed to start")
            return

        if reply.isFinished():
            reply.deleteLater()
            return

        # Safe connection with partial to avoid lambda capture problems
        reply.finished.connect(partial(self._handle_block_reply, reply))

    # -------------------------------
    # Reply decoding
    # -------------------------------

    def _handle_block_reply(self, reply):

        if reply.error() != QModbusDevice.NoError:
            msg = reply.errorString()
            print(f"[PY] Read error: {msg}")
            self.errorOccurred.emit(msg)
            reply.deleteLater()
            return

        result = reply.result()
        if not result.isValid():
            print("[PY] Invalid Modbus result")
            self.errorOccurred.emit("Invalid Modbus result")
            reply.deleteLater()
            return
        registers = result.values()
        
        # Decode all floats from the block
        for start_addr, signal in self._float_map.items():

            idx = start_addr - 1  # convert Modbus start to list index

            if idx + 1 >= len(registers):
                print(f"[PY] Missing registers for address {start_addr}")
                continue

            # Build 32-bit raw int from 2 registers
            raw = (registers[idx + 1] << 16) | registers[idx]

            # Convert to float32 LE
            value = struct.unpack("<f", struct.pack("<I", raw))[0]

            signal.emit(value)

        reply.deleteLater()


"""
    def _make_reply_handler(self, reply, signal):
        def handler():
            self._handle_read_reply(reply, signal)

        return handler

    def read_modbus_data(self):
        if (
            not self._modbus_device
            or self._modbus_device.state() != QModbusDevice.ConnectedState
        ):
            print("[PY] Not connected, skipping read.")
            return

        # Read vitesseReel values
        vitesse = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 1, 2)
        replyVitesse = self._modbus_device.sendReadRequest(
            vitesse, self._server_address
        )
        if replyVitesse.isFinished():

            print("[PY] Read request failed to start.")
            return

        if not replyVitesse.isFinished():
            # replyVitesse.finished.connect(lambda: self._handle_read_reply(replyVitesse, self.vitesseReelUpdated))
            replyVitesse.finished.connect(
                self._make_reply_handler(replyVitesse, self.vitesseReelUpdated)
            )

        else:
            replyVitesse.deleteLater()

        # Read curant values
        courant = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 3, 2)
        replyCourant = self._modbus_device.sendReadRequest(
            courant, self._server_address
        )
        if not replyCourant:
            print("[PY] Read request failed to start.")
            return

        if not replyCourant.isFinished():
            replyCourant.finished.connect(
                lambda: self._handle_read_reply(replyCourant, self.courantReelUpdated)
            )
        else:
            replyCourant.deleteLater()

        # Read Cp values
        Cp = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 5, 2)
        replyCp = self._modbus_device.sendReadRequest(Cp, self._server_address)
        if not replyCp:
            print("[PY] Read request failed to start.")
            return

        if not replyCp.isFinished():
            replyCp.finished.connect(
                lambda: self._handle_read_reply(replyCp, self.CpReelUpdated)
            )
        else:
            replyCp.deleteLater()

        # Read Xmax values
        Xmax = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 13, 2)
        replyXmax = self._modbus_device.sendReadRequest(Xmax, self._server_address)
        if not replyXmax:
            print("[PY] Read request failed to start.")
            return

        if not replyXmax.isFinished():
            replyXmax.finished.connect(
                lambda: self._handle_read_reply(replyXmax, self.XmaxReelUpdated)
            )
        else:
            replyXmax.deleteLater()

        # Read Wp values
        Wp = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 15, 2)
        replyWp = self._modbus_device.sendReadRequest(Wp, self._server_address)
        if not replyWp:
            print("[PY] Read request failed to start.")
            return

        if not replyWp.isFinished():
            replyWp.finished.connect(
                lambda: self._handle_read_reply(replyWp, self.WpReelUpdated)
            )
        else:
            replyWp.deleteLater()

        # Read T1 values
        T1 = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 9, 2)
        replyT1 = self._modbus_device.sendReadRequest(T1, self._server_address)
        if not replyT1:
            print("[PY] Read request failed to start.")
            return

        if not replyT1.isFinished():
            replyT1.finished.connect(
                lambda: self._handle_read_reply(replyT1, self.T1ReelUpdated)
            )
        else:
            replyT1.deleteLater()

        # Read T2 values
        T2 = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 11, 2)
        replyT2 = self._modbus_device.sendReadRequest(T2, self._server_address)
        if not replyT2:
            print("[PY] Read request failed to start.")
            return

        if not replyT2.isFinished():
            replyT2.finished.connect(
                lambda: self._handle_read_reply(replyT2, self.T2ReelUpdated)
            )
        else:
            replyT2.deleteLater()

        # Read p values
        p = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 7, 2)
        replyp = self._modbus_device.sendReadRequest(p, self._server_address)
        if not replyp:
            print("[PY] Read request failed to start.")
            return

        if not replyp.isFinished():
            replyp.finished.connect(
                lambda: self._handle_read_reply(replyp, self.penteReelUpdated)
            )
        else:
            replyp.deleteLater()

        # Read Cmax values
        Cmax = QModbusDataUnit(QModbusDataUnit.HoldingRegisters, 17, 2)
        replyCmax = self._modbus_device.sendReadRequest(Cmax, self._server_address)
        if not replyCmax:
            print("[PY] Read request failed to start.")
            return

        if not replyCmax.isFinished():
            replyCmax.finished.connect(
                lambda: self._handle_read_reply(replyCmax, self.CmaxReelUpdated)
            )
        else:
            replyCmax.deleteLater()

    def _handle_read_reply(self, reply, signal):
        if reply.error() == QModbusDevice.NoError:
            registers = reply.result().values()
            if len(registers) >= 2:
                raw_value = (registers[1] << 16) | registers[0]
                value = struct.unpack("<f", struct.pack("<I", raw_value))[0]
                print(f"[PY] Read value to: {value}")
                signal.emit(value)
        else:
            print(f"[PY] Read error: {reply.errorString()}")
            self.errorOccurred.emit(f"Read error: {reply.errorString()}")
        reply.deleteLater()
"""