drone_launcher.py

#!/usr/bin/env python3
"""
DELSYS - UNIMORE DRONE LAUNCHER & HUD INTEGRATED (UNIFIED WITH EMBEDDED GODOT) 
"""

import sys, os, subprocess, threading, time, json, signal, socket as _socket

from pyparsing import line

from PyQt5.QtWidgets import (
    QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout,
    QPushButton, QLabel, QProgressBar, QFrame, QGridLayout, QMessageBox, QSizePolicy
)
from PyQt5.QtCore import Qt, QTimer, pyqtSignal, QPoint, QProcess
from PyQt5.QtGui import QPainter, QPolygon, QColor, QWindow, QGuiApplication, QFont, QPixmap

import rclpy
from rclpy.node import Node
from std_msgs.msg import Int32, Bool, String
from geometry_msgs.msg import Twist
from std_msgs.msg import Float32MultiArray
from rclpy.qos import QoSProfile, DurabilityPolicy, HistoryPolicy, ReliabilityPolicy
import re

# ─────────────────────────────────────────────
# PORTS, PATHS AND IMAGES CONFIG
# ─────────────────────────────────────────────
HOME          = os.path.expanduser("~")
DELSYS_DIR    = os.path.join(HOME, "delsys-unimore")
ROS_WS        = os.path.join(DELSYS_DIR, "ros2_ws")
BRIDGE_DIR    = os.path.join(DELSYS_DIR, "delsys_bridge")
ROS_SETUP     = "/opt/ros/humble/setup.bash"
WS_SETUP      = os.path.join(ROS_WS, "install/setup.bash")

GODOT_BIN     = os.path.join(BRIDGE_DIR, "Godot_v4.3-stable_linux.x86_64")
GODOT_PROJECT_DIR = os.path.join(DELSYS_DIR, "drone-game")

LOGO_EMG_PATH = "delsys_symbol.png"
LOGO_ARS_PATH = "arscontrol_symbol.png"

BOTTOM_LOGO_DELSYS = "DELSYS.png"
BOTTOM_LOGO_ARS    = "arscontrol.jpeg"

# Configuration constants for calibration sequences (seconds)
CALIB_DURATION_IMU = 3.0
CALIB_DURATION_EMG = 3.0

# TCP Loopback Ports assigned for programmatic process adjustments outside ROS2
IMU_PORT  = 9001
EMG_PORT  = 9002
CTRL_PORT = 9003
BRIDGE_CMD_PORT = 9004

DEAD_THRESH    = 0.2
BOOST_THRESH   = 0.7

BG             = "#0a0f1e"
PANEL_BG       = "#111827"
ACCENT         = "#00d4ff"
GREEN          = "#00ff88"
ORANGE         = "#ff8c00"
RED_C          = "#ff3355"
WHITE          = "#f0f4ff"
GREY           = "#3a4560"
ARROW_OFF      = "#1a2540"
ARROW_ON       = "#00d4ff"

def get_stylesheet(scale=1.0):
    """
    Generates a QSS (Qt Style Sheet) string dynamically modified by a scale coefficient.
    Ensures that borders, padding, and layout geometries stay perfectly crisp on responsive screens.
    """
    f_base = lambda size: max(8, int(size * scale))
    return f"""
    * {{ font-family: 'Courier New', monospace; }}
    QMainWindow, QWidget#root {{ background: {BG}; }}
    QWidget {{ background: {BG}; color: {WHITE}; }}
    QFrame#card {{ background: {PANEL_BG}; border: 1px solid {GREY}; border-radius: {max(4, int(8*scale))}px; }}
    QPushButton {{
        background: {PANEL_BG}; color: {ACCENT}; border: 1px solid {ACCENT}; border-radius: {max(3, int(5*scale))}px;
        padding: {int(10*scale)}px {int(14*scale)}px; font-size: {f_base(11)}px; font-weight: bold; letter-spacing: 1px; min-height: {int(36*scale)}px;
    }}
    QPushButton:hover  {{ background: {ACCENT}; color: {BG}; }}
    QPushButton:disabled {{ color: {GREY}; border-color: {GREY}; background: {PANEL_BG}; }}
    QPushButton#red    {{ border-color: {RED_C};    color: {RED_C};    }}
    QPushButton#red:hover    {{ background: {RED_C};    color: {WHITE}; }}
    QPushButton#green  {{ border-color: {GREEN};  color: {GREEN};  }}
    QPushButton#green:hover  {{ background: {GREEN};  color: {BG};    }}
    QPushButton#orange {{ border-color: {ORANGE}; color: {ORANGE}; }}
    QPushButton#orange:hover {{ background: {ORANGE}; color: {BG};   }}
    QProgressBar {{ background: {GREY}; border: none; border-radius: 3px; height: {int(6*scale)}px; }}
    QProgressBar::chunk {{ background: {ACCENT}; border-radius: 3px; }}
    QLabel {{ background: transparent; border: none; }}
    """

def sep():
    """Returns a visual divider line widget (horizontal line frame)."""
    f = QFrame()
    f.setFrameShape(QFrame.HLine)
    f.setStyleSheet(f"background: {GREY}; max-height: 1px; border: none;")
    return f

def lbl(text, color=WHITE, size=10, bold=False, spacing=0):
    """Factory helper to construct highly uniform and trackable UI text blocks."""
    l = QLabel(text)
    l.setProperty("base_size", size) 
    w = "bold" if bold else "normal"
    ls = f"letter-spacing: {spacing}px;" if spacing else ""
    l.setStyleSheet(f"color: {color}; font-size: {size}px; font-weight: {w}; {ls}")
    return l

def card():
    """Constructs a standard modular panel container for the multi-column interface."""
    f = QFrame()
    f.setObjectName("card")
    f.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
    return f

def send_ctrl(payload: dict, port=CTRL_PORT) -> bool:
    """
    Fires off JSON payloads over raw TCP sockets on a separate, decoupled thread.
    Used to send calibration commands or runtime instructions straight to hardware bridges 
    without running the risk of stalling the master GUI loop.
    """
    def _worker():
        try:
            s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
            s.settimeout(0.5)
            s.connect(('127.0.0.1', port))
            s.sendall((json.dumps(payload) + '\n').encode('utf-8'))
            s.close()
        except Exception:
            pass
    threading.Thread(target=_worker, daemon=True).start()
    return True

