# plugin_prelaunch.py - With connection check
from switchboard.devices.device_base import Device, DeviceStatus
from switchboard.devices.device_widget_base import DeviceWidget
from switchboard.switchboard_logging import LOGGER
from switchboard.config import IntSetting, StringSetting

from PySide6 import QtCore


class DevicePreLaunch(Device):
    """PreLaunch device - executes batch file on connect"""
    
    csettings = {
        'batch_file': StringSetting(
            attr_name="batch_file",
            nice_name="Batch File Path",
            value="D:\\Projects\\DEV_TheStudio_Plugin\\Source\\git_management.bat",
            tool_tip="Full path to the batch file on the remote machine",
            category="PreLaunch Settings",
        ),
        'port': IntSetting(
            attr_name="port",
            nice_name="Listener Port",
            value=2980,
            tool_tip="Port of SwitchboardListener",
            category="Network Settings",
        ),
    }
    
    def __init__(self, name, address, **kwargs):
        super().__init__(name, address, **kwargs)
        LOGGER.info(f"PreLaunch device '{name}' created")
    
    def device_settings(self):
        return super().device_settings()
    
    def connect(self):
        """Called when connect button clicked"""
        LOGGER.info(f">>> {self.name}: connect() called!")
        
        # First, check if listener is reachable
        LOGGER.info(f">>> {self.name}: Checking listener connection...")
        
        # Try a simple connectivity test
        try:
            # Send a simple test message
            test_message = {'command': 'state'}
            success, response = self.unreal_client.send_message(test_message)
            
            if not success:
                LOGGER.error(f">>> {self.name}: Cannot connect to listener!")
                self.device_qt_handler.signal_device_connect_failed.emit(self)
                return
            
            LOGGER.info(f">>> {self.name}: Listener responded: {response}")
            
        except Exception as e:
            LOGGER.error(f">>> {self.name}: Connection test failed: {e}")
            self.device_qt_handler.signal_device_connect_failed.emit(self)
            return
        
        # Set status to READY
        self.status = DeviceStatus.READY
        LOGGER.info(f">>> {self.name}: Status set to READY, executing batch file...")
        
        # Execute batch file
        self.execute_batch_file()
    
    def disconnect(self):
        """Called when disconnect button clicked"""
        LOGGER.info(f">>> {self.name}: disconnect() called!")
        self.status = DeviceStatus.DISCONNECTED
    
    def execute_batch_file(self):
        """Execute the batch file"""
        batch_file = self.batch_file.get_value()
        
        if not batch_file:
            LOGGER.warning(f"  {self.name}: No batch file configured")
            return False
        
        LOGGER.info(f">>> {self.name}: ========== EXECUTING ==========")
        LOGGER.info(f">>> {self.name}: File: {batch_file}")
        LOGGER.info(f">>> {self.name}: Address: {self.address}")
        LOGGER.info(f">>> {self.name}: Port: {self.port.get_value()}")
        
        try:
            message = {
                'command': 'start',
                'bTryKill': False,
                'bUpdateWorkingDir': False,
                'caller': self.name,
                'name': 'cmd.exe',
                'args': f'/c "{batch_file}"',
                'working_dir': '',
            }
            
            LOGGER.info(f">>> {self.name}: Sending message...")
            success, msg = self.unreal_client.send_message(message)
            
            if success:
                LOGGER.info(f">>>  {self.name}: SUCCESS!")
                LOGGER.info(f">>> Response: {msg}")
                return True
            else:
                LOGGER.error(f">>> L {self.name}: Send failed!")
                return False
            
        except Exception as e:
            LOGGER.error(f">>> L {self.name}: ERROR: {e}")
            import traceback
            LOGGER.error(traceback.format_exc())
            return False


class DeviceWidgetPreLaunch(DeviceWidget):
    """Widget for PreLaunch device"""
    
    def __init__(self, name, device_hash, address, icons, parent=None):
        super().__init__(name, device_hash, address, icons, parent=parent)
        LOGGER.info(f"PreLaunch widget created for {name}")
    
    def _add_control_buttons(self):
        """Add connect button"""
        super()._add_control_buttons()
        
        CONTROL_BUTTON_ICON_SIZE = QtCore.QSize(21, 21)
        
        self.connect_button = self.add_control_button(
            icon_size=CONTROL_BUTTON_ICON_SIZE,
            checkable=True,
            tool_tip='Connect and execute batch file',
            hover_focus=False,
            name='connect')
        
        self.connect_button.clicked.connect(self.connect_button_clicked)
    
    def connect_button_clicked(self):
        """Handle connect button click"""
        if self.connect_button.isChecked():
            self._connect()
        else:
            self._disconnect()
    
    def _connect(self):
        """Connect"""
        self.connect_button.setChecked(True)
        self.signal_device_widget_connect.emit(self)
    
    def _disconnect(self):
        """Disconnect"""
        self.connect_button.setChecked(False)
        self.signal_device_widget_disconnect.emit(self)