#!/opt/srasenv/bin/python3
"""
Genesis SLM MX 532 Laser Control Application
=============================================

This application controls a Genesis SLM MX 532 laser via I2C-over-serial protocol.

PROTOCOL OVERVIEW:
- Serial: /dev/ttyUSB0 @ 9600 8N1
- Protocol: NXP I2C tunneled over serial
- Packet format: [0x53][addr][len][cmd][data][0x50]

SAFETY WARNINGS:
- This laser has a MANUAL shutter - operate it manually
- Always close manual shutter before adjusting current
- Verify interlock status before opening manual shutter
- Use emergency stop if anything looks wrong
- Never bypass safety interlocks

USAGE:
1. Connect serial port in Configuration tab
2. Enable Remote and Keyswitch
3. Set current to desired level
4. Manually operate shutter as needed
5. Monitor temperature and current
6. Manually close shutter when done

For more information, see laser_control_implementation_guide.md
"""

import sys
import time
import serial
from datetime import datetime
from typing import Optional, List
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QTabWidget, QPushButton, QSlider, QSpinBox, QLabel, QComboBox,
    QLineEdit, QTextEdit, QCheckBox, QMessageBox, QGroupBox, QGridLayout
)
from PyQt6.QtCore import QObject, pyqtSignal, QTimer, Qt
from PyQt6.QtGui import QPalette, QColor

# ============================================================================
# CONSTANTS
# ============================================================================

# I2C Addresses (7-bit, write bit cleared)
ADDR_X9119_CURRENT = 0x52
ADDR_PCA9555_PS_DIO = 0x40
ADDR_PCA9555_HEAD_DIO = 0x44
ADDR_PCA9555_PS_GLUE_IN = 0x48
ADDR_PCA9555_PS_GLUE_OUT = 0x4a
ADDR_AD5254 = 0x58
ADDR_ADS7828 = 0x90
ADDR_EEPROM = 0xa4
ADDR_STM32 = 0xae

# PCA9555 Bit Masks (0x4a - PS Glue Out)
BIT_SHUTTER = 0x01
BIT_CURRENT_MODE = 0x04
BIT_REMOTE_ENABLE = 0x08
BIT_ANALOG_ENABLE = 0x10
BIT_KEYSWITCH = 0x20

# X9119 Commands
CMD_X9119_WRITE_WIPER = 0xa0

# ADS7828 Channels
CHAN_CURRENT_ACTUAL = 0x84
CHAN_PHOTO_ACTUAL = 0xe4
CHAN_MAIN_TEMP = 0x94
CHAN_ETALON_TEMP = 0xa4  # TODO: Verify channel
CHAN_SHG_TEMP = 0xb4     # TODO: Verify channel

# Scaling constants
AMPS_FULLSCALE = 12.0
WATTS_FULLSCALE = 2.0
POWER_LIMIT = 0.55
ADC_TO_VOLTS = 0.000244140625  # 1/4096

# Temperature calibration constants (for future use)
# Steinhart-Hart: A=0.0011279, B=0.00023429, C=8.7298e-8
# PT1000: Vref=12V, R1=10kΩ
# Currently displaying raw ADC values until circuit parameters are confirmed

# Serial Protocol
NXP_START_BYTE = 0x53
NXP_STOP_BYTE = 0x50

# ============================================================================
# SERIAL COMMUNICATION LAYER
# ============================================================================

class SerialComm(QObject):
    """Handles serial port communication with the laser controller."""

    connected = pyqtSignal()
    disconnected = pyqtSignal()
    error = pyqtSignal(str)
    data_received = pyqtSignal(bytes)
    packet_sent = pyqtSignal(bytes)

    def __init__(self):
        super().__init__()
        self.port: Optional[serial.Serial] = None
        self.is_connected = False
        self.timeout = 1.0
        self.packet_log: List[str] = []

    def connect(self, port_name: str, baudrate: int = 9600) -> bool:
        """
        Connect to serial port.

        Args:
            port_name: Serial port path (e.g., '/dev/ttyUSB0')
            baudrate: Baud rate (default: 9600)

        Returns:
            True if connection successful
        """
        try:
            self.port = serial.Serial(
                port=port_name,
                baudrate=baudrate,
                bytesize=serial.EIGHTBITS,
                parity=serial.PARITY_NONE,
                stopbits=serial.STOPBITS_ONE,
                timeout=self.timeout
            )
            self.is_connected = True
            self.connected.emit()
            self._log_packet(f"Connected to {port_name} @ {baudrate}")
            return True
        except Exception as e:
            self.error.emit(f"Connection failed: {str(e)}")
            return False

    def disconnect(self):
        """Disconnect from serial port."""
        if self.port and self.port.is_open:
            self.port.close()
        self.is_connected = False
        self.disconnected.emit()
        self._log_packet("Disconnected")

    def write_packet(self, data: bytes) -> bool:
        """
        Write packet to serial port.

        Args:
            data: Bytes to write

        Returns:
            True if write successful
        """
        if not self.is_connected or not self.port:
            self.error.emit("Not connected")
            return False

        try:
            self.port.write(data)
            self.packet_sent.emit(data)
            self._log_packet(f"TX: {data.hex(' ')}")
            return True
        except Exception as e:
            self.error.emit(f"Write failed: {str(e)}")
            return False

    def read_packet(self, length: int) -> Optional[bytes]:
        """
        Read packet from serial port.

        Args:
            length: Number of bytes to read

        Returns:
            Bytes read or None on error
        """
        if not self.is_connected or not self.port:
            self.error.emit("Not connected")
            return None

        try:
            data = self.port.read(length)
            if data:
                self.data_received.emit(data)
                self._log_packet(f"RX: {data.hex(' ')}")
            return data
        except Exception as e:
            self.error.emit(f"Read failed: {str(e)}")
            return None

    def _log_packet(self, message: str):
        """Log packet with timestamp."""
        timestamp = datetime.now().strftime("%H:%M:%S.%f")[:-3]
        log_entry = f"[{timestamp}] {message}"
        self.packet_log.append(log_entry)

    def get_packet_log(self) -> List[str]:
        """Get packet log."""
        return self.packet_log.copy()

    def clear_packet_log(self):
        """Clear packet log."""
        self.packet_log.clear()