# ─────────────────────────────────────────────
# RESPONSIVE GRAPHICAL COMPONENTS
# ─────────────────────────────────────────────
class StatusDot(QWidget):
    """
    A custom status indicator widget displaying a colored dot and text.
    Flashes red automatically when handling critical, pending initialization tasks.
    """
    def __init__(self, text: str):
        super().__init__()
        lay = QHBoxLayout(self); lay.setContentsMargins(0,0,0,0); lay.setSpacing(6)
        self._dot = QLabel("⬤"); self._dot.setProperty("base_size", 10)
        self._lbl = QLabel(text); self._lbl.setProperty("base_size", 10)
        self._dot.setStyleSheet(f"color: {GREY}; font-size: 10px;")
        self._lbl.setStyleSheet(f"color: {GREY}; font-size: 10px;")
        lay.addWidget(self._dot); lay.addWidget(self._lbl); lay.addStretch()
        self._blink_timer = None; self._blink_state = False
        self._current_state = 'off'

    def set_state(self, state: str, text: str = None):
        """Sets current execution state ('off', 'pending', 'ok', 'error') and styles text."""
        self._current_state = state
        if self._blink_timer: self._blink_timer.stop(); self._blink_timer = None
        c = {'off': GREY, 'pending': ORANGE, 'ok': ACCENT, 'error': RED_C}.get(state, GREY)
        if text: self._lbl.setText(text)
        
        sz = self._lbl.property("current_size") or 10
        self._lbl.setStyleSheet(f"color: {c}; font-size: {sz}px;")
        self._dot.setStyleSheet(f"color: {c}; font-size: {sz}px;")
        
        if state == 'pending':
            self._blink_timer = QTimer()
            self._blink_timer.timeout.connect(self._blink)
            self._blink_timer.start(500)

    def _blink(self):
        """Flips dot color to simulate an active alert warning during configuration."""
        self._blink_state = not self._blink_state
        sz = self._dot.property("current_size") or 10
        self._dot.setStyleSheet(f"color: {RED_C if self._blink_state else GREY}; font-size: {sz}px;")

    def update_scale(self, scale):
        """Rescales the text and dot icons upon window dimension mutations."""
        sz = max(6, int(10 * scale))
        self._dot.setProperty("current_size", sz)
        self._lbl.setProperty("current_size", sz)
        self.set_state(self._current_state)

class CalibBar(QWidget):
    """
    A tracking progress bar specifically mapped out to handle visual timing countdowns
    during human biometric sensor normalization sequences.
    """
    finished = pyqtSignal()
    def __init__(self, color=ORANGE, duration=3.0):
        super().__init__()
        self.color = color
        self.duration = duration; self._timer = None
        lay = QVBoxLayout(self); lay.setContentsMargins(0, 4, 0, 4); lay.setSpacing(4)
        self._lbl = QLabel(""); self._lbl.setProperty("base_size", 9)
        self._lbl.setStyleSheet(f"color: {GREY}; font-size: 9px;")
        lay.addWidget(self._lbl)
        self._bar = QProgressBar(); self._bar.setRange(0, int(duration * 10)); self._bar.setValue(0)
        self._bar.setTextVisible(False); self._bar.setFixedHeight(8)
        self._bar.setStyleSheet(f"QProgressBar {{ background: {GREY}; border: none; border-radius: 3px; }}"
                                f"QProgressBar::chunk {{ background: {ACCENT}; border-radius: 3px; }}")
        lay.addWidget(self._bar); self.setVisible(False)

    def start(self, message: str):
        """Initializes countdown increments mapping physical time directly into value steps."""
        self.setVisible(True); self._bar.setValue(0)
        sz = self._lbl.property("current_size") or 9
        self._lbl.setStyleSheet(f"color: {ACCENT}; font-size: {sz}px;")
        self._counter = [0]; total = int(self.duration * 10)

        def tick():
            self._counter[0] += 1; self._bar.setValue(self._counter[0])
            rem = self.duration - self._counter[0] / 10
            self._lbl.setText(f"{message}  {rem:.1f}s")
            if self._counter[0] >= total:
                self._timer.stop()
                cur_sz = self._lbl.property("current_size") or 9
                self._lbl.setText("✓  Complete")
                self._lbl.setStyleSheet(f"color: {ACCENT}; font-size: {cur_sz}px;")
                self.finished.emit()

        self._timer = QTimer(); self._timer.timeout.connect(tick); self._timer.start(100)

    def reset(self):
        if self._timer: self._timer.stop()
        self._bar.setValue(0); self._lbl.setText(""); self.setVisible(False)

    def update_scale(self, scale):
        self._bar.setFixedHeight(max(4, int(8 * scale)))
        sz = max(7, int(9 * scale))
        self._lbl.setProperty("current_size", sz)

class EMGNativeCanvas(QWidget):
    """
    An optimized, self-painting canvas panel that draws a real-time signal bar
    representing normalized muscle input power, complete with visual threshold zones.
    """
    def __init__(self):
        super().__init__()
        self.setFixedSize(330, 36)
        self.value = 0.0
        self.calibrated = False

    def update_value(self, val, calibrated):
        self.value = val
        self.calibrated = calibrated
        self.update() # Triggers paintEvent internally on the next layout cycle

    def paintEvent(self, event):
        p = QPainter(self); p.setRenderHint(QPainter.Antialiasing)
        p.fillRect(self.rect(), QColor(PANEL_BG))

        w_val = self.value
        # Select colors dynamically based on structural zone thresholds
        if not self.calibrated:
            bar_color = QColor(GREY)
        elif w_val < DEAD_THRESH:
            bar_color = QColor(GREY)
        elif w_val < BOOST_THRESH:
            bar_color = QColor(GREEN)
        else:
            bar_color = QColor(RED_C)
        
        # Calculate width dynamically based on raw signal activity
        fill_width = max(2, int((self.width() - 4) * w_val))
        p.fillRect(2, 2, fill_width, self.height() - 4, bar_color)
        # Paint Dead Zone marker threshold line
        p.setPen(QColor(ORANGE))
        dead_x = int(self.width() * DEAD_THRESH)
        p.drawLine(dead_x, 0, dead_x, self.height())
        # Paint Boost Zone marker threshold line
        p.setPen(QColor(RED_C))
        boost_x = int(self.width() * BOOST_THRESH)
        p.drawLine(boost_x, 0, boost_x, self.height())
        
class IMUVisualizer(QWidget):
    """
    A 2D navigation crosshair component that changes color states to visually reflect 
    drone navigation directions extracted from spatial IMU sensors (Pitch & Roll angles).
    """
    def __init__(self):
        super().__init__()
        self.setFixedSize(360, 180) 
        self.pitch = 0.0; self.roll = 0.0; self.th = 0.1 # Activation tilt deadband boundary

    def update_angles(self, pitch, roll):
        self.pitch = pitch; self.roll = roll; self.update()

    def paintEvent(self, event):
        p = QPainter(self); p.setRenderHint(QPainter.Antialiasing)
        p.fillRect(self.rect(), QColor(PANEL_BG))

        w, h = self.width(), self.height()
        cx, cy = w // 2, h // 2

        # Evaluate target illumination states checking orientation angles against constraints
        up_c    = QColor(ARROW_ON) if self.pitch < -self.th else QColor(ARROW_OFF)
        down_c  = QColor(ARROW_ON) if self.pitch > self.th else QColor(ARROW_OFF)
        right_c = QColor(ARROW_ON) if self.roll > self.th else QColor(ARROW_OFF)
        left_c  = QColor(ARROW_ON) if self.roll < -self.th else QColor(ARROW_OFF)
        
        p.setPen(Qt.NoPen)
        
        # UP Arrow
        p.setBrush(up_c)
        p.drawPolygon(QPolygon([QPoint(cx - 20, cy + 50 + 35), QPoint(cx - 30 - 20, cy + 50), QPoint(cx + 30 - 20, cy + 50)]))
        # DOWN Arrow
        p.setBrush(down_c)
        p.drawPolygon(QPolygon([QPoint(cx - 20, cy - 50 - 35), QPoint(cx - 30 - 20, cy - 50), QPoint(cx + 30 - 20, cy - 50)]))
        # LEFT Arrow
        p.setBrush(left_c)
        p.drawPolygon(QPolygon([QPoint(cx - 50 - 20 - 35, cy), QPoint(cx - 50 - 20, cy + 30), QPoint(cx - 50 - 20, cy - 30)]))
        # RIGHT Arrow
        p.setBrush(right_c)
        p.drawPolygon(QPolygon([QPoint(cx + 50 - 20 + 35, cy), QPoint(cx + 50 - 20, cy + 30), QPoint(cx + 50 - 20, cy - 30)]))

