"""
api_layers/protocols/modbus_rtu.py

Modbus RTU over RS-232 / RS-485.  Pure Python — no external library.

Supported function codes:
  FC03  Read Holding Registers
  FC04  Read Input Registers
  FC06  Write Single Register

Register data types:
  uint16  — unsigned 16-bit  (1 register)
  int16   — signed 16-bit    (1 register)
  float32 — IEEE-754 float   (2 registers, big-endian)
  int32   — signed 32-bit    (2 registers, big-endian)
"""

import math
import struct
import time
from dataclasses import dataclass
from typing import Dict, List, Optional

from api_layers.protocols.base_protocol import BaseProtocol


# ── CRC-16 (Modbus polynomial 0xA001) ────────────────────────────────────────

def _crc16(data: bytes) -> int:
    crc = 0xFFFF
    for byte in data:
        crc ^= byte
        for _ in range(8):
            crc = (crc >> 1) ^ 0xA001 if crc & 1 else crc >> 1
    return crc


def _frame(payload: bytes) -> bytes:
    return payload + struct.pack("<H", _crc16(payload))


# ── Channel definition ────────────────────────────────────────────────────────

@dataclass
class ModbusChannel:
    channel_id:    str
    name:          str
    register:      int           # 0-based register address
    function_code: int  = 0x03  # FC03=holding, FC04=input
    data_type:     str  = "uint16"   # uint16 | int16 | float32 | int32
    scale:         float = 1.0
    offset:        float = 0.0
    unit:          str  = ""


# ── Protocol layer ────────────────────────────────────────────────────────────

class ModbusRTULayer(BaseProtocol):

    def __init__(
        self,
        port:          str,
        baud:          int              = 9600,
        slave_addr:    int              = 1,
        channels:      List[ModbusChannel] = None,
        parity:        str              = "N",  # N / E / O
        stopbits:      int              = 1,
        poll_interval: float            = 0.1,
        simulate:      bool             = True,
    ):
        super().__init__(port, baud, poll_interval, simulate)
        self.slave_addr = slave_addr
        self.channels   = channels or []
        self._parity    = parity
        self._stopbits  = stopbits

    def _serial_kwargs(self) -> dict:
        import serial
        parity_map = {
            "N": serial.PARITY_NONE,
            "E": serial.PARITY_EVEN,
            "O": serial.PARITY_ODD,
        }
        return {
            "parity":   parity_map.get(self._parity, serial.PARITY_NONE),
            "stopbits": self._stopbits,
            "bytesize": 8,
        }

    # ── Read ──────────────────────────────────────────────────────────────

    def _read_registers(self, fc: int, start: int, count: int) -> List[int]:
        req  = _frame(struct.pack(">BBHH", self.slave_addr, fc, start, count))
        self._ser.write(req)
        time.sleep(0.005)
        n_bytes = 5 + 2 * count
        resp = self._ser.read(n_bytes)
        if len(resp) < n_bytes:
            raise IOError(f"Short response {len(resp)}/{n_bytes} bytes")
        crc_recv = struct.unpack("<H", resp[-2:])[0]
        if crc_recv != _crc16(resp[:-2]):
            raise ValueError("CRC mismatch")
        n_data = resp[2]
        return list(struct.unpack(f">{n_data // 2}H", resp[3:3 + n_data]))

    def _decode(self, ch: ModbusChannel, regs: List[int]) -> float:
        dt = ch.data_type
        if dt == "uint16":
            raw = regs[0]
        elif dt == "int16":
            raw = regs[0] if regs[0] < 0x8000 else regs[0] - 0x10000
        elif dt in ("float32", "int32"):
            combined = (regs[0] << 16) | regs[1]
            if dt == "float32":
                raw = struct.unpack(">f", struct.pack(">I", combined))[0]
            else:
                raw = combined if combined < 0x80000000 else combined - 0x100000000
        else:
            raw = regs[0]
        return float(raw) * ch.scale + ch.offset

    def _poll(self) -> Dict[str, float]:
        result: Dict[str, float] = {}
        for ch in self.channels:
            count = 2 if ch.data_type in ("float32", "int32") else 1
            try:
                regs = self._read_registers(ch.function_code, ch.register, count)
                result[ch.channel_id] = self._decode(ch, regs)
            except Exception:
                pass
        return result

    def _simulate(self, t: float) -> Dict[str, float]:
        return {
            ch.channel_id: (
                (math.sin(t * (0.5 + i * 0.3)) * 100 + 100) * ch.scale + ch.offset
            )
            for i, ch in enumerate(self.channels)
        }

    # ── Write ─────────────────────────────────────────────────────────────

    def _write_register(self, register: int, value: int) -> bool:
        req  = _frame(struct.pack(">BBHH", self.slave_addr, 0x06, register, value & 0xFFFF))
        self._ser.write(req)
        time.sleep(0.005)
        resp = self._ser.read(8)
        return len(resp) == 8

    def write(self, channel_id: str, value) -> bool:
        ch = next((c for c in self.channels if c.channel_id == channel_id), None)
        if ch is None:
            return False
        try:
            int_val = round((float(value) - ch.offset) / ch.scale)
            return self._write_register(ch.register, int_val)
        except Exception:
            return False