# ============================================================================
# I2C PROTOCOL LAYER
# ============================================================================

class I2CProtocol(QObject):
    """Implements NXP I2C-over-serial protocol."""

    def __init__(self, serial_comm: SerialComm):
        super().__init__()
        self.serial = serial_comm

    def nxp_write(self, i2c_addr_write: int, cmd: int, data: int, data_len: int) -> bool:
        """
        Build and send NXP I2C write packet.

        Args:
            i2c_addr_write: I2C device address (write bit cleared)
            cmd: Command byte(s) - int for 1 or 2 bytes
            data: Data value to write
            data_len: 1, 2, or 4 bytes

        Returns:
            True if successful
        """
        # Determine command length
        if cmd <= 0xFF:
            cmd_bytes = bytes([cmd])
        else:
            cmd_bytes = cmd.to_bytes(2, 'big')

        # Convert data to bytes (big-endian)
        data_bytes = data.to_bytes(data_len, 'big')

        # Calculate total length
        total_len = len(cmd_bytes) + len(data_bytes)

        # Build packet: [0x53][addr][len][cmd...][data...][0x50]
        packet = bytes([
            NXP_START_BYTE,
            i2c_addr_write,
            total_len
        ]) + cmd_bytes + data_bytes + bytes([NXP_STOP_BYTE])

        return self.serial.write_packet(packet)

    def nxp_read(self, i2c_addr_write: int, cmd: int, cmd_len: int, data_len: int) -> Optional[int]:
        """
        Build and send NXP I2C read packet.

        Args:
            i2c_addr_write: I2C device address (write bit cleared)
            cmd: Command byte(s)
            cmd_len: 1 or 2 bytes
            data_len: Number of bytes to read

        Returns:
            Integer value read from device or None on error
        """
        # Convert command to bytes
        if cmd_len == 1:
            cmd_bytes = bytes([cmd])
        else:
            cmd_bytes = cmd.to_bytes(2, 'big')

        # Build packet: [0x53][addr][cmd_len][cmd...][0x53][addr|0x01][data_len][0x50]
        packet = bytes([
            NXP_START_BYTE,
            i2c_addr_write,
            cmd_len
        ]) + cmd_bytes + bytes([
            NXP_START_BYTE,
            i2c_addr_write | 0x01,  # Read address
            data_len,
            NXP_STOP_BYTE
        ])

        # Send packet
        if not self.serial.write_packet(packet):
            return None

        # Read response
        response = self.serial.read_packet(data_len)
        if not response or len(response) != data_len:
            return None

        # Convert bytes to integer (big-endian)
        return int.from_bytes(response, 'big')

    # Read strategies

    def i2c_read_one(self, addr: int, cmd: int, data_len: int) -> Optional[int]:
        """
        Single read, no filtering. Use for digital I/O.

        Args:
            addr: I2C address
            cmd: Command byte(s)
            data_len: Number of bytes to read

        Returns:
            Value read or None on error
        """
        cmd_len = 1 if cmd <= 0xFF else 2
        return self.nxp_read(addr, cmd, cmd_len, data_len)

    def i2c_read_match_two(self, addr: int, cmd: int, data_len: int, max_attempts: int = 5) -> Optional[int]:
        """
        Read until 2 values match (up to max_attempts). Most reliable.
        Use for EEPROM reads, configuration values.

        Args:
            addr: I2C address
            cmd: Command byte(s)
            data_len: Number of bytes to read
            max_attempts: Maximum read attempts

        Returns:
            Matched value or first value if no match
        """
        cmd_len = 1 if cmd <= 0xFF else 2
        readings = []

        for attempt in range(max_attempts):
            value = self.nxp_read(addr, cmd, cmd_len, data_len)
            if value is None:
                continue
            readings.append(value)
            if readings.count(value) >= 2:
                return value
            time.sleep(0.01)

        return readings[0] if readings else None

    def i2c_read_discard_high_low(self, addr: int, cmd: int, data_len: int) -> Optional[int]:
        """
        Read 3 times, return median. Filters noise.
        Use for ADC readings (current, temperature, voltage).

        Args:
            addr: I2C address
            cmd: Command byte(s)
            data_len: Number of bytes to read

        Returns:
            Median value or None on error
        """
        cmd_len = 1 if cmd <= 0xFF else 2
        readings = []

        for _ in range(3):
            value = self.nxp_read(addr, cmd, cmd_len, data_len)
            if value is not None:
                readings.append(value)
            time.sleep(0.01)

        if len(readings) < 3:
            return readings[0] if readings else None

        return sorted(readings)[1]  # Median

    # Device-specific functions

    def pca9555_read_port(self, addr: int, port: int) -> Optional[int]:
        """Read PCA9555 port register (0x00-0x07)."""
        return self.i2c_read_one(addr, port, 1)

    def pca9555_write_port(self, addr: int, port: int, value: int) -> bool:
        """Write PCA9555 port register."""
        return self.nxp_write(addr, port, value, 1)

    def pca9555_set_bit(self, addr: int, port: int, bitmask: int, state: bool) -> bool:
        """
        Set or clear specific bit on PCA9555.
        Reads current value, modifies bit, writes back.

        Args:
            addr: I2C address
            port: Port number (0 or 1)
            bitmask: Bit mask
            state: True to set, False to clear

        Returns:
            True if successful
        """
        # Read current output port value
        current = self.pca9555_read_port(addr, 0x02 + port)
        if current is None:
            return False

        # Modify bit
        if state:
            new_value = current | bitmask
        else:
            new_value = current & ~bitmask

        # Write back
        return self.pca9555_write_port(addr, 0x02 + port, new_value)

    def x9119_write_wiper(self, addr: int, value: int) -> bool:
        """
        Set X9119 wiper position (0-1023).

        Args:
            addr: I2C address
            value: Wiper position (0-1023)

        Returns:
            True if successful
        """
        if value > 1023:
            raise ValueError("X9119 value must be 0-1023")
        return self.nxp_write(addr, CMD_X9119_WRITE_WIPER, value, 2)

    def ads7828_read(self, addr: int, channel: int) -> Optional[int]:
        """
        Read ADS7828 ADC channel.

        Args:
            addr: I2C address
            channel: Channel command byte

        Returns:
            12-bit ADC value or None on error
        """
        return self.i2c_read_discard_high_low(addr, channel, 2)