# ─────────────────────────────────────────────
# ROS2 INTEGRATED NODE
# ─────────────────────────────────────────────
class ROS2HUDListener(Node):
    """
    Subclass of a native ROS2 node execution instance. Handles asynchronous topic discovery,
    unmarshals multi-sensor frames, and maps data streams directly into GUI telemetry channels.
    """
    def __init__(self, win_handle):
        super().__init__('launcher_hud_listener')
        self.win = win_handle
        self._subs = {}
        self._sub_lock = threading.Lock()

        # Relaxed Quality of Service profile configuration tuned to capture lossy, fast telemetry data feeds
        qos_sensor = QoSProfile(
            history=HistoryPolicy.KEEP_LAST,
            depth=10,
            reliability=ReliabilityPolicy.BEST_EFFORT
        )

        # Standard subscription definitions mapping directly to HUD updating operations
        self.create_subscription(Int32, '/score', self._score_cb, 10)
        self.create_subscription(Twist, '/drone/cmd_vel', self._cmd_vel_cb, 10)
        self.create_subscription(Float32MultiArray, '/drone/orientation', self._orient_cb, qos_sensor)
        self.create_subscription(String, '/emg_calibration_status', self._emg_calib_status_cb, 10)

        # Master publisher interfaces intended to inject control flow back inside the simulation environment
        self.game_over_pub = self.create_publisher(Bool, '/game_over', 10)
        self.game_reset_pub = self.create_publisher(Bool, '/game_reset', 10)

        # Periodic scanning task to safely lock on to variable, dynamic hardware muscle sensor data topics
        self.discovery_timer = self.create_timer(1.0, self._discover_emg_topic_safely)

    def _discover_emg_topic_safely(self):
        """
        Dynamically probes the running ROS graph for active EMG topic configurations, 
        safely attaching custom interface subscribers when a match emerges.
        """
        with self._sub_lock:
            if self._subs:
                return # Skip discovery if an active muscle stream hook has already been bound
            all_topics = self.get_topic_names_and_types()
            for topic_name, topic_types in all_topics:
                if 'emg' not in topic_name.lower(): continue
                if 'calibration' in topic_name or 'status' in topic_name: continue
                type_str = topic_types[0] if topic_types else ''

                # Check for standard data wrapper array objects
                if type_str == 'std_msgs/msg/Float32':
                    from std_msgs.msg import Float32
                    self._subs[topic_name] = self.create_subscription(
                        Float32, topic_name, 
                        lambda msg: self.win.sig_emg_raw.emit(max(0.0, min(1.0, float(msg.data)))), 10
                    )
                    self.discovery_timer.cancel()
                    break

                # Support interface structural specifications for custom messages
                if 'DelsysSensorData' in type_str or 'delsys_interfaces' in type_str:
                    try:
                        from delsys_interfaces.msg import DelsysSensorData
                        self._subs[topic_name] = self.create_subscription(DelsysSensorData, topic_name, self._emg_native_msg_cb, 200)
                        self.discovery_timer.cancel()
                        break
                    except ImportError: continue

    def _emg_native_msg_cb(self, msg):
        try:
            self.win.sig_emg_raw.emit(max(0.0, min(1.0, float(msg.data_value))))
        except Exception: pass

    def _emg_calib_status_cb(self, msg):
        keywords = ["calibrated", "MVC", "Completed", "saved", "CALIB"]
        if any(k in msg.data for k in keywords): self.win.sig_emg.emit(999.0)

    def _score_cb(self, msg): 
        self.win.sig_score.emit(msg.data)

    def _cmd_vel_cb(self, msg): 
        self.win.sig_twist.emit(msg.linear.x, msg.linear.y, msg.linear.z)

    def _orient_cb(self, msg):
        if len(msg.data) >= 2: self.win.sig_imu.emit(msg.data[0], msg.data[1])

    def publish_game_over(self):
        m = Bool(); m.data = True; self.game_over_pub.publish(m)

    def publish_game_reset(self):
        m = Bool(); m.data = True; self.game_reset_pub.publish(m)

# ─────────────────────────────────────────────
# PROCESS MANAGER
# ─────────────────────────────────────────────
print_lock = threading.Lock()

class ProcessManager:
    """
    Subprocess execution architecture that coordinates sourcing ROS environments, 
    spinning up nodes, trapping stdout diagnostic logs, and performing group termination.
    """
    def __init__(self, ready_cb=None):
        self.procs = {}
        self.ready_cb = ready_cb
        self._ros_env = None

    def _get_ros_env(self):
        """
        Dynamically spins up a quick shell task to source ROS2 environment parameters,
        exporting standard dependency environment tables straight into localized dictionary keys.
        """
        if self._ros_env is None:
            env = os.environ.copy()
            try:
                cmd = f"bash -c 'source {ROS_SETUP} && source {WS_SETUP} && env'"
                out = subprocess.check_output(cmd, shell=True, text=True, timeout=5)
                for line in out.splitlines():
                    if '=' in line:
                        k, _, v = line.partition('=')
                        env[k] = v
                self._ros_env = env
            except Exception: pass
        return self._ros_env if self._ros_env else os.environ.copy()

    def start(self, name: str, cmd: str, sudo=False, ready_trigger=None) -> subprocess.Popen:
        """
        Spins up non-blocking child background shell commands. Employs stream scraping 
        threads to trigger ready signals whenever specific log signatures are matched.
        """
        full = f"sudo -E bash -c '{cmd}'" if sudo else f"bash -c '{cmd}'"
        env = self._get_ros_env()
        
        env["TERM"] = "dumb"  
        env["PYTHONUNBUFFERED"] = "1"

        if name == "godot":
            env["QT_QPA_PLATFORM"] = "xcb"
            env["DISPLAY"] = os.environ.get("DISPLAY", ":0")

        proc = subprocess.Popen(full, shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True, universal_newlines=True, bufsize=0, errors='ignore', env=env)
        self.procs[name] = proc
        
        def _read():
            ansi_escape = re.compile(r'\x1B[@-_][0-?]*[ -/]*[@-~]')
            for raw_line in iter(proc.stdout.readline, ''):
                # Rimuove ANSI escape codes
                raw_line = ansi_escape.sub('', raw_line)
                # Splitta su \r e prende l'ultimo pezzo non vuoto
                parts = [p.strip() for p in raw_line.split('\r') if p.strip()]
                if not parts:
                    continue
                line = parts[-1]
                if line:
                    prefisso = f"[{name}]"
                    with print_lock:
                        print(f"{prefisso:<15} {line}", flush=True)
                    # Unblock launcher state machines if target keyword matches console log output
                    if ready_trigger and ready_trigger in line:
                        if self.ready_cb:
                            self.ready_cb(name)
                
        threading.Thread(target=_read, daemon=True).start()
        return proc

    def stop_all(self):
        """Forces hard cleanups across child task trees using kernel SIGKILL calls."""
        for name, proc in list(self.procs.items()):
            try:
                os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
                proc.wait(timeout=0.2)
            except Exception:
                try: proc.kill()
                except Exception: pass
        self.procs.clear()
        # Hard terminate loose background scripts or stray engine windows running on known ports
        try:
            subprocess.call("pkill -9 -f emg_processing_node 2>/dev/null", shell=True)
            subprocess.call("pkill -9 -f imu_processing_node 2>/dev/null", shell=True)
            subprocess.call("pkill -9 -f drone_controller_node 2>/dev/null", shell=True)
            subprocess.call("pkill -9 -f rosbridge_websocket 2>/dev/null", shell=True)
            subprocess.call("sudo pkill -9 -f delsys_connector_socket_ros.py 2>/dev/null", shell=True)
            subprocess.call("pkill -9 -f Godot_v4.3 2>/dev/null", shell=True)
        except Exception: pass
        time.sleep(0.2)