# ============================================================================
# LASER CONTROL LAYER
# ============================================================================

class LaserControl(QObject):
    """High-level laser control functions."""

    status_changed = pyqtSignal(str)

    def __init__(self, i2c_protocol: I2CProtocol):
        super().__init__()
        self.i2c = i2c_protocol

    # Control functions

    def set_current(self, value: int) -> bool:
        """
        CCMD= - Set laser current (0-1023).

        Args:
            value: Current setting (0-1023)

        Returns:
            True if successful
        """
        if not 0 <= value <= 1023:
            return False
        return self.i2c.x9119_write_wiper(ADDR_X9119_CURRENT, value)

    def set_power_cmd(self, value: int) -> bool:
        """
        PCMD= - Set power command (0-1023).

        Args:
            value: Power setting (0-1023)

        Returns:
            True if successful
        """
        if not 0 <= value <= 1023:
            return False
        return self.i2c.x9119_write_wiper(ADDR_X9119_CURRENT, value)

    def set_shutter(self, state: bool) -> bool:
        """
        SHCMD= - Control shutter (True=open, False=closed).

        Args:
            state: True to open, False to close

        Returns:
            True if successful
        """
        return self.i2c.pca9555_set_bit(ADDR_PCA9555_PS_GLUE_OUT, 0, BIT_SHUTTER, state)

    def set_keyswitch(self, state: bool) -> bool:
        """
        KSWCMD= - Control keyswitch (True=on, False=off).

        Args:
            state: True for on, False for off

        Returns:
            True if successful
        """
        return self.i2c.pca9555_set_bit(ADDR_PCA9555_PS_GLUE_OUT, 0, BIT_KEYSWITCH, state)

    def set_remote_enable(self, state: bool) -> bool:
        """
        REM= - Enable remote control (True=enabled).

        Args:
            state: True to enable, False to disable

        Returns:
            True if successful
        """
        return self.i2c.pca9555_set_bit(ADDR_PCA9555_PS_GLUE_OUT, 0, BIT_REMOTE_ENABLE, state)

    def set_analog_enable(self, state: bool) -> bool:
        """
        ANACMD= - Enable analog input (True=enabled).

        Args:
            state: True to enable, False to disable

        Returns:
            True if successful
        """
        return self.i2c.pca9555_set_bit(ADDR_PCA9555_PS_GLUE_OUT, 0, BIT_ANALOG_ENABLE, state)

    def set_current_mode(self, state: bool) -> bool:
        """
        CMODECMD= - Set current mode (True=enabled).

        Args:
            state: True to enable, False to disable

        Returns:
            True if successful
        """
        return self.i2c.pca9555_set_bit(ADDR_PCA9555_PS_GLUE_OUT, 0, BIT_CURRENT_MODE, state)

    # Monitoring functions

    def get_current_actual(self) -> Optional[float]:
        """
        Read actual current from ADC.

        Returns:
            Current in Amps or None on error
        """
        raw = self.i2c.ads7828_read(ADDR_ADS7828, CHAN_CURRENT_ACTUAL)
        if raw is None:
            return None
        return raw * AMPS_FULLSCALE * ADC_TO_VOLTS

    def get_power_actual(self) -> Optional[float]:
        """
        Read actual power from ADC.

        Returns:
            Power in Watts or None on error
        """
        raw = self.i2c.ads7828_read(ADDR_ADS7828, CHAN_PHOTO_ACTUAL)
        if raw is None:
            return None
        return raw * WATTS_FULLSCALE * ADC_TO_VOLTS

    def get_main_temp(self) -> Optional[int]:
        """
        Read main crystal temperature (raw ADC value).

        Returns:
            Raw ADC value (0-4095) or None on error
        """
        return self.i2c.ads7828_read(ADDR_ADS7828, CHAN_MAIN_TEMP)

    def get_etalon_temp(self) -> Optional[int]:
        """
        Read etalon temperature (raw ADC value).

        Returns:
            Raw ADC value (0-4095) or None on error
        """
        return self.i2c.ads7828_read(ADDR_ADS7828, CHAN_ETALON_TEMP)

    def get_shg_temp(self) -> Optional[int]:
        """
        Read SHG temperature (raw ADC value).

        Returns:
            Raw ADC value (0-4095) or None on error
        """
        return self.i2c.ads7828_read(ADDR_ADS7828, CHAN_SHG_TEMP)

    def get_interlock_status(self) -> Optional[bool]:
        """
        Check interlock status.

        Returns:
            True if OK, False if fault, None on error
        """
        value = self.i2c.pca9555_read_port(ADDR_PCA9555_PS_GLUE_IN, 0x00)
        if value is None:
            return None
        return bool(value & 0x01)

    def get_ldd_enable(self) -> Optional[bool]:
        """
        Check if laser diode driver is enabled.

        Returns:
            True if enabled, False if disabled, None on error
        """
        value = self.i2c.pca9555_read_port(ADDR_PCA9555_PS_DIO, 0x00)
        if value is None:
            return None
        return not bool(value & 0x01)  # Inverted logic

    def get_ps_glue_out_status(self) -> Optional[int]:
        """
        Read PS glue output port status.

        Returns:
            Port value or None on error
        """
        return self.i2c.pca9555_read_port(ADDR_PCA9555_PS_GLUE_OUT, 0x02)

    # Safety functions

    def emergency_stop(self) -> bool:
        """
        Emergency stop - set current to 0, disable keyswitch.
        Note: Shutter is manually operated on this laser.

        Returns:
            True if all operations successful
        """
        success = True
        success &= self.set_current(0)
        success &= self.set_keyswitch(False)
        self.status_changed.emit("EMERGENCY STOP ACTIVATED")
        return success

    def safe_state(self) -> bool:
        """
        Set laser to safe state.
        Note: Shutter is manually operated on this laser.

        Returns:
            True if successful
        """
        success = True
        success &= self.set_current(0)
        success &= self.set_analog_enable(False)
        return success

    def pre_flight_check(self) -> tuple[bool, str]:
        """
        Pre-flight safety check.
        Note: Shutter is manually operated on this laser.

        Returns:
            (safe, message) tuple
        """
        # Check remote enable
        status = self.get_ps_glue_out_status()
        if status is None:
            return False, "Cannot read status"

        if not (status & BIT_REMOTE_ENABLE):
            return False, "Remote enable is OFF"

        if not (status & BIT_KEYSWITCH):
            return False, "Keyswitch is OFF"

        # Check interlock
        interlock = self.get_interlock_status()
        if interlock is None:
            return False, "Cannot read interlock status"

        if not interlock:
            return False, "Interlock is OPEN"

        return True, "All checks passed"

# ============================================================================
# GUI - BASIC CONTROLS TAB
# ============================================================================

class BasicControlTab(QWidget):
    """Basic laser control interface."""

    def __init__(self, laser: LaserControl):
        super().__init__()
        self.laser = laser
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout()

        # Current control
        current_group = QGroupBox("Current Control")
        current_layout = QGridLayout()

        self.current_slider = QSlider(Qt.Orientation.Horizontal)
        self.current_slider.setRange(0, 1023)
        self.current_slider.setValue(0)
        self.current_slider.valueChanged.connect(self.on_current_changed)

        self.current_spinbox = QSpinBox()
        self.current_spinbox.setRange(0, 1023)
        self.current_spinbox.setValue(0)
        self.current_spinbox.valueChanged.connect(self.current_slider.setValue)
        self.current_slider.valueChanged.connect(self.current_spinbox.setValue)

        self.current_percent_label = QLabel("0%")

        self.current_zero_btn = QPushButton("Set to 0")
        self.current_zero_btn.clicked.connect(lambda: self.current_slider.setValue(0))

        current_layout.addWidget(QLabel("Current:"), 0, 0)
        current_layout.addWidget(self.current_slider, 0, 1)
        current_layout.addWidget(self.current_spinbox, 0, 2)
        current_layout.addWidget(self.current_percent_label, 0, 3)
        current_layout.addWidget(self.current_zero_btn, 1, 1)

        current_group.setLayout(current_layout)
        layout.addWidget(current_group)

        # Power command
        power_group = QGroupBox("Power Command")
        power_layout = QGridLayout()

        self.power_slider = QSlider(Qt.Orientation.Horizontal)
        self.power_slider.setRange(0, 1023)
        self.power_slider.setValue(0)
        self.power_slider.valueChanged.connect(self.on_power_changed)

        self.power_spinbox = QSpinBox()
        self.power_spinbox.setRange(0, 1023)
        self.power_spinbox.setValue(0)
        self.power_spinbox.valueChanged.connect(self.power_slider.setValue)
        self.power_slider.valueChanged.connect(self.power_spinbox.setValue)

        power_layout.addWidget(QLabel("Power:"), 0, 0)
        power_layout.addWidget(self.power_slider, 0, 1)
        power_layout.addWidget(self.power_spinbox, 0, 2)

        power_group.setLayout(power_layout)
        layout.addWidget(power_group)

        # Digital controls
        digital_group = QGroupBox("Digital Controls")
        digital_layout = QGridLayout()

        self.keyswitch_btn = QPushButton("Keyswitch: OFF")
        self.keyswitch_btn.setCheckable(True)
        self.keyswitch_btn.clicked.connect(self.on_keyswitch_clicked)

        self.remote_btn = QPushButton("Remote: OFF")
        self.remote_btn.setCheckable(True)
        self.remote_btn.clicked.connect(self.on_remote_clicked)

        self.analog_btn = QPushButton("Analog: OFF")
        self.analog_btn.setCheckable(True)
        self.analog_btn.clicked.connect(self.on_analog_clicked)

        self.current_mode_btn = QPushButton("Current Mode: OFF")
        self.current_mode_btn.setCheckable(True)
        self.current_mode_btn.clicked.connect(self.on_current_mode_clicked)

        digital_layout.addWidget(self.keyswitch_btn, 0, 0)
        digital_layout.addWidget(self.remote_btn, 0, 1)
        digital_layout.addWidget(self.analog_btn, 1, 0)
        digital_layout.addWidget(self.current_mode_btn, 1, 1)

        digital_group.setLayout(digital_layout)
        layout.addWidget(digital_group)

        # Emergency stop
        self.emergency_btn = QPushButton("EMERGENCY STOP")
        self.emergency_btn.setObjectName("emergency")
        self.emergency_btn.clicked.connect(self.on_emergency_stop)
        layout.addWidget(self.emergency_btn)

        # Status display
        status_group = QGroupBox("Status")
        status_layout = QVBoxLayout()

        self.current_actual_label = QLabel("Current Actual: --")
        self.connection_status_label = QLabel("Connection: Disconnected")

        status_layout.addWidget(self.current_actual_label)
        status_layout.addWidget(self.connection_status_label)

        status_group.setLayout(status_layout)
        layout.addWidget(status_group)

        layout.addStretch()
        self.setLayout(layout)

    def on_current_changed(self, value: int):
        """Handle current slider change."""
        percent = (value / 1023.0) * 100
        self.current_percent_label.setText(f"{percent:.1f}%")
        self.laser.set_current(value)

    def on_power_changed(self, value: int):
        """Handle power slider change."""
        self.laser.set_power_cmd(value)

    def on_keyswitch_clicked(self, checked: bool):
        """Handle keyswitch button click."""
        self.laser.set_keyswitch(checked)
        self.keyswitch_btn.setText(f"Keyswitch: {'ON' if checked else 'OFF'}")

    def on_remote_clicked(self, checked: bool):
        """Handle remote enable button click."""
        self.laser.set_remote_enable(checked)
        self.remote_btn.setText(f"Remote: {'ON' if checked else 'OFF'}")

    def on_analog_clicked(self, checked: bool):
        """Handle analog enable button click."""
        self.laser.set_analog_enable(checked)
        self.analog_btn.setText(f"Analog: {'ON' if checked else 'OFF'}")

    def on_current_mode_clicked(self, checked: bool):
        """Handle current mode button click."""
        self.laser.set_current_mode(checked)
        self.current_mode_btn.setText(f"Current Mode: {'ON' if checked else 'OFF'}")

    def on_emergency_stop(self):
        """Handle emergency stop button click."""
        self.laser.emergency_stop()
        self.reset_controls()

    def reset_controls(self):
        """Reset all controls to safe state."""
        self.current_slider.setValue(0)
        self.keyswitch_btn.setChecked(False)
        self.keyswitch_btn.setText("Keyswitch: OFF")

    def update_current_actual(self, value: Optional[float]):
        """Update current actual display."""
        if value is not None:
            self.current_actual_label.setText(f"Current Actual: {value:.3f} A")
        else:
            self.current_actual_label.setText("Current Actual: --")

    def set_connection_status(self, connected: bool):
        """Update connection status display."""
        if connected:
            self.connection_status_label.setText("Connection: Connected")
            self.connection_status_label.setStyleSheet("color: #00ff00;")
        else:
            self.connection_status_label.setText("Connection: Disconnected")
            self.connection_status_label.setStyleSheet("color: #ff0000;")