# ─────────────────────────────────────────────
# MAIN WINDOW
# ─────────────────────────────────────────────
class MainWindow(QMainWindow): 
    # Thread-safe signal slots designed to route back into main GUI update routines
    sig_step = pyqtSignal(int, str, str, str, str)
    sig_emg = pyqtSignal(float)
    sig_emg_raw = pyqtSignal(float)
    sig_imu = pyqtSignal(float, float)
    sig_score = pyqtSignal(int)
    sig_twist = pyqtSignal(float, float, float)
    sig_embed_godot = pyqtSignal(int)
    sig_ready = pyqtSignal()

    def __init__(self):
        os.environ["QT_QPA_PLATFORM"] = "xcb" # Assures stable Linux display coordination
        super().__init__()
        self.setWindowTitle("DELSYS SENSOR IN ROS2 FRAMEWORK BY UNIMORE - DRONE CONTROL DEMO")
        self.setMinimumSize(1340, 760) 
        
        # Runtime internal tracking metrics
        self._recording = False
        self._system_ready = False
        self._imu_done = False
        self._emg_done = False
        self._emg_calibrated = False
        self._emg_value = 0.0
        self._current_score = 0
        self._game_start_time = None
        self._step_event = threading.Event()
        self._godot_process = None

        self._pm = ProcessManager(ready_cb=self._on_process_ready)

        self.setStyleSheet(get_stylesheet(1.0))
        self._build_ui() 

        # Establish thread-safe internal signal connections
        self.sig_step.connect(self._handle_step_update)
        self.sig_emg.connect(self._update_emg_hud)
        self.sig_emg_raw.connect(self._update_emg_raw_hud)
        self.sig_imu.connect(self._update_imu_hud)
        self.sig_score.connect(self._update_score_hud)
        self.sig_twist.connect(self._update_twist_hud)
        self.sig_ready.connect(self._on_system_ready)
        
        # Setup real-time system clock heartbeat for tracking match session lengths
        self._gui_timer = QTimer()
        self._gui_timer.timeout.connect(self._gui_tick)
        self._gui_timer.start(50)

        # Setup structural window-docking loops to snap the external game process into place
        self._godot_wid = None
        self._dock_timer = QTimer()
        self._dock_timer.timeout.connect(self._sync_godot_window)
        self._dock_timer.start(30)
        self._last_geom = None

        # Asynchronously spin up the background ROS2 worker thread
        threading.Thread(target=self._ros2_spin_worker, daemon=True).start()

    def _ros2_spin_worker(self):
        rclpy.init()
        self._ros_listener = ROS2HUDListener(self)
        try: rclpy.spin(self._ros_listener)
        except Exception: pass

    def _on_process_ready(self, name: str): 
        self._step_event.set()

    def _find_godot_window(self):
        """Queries the Linux X11 display manager via wmctrl to track the native Godot window ID."""
        try:
            out = subprocess.check_output("wmctrl -l", shell=True).decode()
            for line in out.splitlines():
                if "drone-game" in line.lower(): return line.split()[0]
        except: pass
        return None

    def _move_resize_godot(self):
        """
        Tracks the global layout position coordinates of the master host widget, 
        forcing the X11 system engine to move the standalone Godot app directly into those bounds.
        """
        if not self._godot_wid: return
        top_left = self.godot_host.mapToGlobal(self.godot_host.rect().topLeft())
        x, y = top_left.x(), top_left.y()
        w, h = self.godot_host.width(), self.godot_host.height()
        geom = (x, y, w, h)
        if geom == self._last_geom: return
        self._last_geom = geom
        # Issue system control command resizing the external canvas window frame
        subprocess.call(f"wmctrl -i -r {self._godot_wid} -e 0,{x},{y},{w},{h}", shell=True, stderr=subprocess.DEVNULL)

    def _raise_godot(self):
        """Brings the Godot simulation app directly to the top layer of the display stacking order."""
        if self._godot_wid:
            subprocess.call(f"wmctrl -i -r {self._godot_wid} -b add,above", shell=True, stderr=subprocess.DEVNULL)
            subprocess.call(f"xdotool windowraise {self._godot_wid}", shell=True, stderr=subprocess.DEVNULL)
            
    def _build_ui(self):
        """Assembles structural panels, asset nodes, and buttons into the dashboard UI layout."""
        root = QWidget(); root.setObjectName("root"); self.setCentralWidget(root)
        base_layout = QHBoxLayout(root); base_layout.setContentsMargins(12, 12, 12, 12); base_layout.setSpacing(12)
        left_side_layout = QVBoxLayout(); left_side_layout.setSpacing(12)
        
        # Build Upper Brand Banner Panel Section
        self.f_header_extended = card()
        self.f_header_extended.setFixedSize(340 + 360 + 12, 75) 
        l_hdr = QHBoxLayout(self.f_header_extended); l_hdr.setContentsMargins(16, 8, 16, 8)
        
        self.lbl_logo_emg = QLabel()
        if os.path.exists(LOGO_EMG_PATH):
            pix_emg = QPixmap(LOGO_EMG_PATH).scaled(42, 42, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            self.lbl_logo_emg.setPixmap(pix_emg)
        l_hdr.addWidget(self.lbl_logo_emg)
        l_hdr.addSpacing(12)
        
        v_txt = QVBoxLayout()
        self.lbl_brand1 = lbl("DELSYS SENSORS - ROS2 FRAMEWORK UNIMORE", ACCENT, 14, bold=True, spacing=1)
        self.lbl_brand1.setAlignment(Qt.AlignCenter)
        v_txt.addWidget(self.lbl_brand1)
        l_hdr.addLayout(v_txt)
        l_hdr.addSpacing(12)
        
        self.lbl_logo_ars = QLabel()
        if os.path.exists(LOGO_ARS_PATH):
            pix_ars = QPixmap(LOGO_ARS_PATH).scaled(80, 42, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            self.lbl_logo_ars.setPixmap(pix_ars)
        l_hdr.addWidget(self.lbl_logo_ars)
        
        left_side_layout.addWidget(self.f_header_extended)
        
        # Combine Left Parameter Panels and HUD Side-by-Side
        cols_sub_layout = QHBoxLayout(); cols_sub_layout.setSpacing(12)
        self.col_left = self._build_col_left()
        self.col_center = self._build_col_center()
        
        self.col_left.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
        self.col_left.setFixedWidth(340)
        self.col_center.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
        self.col_center.setFixedWidth(340)

        cols_sub_layout.addWidget(self.col_left)
        cols_sub_layout.addWidget(self.col_center)
        left_side_layout.addLayout(cols_sub_layout)
        
        # Build Right Side Area dedicated to housing the Godot simulation engine view
        self.right_side_container = QWidget()
        v_right = QVBoxLayout(self.right_side_container); v_right.setContentsMargins(0, 0, 0, 0); v_right.setSpacing(12)
        
        # The targeted bounding viewport container where the Godot window frame snaps into place
        self.godot_host = QWidget()
        self.godot_host.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        v_right.addWidget(self.godot_host, stretch=4)
        
        self.f_bottom_logos = card()
        self.f_bottom_logos.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
        l_bottom_imgs = QHBoxLayout(self.f_bottom_logos); l_bottom_imgs.setContentsMargins(12, 8, 12, 8); l_bottom_imgs.setSpacing(20)
        
        self.lbl_bottom_delsys = QLabel()
        self.lbl_bottom_delsys.setAlignment(Qt.AlignCenter)
        self.lbl_bottom_ars = QLabel()
        self.lbl_bottom_ars.setAlignment(Qt.AlignCenter)
        
        l_bottom_imgs.addWidget(self.lbl_bottom_delsys, stretch=1)
        l_bottom_imgs.addWidget(self.lbl_bottom_ars, stretch=1)
        v_right.addWidget(self.f_bottom_logos, stretch=1) 
        
        base_layout.addLayout(left_side_layout, stretch=0)
        base_layout.addWidget(self.right_side_container, stretch=1)

    def _build_col_left(self):
        """Assembles the deployment sequencer tracking column, calibration handles, and primary buttons."""
        w = QWidget()
        lay = QVBoxLayout(w); lay.setContentsMargins(0,0,0,0); lay.setSpacing(10)

        self.f_sys = card(); l_sys = QVBoxLayout(self.f_sys); l_sys.setSpacing(6)
        self.lbl_title_sys = lbl("SERVICES SYSTEM", ACCENT, 12, spacing=2, bold=True)
        l_sys.addWidget(self.lbl_title_sys); l_sys.addWidget(sep())
        
        self._dots = {}
        services = [("build", "colcon build"), ("rosbridge", "rosbridge server"),
                    ("emg", "emg_processing_node"), ("imu", "imu_processing_node"),
                    ("controller", "drone_controller"), ("bridge", "delsys_bridge (sudo)"),
                    ("godot", "godot engine")]
        
        for key, name in services:
            dot = StatusDot(name); self._dots[key] = dot; l_sys.addWidget(dot)
        
        l_sys.addWidget(sep())
        self._build_progress = QProgressBar(); self._build_progress.setRange(0, 7); self._build_progress.setFixedHeight(6); self._build_progress.setVisible(False); l_sys.addWidget(self._build_progress)
        
        self._build_lbl = lbl("", WHITE, 9) # Testo bianco base
        self._build_lbl.setVisible(False); l_sys.addWidget(self._build_lbl)
        
        self._build_progress = QProgressBar(); self._build_progress.setRange(0, 7)
        self._build_progress.setTextVisible(False)
        self._build_progress.setFixedHeight(6); self._build_progress.setVisible(False); l_sys.addWidget(self._build_progress)
        
        btn_row = QHBoxLayout()
        self.btn_start = QPushButton("▶  START SYSTEM")
        self.btn_start.setObjectName("green")
        self.btn_start.clicked.connect(self._start_system)
        btn_row.addWidget(self.btn_start)
        l_sys.addLayout(btn_row)
        lay.addWidget(self.f_sys, stretch=5)

        # Section containing hardware calibration triggers
        f_cal = card(); l_cal = QVBoxLayout(f_cal); l_cal.setSpacing(4)
        hdr_c = QHBoxLayout()
        self.lbl_title_cal = lbl("CALIBRATIONS", ACCENT, 12, spacing=2, bold=True)
        hdr_c.addWidget(self.lbl_title_cal); hdr_c.addStretch()
        self._calib_status = lbl("TO DO", ORANGE, 9); hdr_c.addWidget(self._calib_status); l_cal.addLayout(hdr_c)
        l_cal.addWidget(sep())
        
        self.lbl_sub_imu = lbl("Neutral Wrist (odd number sensor)", GREY, 11)
        self.lbl_sub_imu.setAlignment(Qt.AlignCenter)
        self.btn_imu = QPushButton(" IMU CALIBRATION"); self.btn_imu.setEnabled(False); self.btn_imu.clicked.connect(self._calib_imu)
        self._imu_bar = CalibBar(ACCENT, CALIB_DURATION_IMU); self._imu_bar.finished.connect(self._on_imu_calib_done)
        l_cal.addWidget(self.lbl_sub_imu); l_cal.addWidget(self.btn_imu); l_cal.addWidget(self._imu_bar)
        
        l_cal.addSpacing(4)
        
        self.lbl_sub_emg = lbl("Max contraction (even number sensor)", GREY, 11)
        self.lbl_sub_emg.setAlignment(Qt.AlignCenter)
        self.btn_emg = QPushButton(" EMG CALIBRATION"); self.btn_emg.setEnabled(False); self.btn_emg.clicked.connect(self._calib_emg)
        self._emg_bar = CalibBar(ORANGE, CALIB_DURATION_EMG); self._emg_bar.finished.connect(self._on_emg_calib_done)
        l_cal.addWidget(self.lbl_sub_emg); l_cal.addWidget(self.btn_emg); l_cal.addWidget(self._emg_bar)
        lay.addWidget(f_cal, stretch=5)

        # Section containing game control buttons
        f_rec = card(); l_rec = QVBoxLayout(f_rec)
        self.lbl_title_rec = lbl("GAMEPLAY", ACCENT, 12, spacing=2, bold=True)
        l_rec.addWidget(self.lbl_title_rec); l_rec.addWidget(sep())
        
        rec_btn_layout = QHBoxLayout()
        self.btn_record = QPushButton("▶  START")
        self.btn_restart = QPushButton("⟳  RESTART")
        for btn in [self.btn_record, self.btn_restart]:
            btn.setEnabled(False)
            
        self.btn_record.clicked.connect(self._toggle_recording)
        self.btn_restart.clicked.connect(self._restart_gameplay)
        
        rec_btn_layout.addWidget(self.btn_record)
        rec_btn_layout.addWidget(self.btn_restart)
        l_rec.addLayout(rec_btn_layout)
        
        self._rec_lbl = lbl("Waiting for system...", WHITE, 9)
        l_rec.addWidget(self._rec_lbl)
        lay.addWidget(f_rec, stretch=3)
        
        return w

    def _build_col_center(self):
        """Constructs the central dashboard column displaying live flight telemetry meters."""
        w = QWidget()
        lay = QVBoxLayout(w); lay.setContentsMargins(0,0,0,0); lay.setSpacing(12)
        
        f_hud = QFrame(); f_hud.setObjectName("card")
        l_hud = QVBoxLayout(f_hud); l_hud.setContentsMargins(16, 16, 16, 16); l_hud.setSpacing(12)
        
        self.lbl_title_hud = lbl("REALTIME FLIGHT HUD", ACCENT, 15, bold=True, spacing=2)
        l_hud.addWidget(self.lbl_title_hud); l_hud.addWidget(sep())

        # Match Score and Session Timer indicators
        st_row = QHBoxLayout()
        v_sc = QVBoxLayout()
        self.lbl_sc_title = lbl("SCORE", GREY, 13, bold=True)
        v_sc.addWidget(self.lbl_sc_title); self.hud_score = lbl("0", GREEN, 36, bold=True); v_sc.addWidget(self.hud_score); st_row.addLayout(v_sc)
        st_row.addStretch()
        v_tm = QVBoxLayout()
        self.lbl_tm_title = lbl("TIMER", GREY, 13, bold=True)
        v_tm.addWidget(self.lbl_tm_title); self.hud_timer = lbl("60", WHITE, 36, bold=True); v_tm.addWidget(self.hud_timer); st_row.addLayout(v_tm)
        l_hud.addLayout(st_row); l_hud.addWidget(sep())

        # Live EMG Muscle Activity Bar indicators
        hdr_b = QHBoxLayout()
        l_hud.addWidget(lbl("VELOCITY", ACCENT, 13, bold=True))
        l_hud.addWidget(lbl("EMG", WHITE, 14, bold=True))

        hdr_b = QHBoxLayout()
        hdr_b.addStretch()
        self.lbl_emg_pct = lbl("0%", WHITE, 10, bold=True)
        hdr_b.addWidget(self.lbl_emg_pct)
        l_hud.addLayout(hdr_b)

        self.emg_canvas = EMGNativeCanvas()
        l_hud.addWidget(self.emg_canvas)
        
        self.hud_emg_status = lbl("STATUS: UNCALIBRATED", GREY, 11, bold=True)
        l_hud.addWidget(self.hud_emg_status)
        l_hud.addWidget(sep())

        # 2D Spatial Crosshair Direction Indicators
        l_hud.addWidget(lbl("DIRECTION", ACCENT, 13, bold=True))
        l_hud.addWidget(lbl("IMU", WHITE, 13, bold=True))
        l_hud.addStretch()
        self.imu_visualizer = IMUVisualizer()
        l_hud.addWidget(self.imu_visualizer, alignment=Qt.AlignCenter)
        l_hud.addStretch()
        l_hud.addWidget(sep())

        # Exact Cartesian Twist Vector Value Fields
        self.lbl_tele_title = lbl("CURRENT TWIST TELEMETRY", ACCENT, 13, bold=True)
        l_hud.addWidget(self.lbl_tele_title)

        self.lbl_telemetria_x = lbl("X: +0.000", GREY, 14)
        self.lbl_telemetria_y = lbl("Y: +0.000", GREY, 14)
        self.lbl_telemetria_z = lbl("Z: +0.000", GREY, 14)

        for lbl_t in [self.lbl_telemetria_x, self.lbl_telemetria_y, self.lbl_telemetria_z]: 
            lbl_t.setAlignment(Qt.AlignCenter)
            l_hud.addWidget(lbl_t)
        
        lay.addWidget(f_hud)
        return w

    def _update_emg_hud(self, value: float):
        """Processes incoming muscle data stream inputs to update threshold zones and statuses."""
        if value == 999.0: # Magic state string payload flagging a calibration step complete
            self._emg_calibrated = True
            self._emg_done = True
            self.hud_emg_status.setText("STATUS: CALIBRATED ✓")
            self.hud_emg_status.setStyleSheet(f"color: {ACCENT}; font-weight: bold;")
            self._update_calib_status_string()
            return

        self._emg_value = value
        self.emg_canvas.update_value(self._emg_value, self._emg_calibrated)
        
        if not self._emg_calibrated:
            self.lbl_emg_pct.setText(f"{int(self._emg_value * 100)}% (raw)")
            self.hud_emg_status.setText("STATUS: UNCALIBRATED")
            
            target_color = WHITE if self._system_ready else GREY
            self.hud_emg_status.setStyleSheet(f"color: {target_color}; font-weight: bold;")
            return
        
        # Style active metrics checking output flags against internal thresholds
        self.lbl_emg_pct.setText(f"{int(self._emg_value * 100)}%")
        if self._emg_value < DEAD_THRESH:
            self.hud_emg_status.setText("STATUS: DEAD ZONE")
            self.hud_emg_status.setStyleSheet(f"color: {WHITE}; font-weight: bold;")
        elif self._emg_value < BOOST_THRESH:
            self.hud_emg_status.setText("STATUS: ▶ NORMAL")
            self.hud_emg_status.setStyleSheet(f"color: {GREEN}; font-weight: bold;")
        else:
            self.hud_emg_status.setText("STATUS: ⚡ BOOST")
            self.hud_emg_status.setStyleSheet(f"color: {RED_C}; font-weight: bold;")
            
    def _update_emg_raw_hud(self, value: float): 
        self._update_emg_hud(value)

    def _update_imu_hud(self, pitch: float, roll: float): 
        self.imu_visualizer.update_angles(pitch, roll)

    def _update_score_hud(self, score: int):
        """Tracks, updates, and updates the layout text color based on points accumulated."""
        self._current_score += score
        self.hud_score.setText(str(self._current_score))
        if self._current_score > 0:
            self.hud_score.setStyleSheet(f"color: {GREEN}; font-size: 36px; font-weight: bold;")
        elif self._current_score < 0:
            self.hud_score.setStyleSheet(f"color: {RED_C}; font-size: 36px; font-weight: bold;")
        else:
            self.hud_score.setStyleSheet(f"color: {WHITE}; font-size: 36px; font-weight: bold;")

    def _update_twist_hud(self, lx: float, ly: float, lz: float):
        self.lbl_telemetria_x.setText(f"X: {lx:+.3f}")
        self.lbl_telemetria_y.setText(f"Y: {ly:+.3f}")
        self.lbl_telemetria_z.setText(f"Z: {lz:+.3f}")

    def _gui_tick(self):
        """Runs periodic match countdown calculations inside the primary thread loop."""
        if self._recording:
            elapsed = time.time() - self._game_start_time
            rem = max(0, 60 - int(elapsed))
            self.hud_timer.setText(str(rem))
            self.hud_timer.setStyleSheet(f"color: {RED_C if rem < 10 else WHITE}; font-size: 36px; font-weight: bold;")
            
            if rem <= 0: # Stop session recording when time hits zero
                self._recording = False
                self._game_start_time = None
                send_ctrl({'DataType': 'RECORDING_STOP'}, port=CTRL_PORT)
                if self._ros_listener: self._ros_listener.publish_game_over()
                self.btn_record.setText("▶  START")
                self.btn_record.setObjectName("green")
                self._rec_lbl.setText("TIME IS UP! Press START or RESTART.")
                self._rec_lbl.setStyleSheet(f"color: {RED_C}; font-weight: bold;")

    def _start_system(self):
        """
        Handles ecosystem bootstrapping. If the ecosystem is already active, 
        it performs a full restart by clean-forking the process tree.
        """
        if self._system_ready:
            setup_ws = os.path.join(os.path.expanduser("~"), "delsys_demo/ros2_ws/install/setup.bash")
            script_path = os.path.abspath(sys.argv[0])
            cmd = f"source /opt/ros/humble/setup.bash && source {setup_ws} && {sys.executable} {script_path}"
            if self._godot_process:
                self._godot_process.kill()
                self._godot_process = None
            pid = os.fork()
            if pid == 0:
                os.setsid() # Break process association to separate it from the current terminal group
                try:
                    subprocess.call("pkill -9 -f emg_processing_node 2>/dev/null", shell=True)
                    subprocess.call("pkill -9 -f imu_processing_node 2>/dev/null", shell=True)
                    subprocess.call("pkill -9 -f drone_controller_node 2>/dev/null", shell=True)
                    subprocess.call("pkill -9 -f rosbridge_websocket 2>/dev/null", shell=True)
                    subprocess.call("sudo pkill -9 -f delsys_connector_socket_ros.py 2>/dev/null", shell=True)
                    subprocess.call("sudo fuser -k -9 9001/tcp 9002/tcp 9003/tcp 9090/tcp 2>/dev/null", shell=True)
                except Exception: pass
                time.sleep(0.3)
                subprocess.Popen(cmd, shell=True, executable="/bin/bash")
                sys.exit(0)
            else:
                QApplication.quit()
                sys.exit(0)

        # Clear active interface tracker profiles to default values
        self._system_ready = False
        self._recording = False
        self._imu_done = False
        self._emg_done = False
        self._emg_calibrated = False
        self._current_score = 0
        self._godot_wid = None
        self._last_geom = None

        self.hud_score.setText("0")
        self.hud_score.setStyleSheet(f"color: {WHITE}; font-size: 36px; font-weight: bold;") 
        self.hud_timer.setText("60")
        self.btn_start.setEnabled(False)
        self._build_progress.setVisible(True)
        self._build_progress.setValue(0)
        self._build_lbl.setVisible(True)
        self._imu_bar.reset(); self._emg_bar.reset()
        self.emg_canvas.update_value(0.0, False)
        self._calib_status.setText("TO DO")
        
        for dot in self._dots.values(): dot.set_state("off")
        self._step_event.clear()

        # Unroll initialization sequences via an independent execution background worker thread
        threading.Thread(target=self._launch_sequence, daemon=True).start()

    def _kill_system_procs(self):
        if self._godot_process: self._godot_process.kill(); self._godot_process = None
        self._pm.stop_all()
        time.sleep(0.3)

    def _sync_godot_window(self):
        """
        Runs continuously in the background to handle the X11 embedding logic.
        Snaps the external Godot simulation window into the designated PyQt container layout.
        """
        if not self._godot_wid:
            self._godot_wid = self._find_godot_window()
            if self._godot_wid: self._raise_godot()
            return
        self._move_resize_godot()
        
    def _launch_sequence(self):
        """
        The master ecosystem initialization chain. Sources paths, builds custom packages,
        launches ROS nodes step-by-step, and verifies the hardware connections.
        """
        ros = f"source {ROS_SETUP} && source {WS_SETUP}"
        self._pm.stop_all(); time.sleep(0.4)

        # Step 1: Recompile the workspace and build custom ROS2 messages
        self.sig_step.emit(0, "build", "pending", "building...", "colcon build...")
        proc = self._pm.start("build", f"cd {ROS_WS} && source {ROS_SETUP} && rm -rf {ROS_WS}/build/delsys_interfaces && colcon build --symlink-install --event-handlers console_cohesion+ status+ 2>&1")
        proc.wait()
        if proc.returncode != 0: self.sig_step.emit(1, "build", "error", "FAIL", "Build failed"); return
        self.sig_step.emit(1, "build", "ok", "colcon build ✓", "✓ colcon build complete")
        
        # Step 2: Spin up the ROSBridge WebSocket Server for browser/engine integration
        self.sig_step.emit(1, "rosbridge", "pending", "running...", "ROSBridge...")
        self._pm.start("rosbridge", f"{ros} && ros2 launch rosbridge_server rosbridge_websocket_launch.xml", ready_trigger="started on port")
        self._step_event.wait(timeout=6.0); self._step_event.clear()
        self.sig_step.emit(2, "rosbridge", "ok", "rosbridge ✓", "✓ ROSBridge activated")

        # Step 3: Launch the EMG signal filtering and processing node
        self.sig_step.emit(2, "emg", "pending", "running...", "EMG node...")
        self._pm.start("emg", f"{ros} && ros2 run emg_processing emg_processing_node", ready_trigger="listening")
        self._step_event.wait(timeout=6.0); self._step_event.clear()
        self.sig_step.emit(3, "emg", "ok", "emg_processing ✓", "✓ EMG server activated")

        # Step 4: Launch the IMU kinematic processing node
        self.sig_step.emit(3, "imu", "pending", "running...", "IMU node...")
        self._pm.start("imu", f"{ros} && ros2 run imu_processing imu_processing_node", ready_trigger="listening")
        self._step_event.wait(timeout=6.0); self._step_event.clear()
        self.sig_step.emit(4, "imu", "ok", "imu_processing ✓", "✓ IMU server activated")

        # Step 5: Launch the master drone navigation tracking controller
        self.sig_step.emit(4, "controller", "pending", "running...", "Controller...")
        self._pm.start("controller", f"{ros} && ros2 run drone_controller drone_controller_node", ready_trigger="started")
        self._step_event.wait(timeout=5.0); self._step_event.clear()
        self.sig_step.emit(5, "controller", "ok", "controller ✓", "✓ Controller activated")

        # Step 6: Connect to the physical Delsys base station hardware via sockets (requires root privileges)
        self.sig_step.emit(5, "bridge", "pending", "syncing hardware...", "Delsys RF Sync...")
        self._pm.start("bridge", f"cd {BRIDGE_DIR} && python3 delsys_connector_socket_ros.py", sudo=True, ready_trigger="READY")
        self._step_event.wait(timeout=15.0); self._step_event.clear()
        self.sig_step.emit(6, "bridge", "ok", "delsys_connector ✓", "✓ Hardware Connected")

        # Step 7: Launch the Godot 3D game simulation runtime executable
        self.sig_step.emit(6, "godot", "pending", "starting...", "Godot...")
        self.sig_ready.emit()

    def moveEvent(self, event): 
        super().moveEvent(event)
        self._move_resize_godot()
    
    def resizeEvent(self, event):
        """Handles on-the-fly component rescaling to maintain readable text across different layout proportions."""
        super().resizeEvent(event)
        self._move_resize_godot()
        
        scale = event.size().height() / 760.0
        if scale < 0.7: scale = 0.7 
        
        self.setStyleSheet(get_stylesheet(scale))
        
        title_scale_size = max(10, int(14 * scale))
        self.lbl_brand1.setStyleSheet(f"color: {ACCENT}; font-size: {title_scale_size}px; font-weight: bold; letter-spacing: 1px;")
        
        target_widgets = self.col_left.findChildren(QLabel) + self.col_center.findChildren(QLabel)
        for widget in target_widgets:
            if widget == self.lbl_brand1: continue 
            base_sz = widget.property("base_size")
            if base_sz is not None:
                new_sz = max(6, int(base_sz * scale))
                widget.setProperty("current_size", new_sz)
                
                curr_style = widget.styleSheet()
                if "color" in curr_style:
                    color_part = curr_style.split("font-size")[0].strip()
                    is_bold = "bold" in curr_style
                    w_weight = "bold" if is_bold else "normal"
                    widget.setStyleSheet(f"{color_part} font-size: {new_sz}px; font-weight: {w_weight};")
                else:
                    widget.setStyleSheet(f"font-size: {new_sz}px;")
                    
        # Dynamically scale branding logo graphics in the bottom panel bounds
        avail_width = max(100, self.godot_host.width() // 2 - 20)
        avail_height = max(40, self.f_bottom_logos.height() - 16)
        
        if os.path.exists(BOTTOM_LOGO_DELSYS):
            pix_delsys = QPixmap(BOTTOM_LOGO_DELSYS).scaled(avail_width, avail_height, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            self.lbl_bottom_delsys.setPixmap(pix_delsys)
            
        if os.path.exists(BOTTOM_LOGO_ARS):
            pix_ars = QPixmap(BOTTOM_LOGO_ARS).scaled(avail_width, avail_height, Qt.KeepAspectRatio, Qt.SmoothTransformation)
            self.lbl_bottom_ars.setPixmap(pix_ars)

        for dot in self._dots.values(): dot.update_scale(scale)
        self._imu_bar.update_scale(scale)
        self._emg_bar.update_scale(scale)

    def _on_system_ready(self):
        """Triggers immediately once the launch sequence finishes to spin up and embed the simulation app."""
        self._godot_process = QProcess(self)
        self._godot_process.setProcessChannelMode(QProcess.MergedChannels)
        self._godot_process.start(GODOT_BIN, ["--path", GODOT_PROJECT_DIR, "--windowed", "--borderless", "--title", "drone-game", "--no-vsync"])
       
        self._system_ready = True

        self.btn_record.setEnabled(True)
        self.btn_restart.setEnabled(True)
        self.btn_record.setObjectName("green")
        self.btn_restart.setObjectName("orange")

        self.btn_record.setStyleSheet("")
        self.btn_restart.setStyleSheet("")
        
        # Force Qt stylesheet repolishing to refresh newly unlocked styles instantly
        self.btn_record.style().unpolish(self.btn_record)
        self.btn_record.style().polish(self.btn_record)
        self.btn_restart.style().unpolish(self.btn_restart)
        self.btn_restart.style().polish(self.btn_restart)

        # Transition text metrics to bold white states once systems are active
        to_white = [self.lbl_sc_title, self.lbl_tm_title, self.hud_emg_status, 
                    self.lbl_sub_imu, self.lbl_sub_emg, 
                    self.lbl_telemetria_x, self.lbl_telemetria_y, self.lbl_telemetria_z]
        for l in to_white:
            l.setStyleSheet(f"color: {WHITE}; font-size: {l.property('current_size') or l.property('base_size')}px; font-weight: bold;")

        # Complete final dashboard update steps
        self.sig_step.emit(7, "godot", "ok", "godot ✓", "✓ Activated")
        self.btn_start.setText("↺  RESTART SYSTEM")
        self.btn_start.setEnabled(True)
        self.btn_imu.setEnabled(True); self.btn_emg.setEnabled(True)
        self._build_progress.setValue(7)
        
        self._build_lbl.setText("✓ Ecosystem operational")
        self._build_lbl.setStyleSheet(f"color: {ACCENT}; font-size: {self._build_lbl.property('current_size') or 9}px;")
        self._rec_lbl.setText("Ecosystem ready. Calibrate sensors.")
        self._rec_lbl.setStyleSheet(f"color: {WHITE};")
        
    def _calib_imu(self):
        self.btn_imu.setEnabled(False); self._imu_bar.reset(); self._imu_bar.start("IMU — Hold wrist steady")
        send_ctrl({'DataType': 'IMU_CALIB'}, port=IMU_PORT)
        send_ctrl({'DataType': 'IMU_CALIB'}, port=CTRL_PORT)

    def _on_imu_calib_done(self):
        self._imu_done = True; self.btn_imu.setText(" ↺ RE-CALIBRATE IMU"); self.btn_imu.setEnabled(True)
        self._update_calib_status_string()

    def _calib_emg(self):
        self.btn_emg.setEnabled(False)
        self._emg_bar.reset()
        send_ctrl({'DataType': 'EMG_CALIB'}, port=BRIDGE_CMD_PORT)
        self._emg_bar.start("EMG — Maximum muscle contraction...")

    def _on_emg_calib_done(self):
        self._emg_calibrated = True         
        self._emg_done = True
        self.btn_emg.setText(" ↺ RE-CALIBRATE EMG")
        self.btn_emg.setEnabled(True)
        self._update_calib_status_string()

    def _update_calib_status_string(self):
        """Evaluates ongoing readiness profiles across all sensors before unlocking takeoff permissions."""
        sz = self._calib_status.property("current_size") or 9
        if self._imu_done and self._emg_done:
            self._calib_status.setText("✓ calibrated"); self._calib_status.setStyleSheet(f"color: {ACCENT}; font-size: {sz}px;")
            self._rec_lbl.setText("✓ Ready for flight! Press START."); self._rec_lbl.setStyleSheet(f"color: {ACCENT}; font-size: {self._rec_lbl.property('current_size') or 9}px;")
        else:
            self._calib_status.setText("TO DO"); self._calib_status.setStyleSheet(f"color: {ORANGE}; font-size: {sz}px;") 

    def _restart_gameplay(self):
        """Resets score data metrics, updates session clocks, and publishes a gameplay reset notice."""
        if self._recording:
            self._recording = False
            send_ctrl({'DataType': 'RECORDING_STOP'}, port=CTRL_PORT)
        self._current_score = 0; self._game_start_time = None
        self.hud_score.setText("0")
        self.hud_score.setStyleSheet(f"color: {WHITE}; font-size: 36px; font-weight: bold;") 
        self.hud_timer.setText("60")
        self.btn_record.setText("▶  START")
        self.btn_record.setObjectName("green") 
        #self.btn_record.setStyleSheet(f"color: {BG}; border-color: {GREEN};")
        self._rec_lbl.setText("✓ Ready for flight! Press START."); self._rec_lbl.setStyleSheet(f"color: {ACCENT};")
        if self._ros_listener: self._ros_listener.publish_game_reset()

    def _toggle_recording(self):
        """Swaps session activity recording states and dispatches corresponding notification updates to ROS."""
        self._recording = not self._recording
        if self._recording:
            self._current_score = 0; self.hud_score.setText("0"); self.hud_timer.setText("60")
            self._game_start_time = time.time()
            if self._ros_listener: self._ros_listener.publish_game_reset()
            QTimer.singleShot(100, lambda: send_ctrl({'DataType': 'RECORDING_START'}, port=CTRL_PORT))
            self.btn_record.setText("■  STOP"); 
            self.btn_record.setObjectName("red")
        else:
            self._game_start_time = None
            send_ctrl({'DataType': 'RECORDING_STOP'}, port=CTRL_PORT)
            self.btn_record.setText("▶  START")
            self.btn_record.setObjectName("green")
            if self._ros_listener: self._ros_listener.publish_game_over()
        self.btn_record.setStyleSheet("") 
        self.btn_record.style().unpolish(self.btn_record)
        self.btn_record.style().polish(self.btn_record)

    def _handle_step_update(self, val, key, status, dot_text, log_text):
        """Intercepts background worker deployment notifications to advance dashboard progress track elements."""
        self._build_progress.setValue(val)
        self._build_lbl.setText(log_text)

        color = ACCENT if status == 'ok' else WHITE
        sz = self._build_lbl.property("current_size") or 9
        self._build_lbl.setStyleSheet(f"color: {color}; font-size: {sz}px;")
        
        self._dots[key].set_state(status, dot_text)

    def closeEvent(self, e): 
        """Safely intercepts window close commands to gracefully terminate all child processes."""
        self._kill_system_procs()
        super().closeEvent(e)

def main():
    """Initializes the master framework QApplication window instance."""
    app = QApplication(sys.argv); win = MainWindow(); win.show(); sys.exit(app.exec_())

if __name__ == '__main__': 
    try:
        # Check for target environment parameters before launching the GUI application
        from delsys_interfaces.msg import DelsysSensorData
        print("[LAUNCHER] ROS2 environment detected correctly. Starting GUI...")
    except ImportError:
        # If the environment is not sourced, execute a hot shell overlay to auto-source the workspace paths
        print("[LAUNCHER] Custom messages not found. Attempting auto-source of environment...")
        setup_ws = os.path.join(os.path.expanduser("~"), "delsys_demo/ros2_ws/install/setup.bash")
        python_executable = sys.executable
        script_path = os.path.abspath(__file__)
        cmd = f"source /opt/ros/humble/setup.bash && source {setup_ws} && {python_executable} {script_path}"
        os.execl("/bin/bash", "bash", "-c", cmd) # Replaces the active process image instantly

    main()