# ============================================================================
# GUI - MONITORING TAB
# ============================================================================

class MonitoringTab(QWidget):
    """Real-time monitoring interface."""

    def __init__(self, laser: LaserControl):
        super().__init__()
        self.laser = laser
        self.auto_refresh_enabled = False
        self.refresh_timer = QTimer()
        self.refresh_timer.timeout.connect(self.refresh_readings)
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout()

        # Real-time readings
        readings_group = QGroupBox("Real-Time Readings")
        readings_layout = QGridLayout()

        self.current_actual_label = QLabel("--")
        self.power_actual_label = QLabel("--")
        self.main_temp_label = QLabel("--")
        self.etalon_temp_label = QLabel("--")
        self.shg_temp_label = QLabel("--")
        self.interlock_label = QLabel("--")
        self.ldd_enable_label = QLabel("--")

        readings_layout.addWidget(QLabel("Current Actual:"), 0, 0)
        readings_layout.addWidget(self.current_actual_label, 0, 1)
        readings_layout.addWidget(QLabel("Power Actual:"), 1, 0)
        readings_layout.addWidget(self.power_actual_label, 1, 1)
        readings_layout.addWidget(QLabel("Main Temperature:"), 2, 0)
        readings_layout.addWidget(self.main_temp_label, 2, 1)
        readings_layout.addWidget(QLabel("Etalon Temperature:"), 3, 0)
        readings_layout.addWidget(self.etalon_temp_label, 3, 1)
        readings_layout.addWidget(QLabel("SHG Temperature:"), 4, 0)
        readings_layout.addWidget(self.shg_temp_label, 4, 1)
        readings_layout.addWidget(QLabel("Interlock Status:"), 5, 0)
        readings_layout.addWidget(self.interlock_label, 5, 1)
        readings_layout.addWidget(QLabel("LDD Enable:"), 6, 0)
        readings_layout.addWidget(self.ldd_enable_label, 6, 1)

        readings_group.setLayout(readings_layout)
        layout.addWidget(readings_group)

        # Controls
        controls_group = QGroupBox("Controls")
        controls_layout = QVBoxLayout()

        refresh_rate_layout = QHBoxLayout()
        refresh_rate_layout.addWidget(QLabel("Refresh Rate (ms):"))
        self.refresh_rate_slider = QSlider(Qt.Orientation.Horizontal)
        self.refresh_rate_slider.setRange(100, 2000)
        self.refresh_rate_slider.setValue(500)
        self.refresh_rate_slider.valueChanged.connect(self.on_refresh_rate_changed)
        refresh_rate_layout.addWidget(self.refresh_rate_slider)
        self.refresh_rate_label = QLabel("500")
        refresh_rate_layout.addWidget(self.refresh_rate_label)
        controls_layout.addLayout(refresh_rate_layout)

        self.auto_refresh_checkbox = QCheckBox("Enable Auto-Refresh")
        self.auto_refresh_checkbox.stateChanged.connect(self.on_auto_refresh_changed)
        controls_layout.addWidget(self.auto_refresh_checkbox)

        self.manual_refresh_btn = QPushButton("Manual Refresh")
        self.manual_refresh_btn.clicked.connect(self.refresh_readings)
        controls_layout.addWidget(self.manual_refresh_btn)

        controls_group.setLayout(controls_layout)
        layout.addWidget(controls_group)

        layout.addStretch()
        self.setLayout(layout)

    def on_refresh_rate_changed(self, value: int):
        """Handle refresh rate change."""
        self.refresh_rate_label.setText(str(value))
        if self.auto_refresh_enabled:
            self.refresh_timer.setInterval(value)

    def on_auto_refresh_changed(self, state: int):
        """Handle auto-refresh checkbox change."""
        self.auto_refresh_enabled = bool(state)
        if self.auto_refresh_enabled:
            interval = self.refresh_rate_slider.value()
            self.refresh_timer.start(interval)
        else:
            self.refresh_timer.stop()

    def refresh_readings(self):
        """Refresh all sensor readings."""
        # Current actual
        current = self.laser.get_current_actual()
        if current is not None:
            self.current_actual_label.setText(f"{current:.3f} A")
        else:
            self.current_actual_label.setText("--")

        # Power actual
        power = self.laser.get_power_actual()
        if power is not None:
            self.power_actual_label.setText(f"{power:.3f} W")
        else:
            self.power_actual_label.setText("--")

        # Main temperature (raw ADC)
        temp = self.laser.get_main_temp()
        if temp is not None:
            self.main_temp_label.setText(f"ADC: {temp}")
        else:
            self.main_temp_label.setText("--")

        # Etalon temperature (raw ADC)
        etalon_temp = self.laser.get_etalon_temp()
        if etalon_temp is not None:
            self.etalon_temp_label.setText(f"ADC: {etalon_temp}")
        else:
            self.etalon_temp_label.setText("--")

        # SHG temperature (raw ADC)
        shg_temp = self.laser.get_shg_temp()
        if shg_temp is not None:
            self.shg_temp_label.setText(f"ADC: {shg_temp}")
        else:
            self.shg_temp_label.setText("--")

        # Interlock status
        interlock = self.laser.get_interlock_status()
        if interlock is not None:
            if interlock:
                self.interlock_label.setText("OK")
                self.interlock_label.setStyleSheet("color: #00ff00; font-weight: bold;")
            else:
                self.interlock_label.setText("FAULT")
                self.interlock_label.setStyleSheet("color: #ff0000; font-weight: bold;")
        else:
            self.interlock_label.setText("--")
            self.interlock_label.setStyleSheet("")

        # LDD enable
        ldd = self.laser.get_ldd_enable()
        if ldd is not None:
            self.ldd_enable_label.setText("ON" if ldd else "OFF")
        else:
            self.ldd_enable_label.setText("--")

# ============================================================================
# GUI - ADVANCED TAB
# ============================================================================

class AdvancedTab(QWidget):
    """Advanced I2C interface and packet monitoring."""

    def __init__(self, i2c: I2CProtocol, serial_comm: SerialComm):
        super().__init__()
        self.i2c = i2c
        self.serial = serial_comm
        self.init_ui()

        # Update packet log periodically
        self.log_timer = QTimer()
        self.log_timer.timeout.connect(self.update_packet_log)
        self.log_timer.start(500)

    def init_ui(self):
        layout = QVBoxLayout()

        # Raw I2C interface
        i2c_group = QGroupBox("Raw I2C Interface")
        i2c_layout = QGridLayout()

        self.addr_input = QLineEdit()
        self.addr_input.setPlaceholderText("0x52")

        self.cmd_input = QLineEdit()
        self.cmd_input.setPlaceholderText("0xa0")

        self.data_input = QLineEdit()
        self.data_input.setPlaceholderText("0x0100")

        self.data_len_combo = QComboBox()
        self.data_len_combo.addItems(["1 byte", "2 bytes", "4 bytes"])
        self.data_len_combo.setCurrentIndex(1)

        self.write_btn = QPushButton("Write")
        self.write_btn.clicked.connect(self.on_write_clicked)

        self.read_btn = QPushButton("Read")
        self.read_btn.clicked.connect(self.on_read_clicked)

        self.response_display = QLineEdit()
        self.response_display.setReadOnly(True)
        self.response_display.setPlaceholderText("Response will appear here")

        i2c_layout.addWidget(QLabel("Device Address (hex):"), 0, 0)
        i2c_layout.addWidget(self.addr_input, 0, 1)
        i2c_layout.addWidget(QLabel("Command (hex):"), 1, 0)
        i2c_layout.addWidget(self.cmd_input, 1, 1)
        i2c_layout.addWidget(QLabel("Data (hex):"), 2, 0)
        i2c_layout.addWidget(self.data_input, 2, 1)
        i2c_layout.addWidget(QLabel("Data Length:"), 3, 0)
        i2c_layout.addWidget(self.data_len_combo, 3, 1)
        i2c_layout.addWidget(self.write_btn, 4, 0)
        i2c_layout.addWidget(self.read_btn, 4, 1)
        i2c_layout.addWidget(QLabel("Response:"), 5, 0)
        i2c_layout.addWidget(self.response_display, 5, 1)

        i2c_group.setLayout(i2c_layout)
        layout.addWidget(i2c_group)

        # Packet monitor
        monitor_group = QGroupBox("Packet Monitor")
        monitor_layout = QVBoxLayout()

        self.packet_log = QTextEdit()
        self.packet_log.setReadOnly(True)
        self.packet_log.setMaximumHeight(200)
        monitor_layout.addWidget(self.packet_log)

        log_buttons = QHBoxLayout()
        self.clear_log_btn = QPushButton("Clear Log")
        self.clear_log_btn.clicked.connect(self.on_clear_log)
        log_buttons.addWidget(self.clear_log_btn)

        self.export_log_btn = QPushButton("Export to File")
        self.export_log_btn.clicked.connect(self.on_export_log)
        log_buttons.addWidget(self.export_log_btn)

        monitor_layout.addLayout(log_buttons)
        monitor_group.setLayout(monitor_layout)
        layout.addWidget(monitor_group)

        layout.addStretch()
        self.setLayout(layout)

    def on_write_clicked(self):
        """Handle write button click."""
        try:
            addr = int(self.addr_input.text(), 16)
            cmd = int(self.cmd_input.text(), 16)
            data = int(self.data_input.text(), 16)
            data_len = [1, 2, 4][self.data_len_combo.currentIndex()]

            success = self.i2c.nxp_write(addr, cmd, data, data_len)
            if success:
                self.response_display.setText("Write successful")
            else:
                self.response_display.setText("Write failed")
        except ValueError as e:
            self.response_display.setText(f"Invalid input: {str(e)}")

    def on_read_clicked(self):
        """Handle read button click."""
        try:
            addr = int(self.addr_input.text(), 16)
            cmd = int(self.cmd_input.text(), 16)
            data_len = [1, 2, 4][self.data_len_combo.currentIndex()]
            cmd_len = 1 if cmd <= 0xFF else 2

            value = self.i2c.nxp_read(addr, cmd, cmd_len, data_len)
            if value is not None:
                self.response_display.setText(f"0x{value:0{data_len*2}x}")
            else:
                self.response_display.setText("Read failed")
        except ValueError as e:
            self.response_display.setText(f"Invalid input: {str(e)}")

    def update_packet_log(self):
        """Update packet log display."""
        log_entries = self.serial.get_packet_log()
        # Only show last 50 entries
        display_entries = log_entries[-50:]
        self.packet_log.setPlainText('\n'.join(display_entries))
        # Scroll to bottom
        scrollbar = self.packet_log.verticalScrollBar()
        scrollbar.setValue(scrollbar.maximum())

    def on_clear_log(self):
        """Clear packet log."""
        self.serial.clear_packet_log()
        self.packet_log.clear()

    def on_export_log(self):
        """Export packet log to file."""
        log_entries = self.serial.get_packet_log()
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"laser_packet_log_{timestamp}.txt"

        try:
            with open(filename, 'w') as f:
                f.write('\n'.join(log_entries))
            QMessageBox.information(self, "Export Successful",
                                  f"Log exported to {filename}")
        except Exception as e:
            QMessageBox.warning(self, "Export Failed",
                              f"Failed to export log: {str(e)}")

# ============================================================================
# GUI - CONFIGURATION TAB
# ============================================================================

class ConfigTab(QWidget):
    """Serial port configuration."""

    connection_changed = pyqtSignal(bool)

    def __init__(self, serial_comm: SerialComm):
        super().__init__()
        self.serial = serial_comm
        self.init_ui()

        # Connect signals
        self.serial.connected.connect(self.on_connected)
        self.serial.disconnected.connect(self.on_disconnected)
        self.serial.error.connect(self.on_error)

    def init_ui(self):
        layout = QVBoxLayout()

        # Serial port
        port_group = QGroupBox("Serial Port")
        port_layout = QGridLayout()

        self.port_combo = QComboBox()
        self.port_combo.addItems(["/dev/ttyUSB1", "/dev/ttyUSB0", "/dev/ttyACM0"])
        self.port_combo.setEditable(True)

        self.baudrate_combo = QComboBox()
        self.baudrate_combo.addItems(["9600", "19200", "38400", "57600", "115200"])
        self.baudrate_combo.setCurrentText("9600")

        port_layout.addWidget(QLabel("Port:"), 0, 0)
        port_layout.addWidget(self.port_combo, 0, 1)
        port_layout.addWidget(QLabel("Baud Rate:"), 1, 0)
        port_layout.addWidget(self.baudrate_combo, 1, 1)
        port_layout.addWidget(QLabel("Data Bits:"), 2, 0)
        port_layout.addWidget(QLabel("8 (fixed)"), 2, 1)
        port_layout.addWidget(QLabel("Parity:"), 3, 0)
        port_layout.addWidget(QLabel("None (fixed)"), 3, 1)
        port_layout.addWidget(QLabel("Stop Bits:"), 4, 0)
        port_layout.addWidget(QLabel("1 (fixed)"), 4, 1)

        port_group.setLayout(port_layout)
        layout.addWidget(port_group)

        # Connection
        conn_group = QGroupBox("Connection")
        conn_layout = QVBoxLayout()

        self.connect_btn = QPushButton("Connect")
        self.connect_btn.clicked.connect(self.on_connect_clicked)
        conn_layout.addWidget(self.connect_btn)

        self.status_label = QLabel("Status: Disconnected")
        self.status_label.setStyleSheet("color: #ff0000;")
        conn_layout.addWidget(self.status_label)

        conn_group.setLayout(conn_layout)
        layout.addWidget(conn_group)

        # Debug options
        debug_group = QGroupBox("Debug Options")
        debug_layout = QGridLayout()

        self.timeout_input = QLineEdit("1000")
        self.retry_input = QLineEdit("3")

        debug_layout.addWidget(QLabel("Packet Timeout (ms):"), 0, 0)
        debug_layout.addWidget(self.timeout_input, 0, 1)
        debug_layout.addWidget(QLabel("Retry Count:"), 1, 0)
        debug_layout.addWidget(self.retry_input, 1, 1)

        debug_group.setLayout(debug_layout)
        layout.addWidget(debug_group)

        layout.addStretch()
        self.setLayout(layout)

    def on_connect_clicked(self):
        """Handle connect/disconnect button click."""
        if self.serial.is_connected:
            self.serial.disconnect()
        else:
            port = self.port_combo.currentText()
            baudrate = int(self.baudrate_combo.currentText())
            self.serial.connect(port, baudrate)

    def on_connected(self):
        """Handle connection established."""
        self.connect_btn.setText("Disconnect")
        self.status_label.setText("Status: Connected")
        self.status_label.setStyleSheet("color: #00ff00;")
        self.connection_changed.emit(True)

    def on_disconnected(self):
        """Handle disconnection."""
        self.connect_btn.setText("Connect")
        self.status_label.setText("Status: Disconnected")
        self.status_label.setStyleSheet("color: #ff0000;")
        self.connection_changed.emit(False)

    def on_error(self, message: str):
        """Handle serial error."""
        QMessageBox.warning(self, "Serial Error", message)

# ============================================================================
# MAIN WINDOW
# ============================================================================

class LaserControlApp(QMainWindow):
    """Main application window."""

    def __init__(self):
        super().__init__()

        # Initialize communication layers
        self.serial_comm = SerialComm()
        self.i2c_protocol = I2CProtocol(self.serial_comm)
        self.laser_control = LaserControl(self.i2c_protocol)

        self.init_ui()
        self.apply_stylesheet()

        # Connect signals
        self.serial_comm.disconnected.connect(self.on_disconnected)

    def init_ui(self):
        self.setWindowTitle("Genesis SLM MX 532 Laser Control")
        self.setGeometry(100, 100, 800, 600)

        # Create central widget
        central_widget = QWidget()
        self.setCentralWidget(central_widget)

        layout = QVBoxLayout()
        central_widget.setLayout(layout)

        # Create tabs
        self.tabs = QTabWidget()

        self.basic_tab = BasicControlTab(self.laser_control)
        self.monitoring_tab = MonitoringTab(self.laser_control)
        self.advanced_tab = AdvancedTab(self.i2c_protocol, self.serial_comm)
        self.config_tab = ConfigTab(self.serial_comm)

        self.tabs.addTab(self.basic_tab, "Basic Controls")
        self.tabs.addTab(self.monitoring_tab, "Monitoring")
        self.tabs.addTab(self.advanced_tab, "Advanced")
        self.tabs.addTab(self.config_tab, "Configuration")

        layout.addWidget(self.tabs)

        # Connect config tab signal
        self.config_tab.connection_changed.connect(self.on_connection_changed)

    def on_connection_changed(self, connected: bool):
        """Handle connection state change."""
        self.basic_tab.set_connection_status(connected)
        if not connected:
            self.on_disconnected()

    def on_disconnected(self):
        """Handle disconnection - set safe state."""
        self.laser_control.safe_state()
        self.basic_tab.reset_controls()

    def apply_stylesheet(self):
        """Apply QSS stylesheet."""
        stylesheet = """
        QMainWindow {
            background-color: #2b2b2b;
        }

        QWidget {
            background-color: #2b2b2b;
            color: white;
        }

        QPushButton {
            background-color: #3c3c3c;
            color: white;
            border: 1px solid #555;
            padding: 5px;
            border-radius: 3px;
        }

        QPushButton:hover {
            background-color: #4c4c4c;
        }

        QPushButton:pressed {
            background-color: #2c2c2c;
        }

        QPushButton#emergency {
            background-color: #cc0000;
            font-weight: bold;
            font-size: 14pt;
            min-height: 50px;
        }

        QPushButton#emergency:hover {
            background-color: #ff0000;
        }

        QGroupBox {
            border: 1px solid #555;
            border-radius: 5px;
            margin-top: 10px;
            padding-top: 10px;
        }

        QGroupBox::title {
            subcontrol-origin: margin;
            left: 10px;
            padding: 0 5px;
        }

        QSlider::groove:horizontal {
            background: #3c3c3c;
            height: 8px;
            border-radius: 4px;
        }

        QSlider::handle:horizontal {
            background: #5c5c5c;
            width: 16px;
            margin: -4px 0;
            border-radius: 8px;
        }

        QSlider::handle:horizontal:hover {
            background: #6c6c6c;
        }

        QSpinBox, QLineEdit, QComboBox {
            background-color: #3c3c3c;
            border: 1px solid #555;
            padding: 3px;
            border-radius: 3px;
        }

        QTextEdit {
            background-color: #1c1c1c;
            border: 1px solid #555;
            border-radius: 3px;
        }

        QTabWidget::pane {
            border: 1px solid #555;
        }

        QTabBar::tab {
            background-color: #3c3c3c;
            border: 1px solid #555;
            padding: 8px 16px;
            margin-right: 2px;
        }

        QTabBar::tab:selected {
            background-color: #4c4c4c;
        }

        QTabBar::tab:hover {
            background-color: #5c5c5c;
        }
        """
        self.setStyleSheet(stylesheet)

    def closeEvent(self, event):
        """Handle window close event."""
        # Set safe state before closing
        if self.serial_comm.is_connected:
            self.laser_control.safe_state()
            self.serial_comm.disconnect()
        event.accept()

# ============================================================================
# MAIN
# ============================================================================

def main():
    app = QApplication(sys.argv)
    window = LaserControlApp()
    window.show()
    sys.exit(app.exec())

if __name__ == '__main__':
    main()