pc_stats_monitor_v2_linux.py

"""
PC Stats Monitor v2.0 - Linux Edition
Dynamic Sensor Selection with GUI Configuration
Uses psutil for hardware sensor discovery
"""

import psutil
import socket
import time
import json
import os
import sys
import glob as _glob
import argparse
from datetime import datetime

# Tkinter is imported conditionally only when GUI mode is needed
# This allows the script to run on headless systems without tkinter

# Configuration file path
CONFIG_FILE = "monitor_config_linux.json"

# Default configuration
DEFAULT_CONFIG = {
    "version": "2.0-linux",
    "esp32_ip": "192.168.1.197",
    "udp_port": 4210,
    "update_interval": 3,
    "metrics": []
}

# Maximum metrics supported by ESP32
MAX_METRICS = 20

# Global sensor database
sensor_database = {
    "system": [],      # psutil-based metrics (CPU%, RAM%, Disk%)
    "temperature": [], # Hardware temperatures
    "fan": [],         # Fan speeds
    "data": [],        # Network data (total uploaded/downloaded)
    "throughput": [],  # Network throughput (current upload/download speed)
    "gpu": [],         # GPU metrics (usage, memory, freq, fan, power)
    "other": []
}

# Network tracking for speed calculation
network_last_sample = {}
network_last_time = None

# NVML handles for NVIDIA GPU (populated during sensor discovery or lazily)
nvml_handles = {}


def discover_sensors():
    """
    Discover all available sensors from psutil on Linux
    """
    print("=" * 60)
    print("PC STATS MONITOR v2.0 - LINUX EDITION - SENSOR DISCOVERY")
    print("=" * 60)

    # Add psutil system metrics
    print("\n[1/3] Discovering system metrics (psutil)...")

    # Warm up psutil for accurate readings
    psutil.cpu_percent(interval=0.1)

    sensor_database["system"].append({
        "name": "CPU",
        "display_name": "CPU Usage",
        "source": "psutil",
        "type": "percent",
        "unit": "%",
        "psutil_method": "cpu_percent",
        "custom_label": "",
        "current_value": int(psutil.cpu_percent(interval=0))
    })

    sensor_database["system"].append({
        "name": "RAM",
        "display_name": "RAM Usage",
        "source": "psutil",
        "type": "percent",
        "unit": "%",
        "psutil_method": "virtual_memory.percent",
        "custom_label": "",
        "current_value": int(psutil.virtual_memory().percent)
    })

    sensor_database["system"].append({
        "name": "RAM_GB",
        "display_name": "RAM Used (GB)",
        "source": "psutil",
        "type": "memory",
        "unit": "GB",
        "psutil_method": "virtual_memory.used",
        "custom_label": "",
        "current_value": int(psutil.virtual_memory().used / (1024**3))
    })

    sensor_database["system"].append({
        "name": "SWAP",
        "display_name": "Swap Usage",
        "source": "psutil",
        "type": "percent",
        "unit": "%",
        "psutil_method": "swap_memory.percent",
        "custom_label": "",
        "current_value": int(psutil.swap_memory().percent)
    })

    sensor_database["system"].append({
        "name": "SWAP_GB",
        "display_name": "Swap Used (GB)",
        "source": "psutil",
        "type": "memory",
        "unit": "GB",
        "psutil_method": "swap_memory.used",
        "custom_label": "",
        "current_value": int(psutil.swap_memory().used / (1024**3))
    })

    sensor_database["system"].append({
        "name": "DISK",
        "display_name": "Disk / Usage",
        "source": "psutil",
        "type": "percent",
        "unit": "%",
        "psutil_method": "disk_usage",
        "custom_label": "",
        "current_value": int(psutil.disk_usage('/').percent)
    })

    print(f"  Found {len(sensor_database['system'])} system metrics")

    # Discover hardware sensors (temperatures)
    print("\n[2/3] Discovering hardware sensors (temperatures & fans)...")
    sensor_count = 0

    try:
        # Temperature sensors
        if hasattr(psutil, "sensors_temperatures"):
            temps = psutil.sensors_temperatures()

            for sensor_name, entries in temps.items():
                for entry in entries:
                    # Generate short name
                    short_name = generate_short_name_linux(entry.label, "temperature", sensor_name)

                    # Generate display name
                    display_name = f"{entry.label} [{sensor_name}]" if entry.label else f"Sensor [{sensor_name}]"

                    # Get current value
                    try:
                        current_value = int(entry.current) if entry.current else 0
                    except:
                        current_value = 0

                    sensor_info = {
                        "name": short_name,
                        "display_name": display_name,
                        "source": "psutil_temp",
                        "type": "temperature",
                        "unit": "C",
                        "sensor_key": sensor_name,
                        "sensor_label": entry.label,
                        "custom_label": "",
                        "current_value": current_value
                    }

                    sensor_database["temperature"].append(sensor_info)
                    sensor_count += 1

        # Fan sensors
        if hasattr(psutil, "sensors_fans"):
            fans = psutil.sensors_fans()

            for sensor_name, entries in fans.items():
                for entry in entries:
                    # Generate short name
                    short_name = generate_short_name_linux(entry.label, "fan", sensor_name)

                    # Generate display name
                    display_name = f"{entry.label} [{sensor_name}]" if entry.label else f"Fan [{sensor_name}]"

                    # Get current value
                    try:
                        current_value = int(entry.current) if entry.current else 0
                    except:
                        current_value = 0

                    sensor_info = {
                        "name": short_name,
                        "display_name": display_name,
                        "source": "psutil_fan",
                        "type": "fan",
                        "unit": "RPM",
                        "sensor_key": sensor_name,
                        "sensor_label": entry.label,
                        "custom_label": "",
                        "current_value": current_value
                    }

                    sensor_database["fan"].append(sensor_info)
                    sensor_count += 1

        print(f"  Found {sensor_count} hardware sensors:")
        print(f"    - Temperatures: {len(sensor_database['temperature'])}")
        print(f"    - Fans: {len(sensor_database['fan'])}")

    except Exception as e:
        print(f"  WARNING: Could not access hardware sensors: {e}")

    # Discover network metrics
    print("\n[3/4] Discovering network metrics...")
    net_count = 0

    try:
        net_io = psutil.net_io_counters(pernic=True)

        for interface, stats in net_io.items():
            # Skip loopback
            if interface == "lo":
                continue

            # Total Data Uploaded
            sensor_database["data"].append({
                "name": f"{interface[:7]}_U",
                "display_name": f"Data Uploaded - {interface}",
                "source": "psutil_net",
                "type": "data",
                "unit": "MB",
                "interface": interface,
                "metric": "bytes_sent",
                "custom_label": "",
                "current_value": int(stats.bytes_sent / (1024**2))  # MB
            })

            # Total Data Downloaded
            sensor_database["data"].append({
                "name": f"{interface[:7]}_D",
                "display_name": f"Data Downloaded - {interface}",
                "source": "psutil_net",
                "type": "data",
                "unit": "MB",
                "interface": interface,
                "metric": "bytes_recv",
                "custom_label": "",
                "current_value": int(stats.bytes_recv / (1024**2))  # MB
            })

            # Upload Speed (will be calculated dynamically)
            sensor_database["throughput"].append({
                "name": f"{interface[:7]}_U",
                "display_name": f"Upload Speed - {interface}",
                "source": "psutil_net_speed",
                "type": "throughput",
                "unit": "MB/s",
                "interface": interface,
                "metric": "bytes_sent",
                "custom_label": "",
                "current_value": 0  # Will be calculated
            })

            # Download Speed (will be calculated dynamically)
            sensor_database["throughput"].append({
                "name": f"{interface[:7]}_D",
                "display_name": f"Download Speed - {interface}",
                "source": "psutil_net_speed",
                "type": "throughput",
                "unit": "MB/s",
                "interface": interface,
                "metric": "bytes_recv",
                "custom_label": "",
                "current_value": 0  # Will be calculated
            })

            net_count += 4

        print(f"  Found {net_count} network metrics:")
        print(f"    - Data: {len(sensor_database['data'])}")
        print(f"    - Throughput: {len(sensor_database['throughput'])}")

    except Exception as e:
        print(f"  WARNING: Could not access network stats: {e}")

    # Discover GPU metrics
    print("\n[4/4] Discovering GPU sensors...")
    nvidia_found = _discover_nvidia_sensors()
    if not nvidia_found:
        _discover_amd_sensors()

    total_gpu = len(sensor_database["gpu"])
    if total_gpu:
        print(f"  Found {total_gpu} GPU metric(s)")
    else:
        print("  No GPU sensors found")
        print("  NVIDIA: pip install nvidia-ml-py3")
        print("  AMD:    requires amdgpu kernel driver (/sys/class/drm/)")

    print("\n" + "=" * 60)
    print("\nℹ NOTE: Sensor values in GUI are static (captured at launch time)")
    print("  This helps you identify active sensors and their typical readings.")


def generate_short_name_linux(label, sensor_type, sensor_key=""):
    """
    Generate a short name (max 10 chars) for ESP32 display - Linux version
    """
    # Start with label or sensor key
    name = label if label else sensor_key

    # Add prefixes based on sensor key
    if sensor_type == "temperature":
        if "coretemp" in sensor_key.lower():
            if "package" in label.lower():
                name = "CPU_PKG"
            elif "core" in label.lower():
                # Extract core number
                import re
                match = re.search(r'core (\d+)', label.lower())
                if match:
                    name = f"CPU_C{match.group(1)}"
                else:
                    name = "CPU_Temp"
            else:
                name = "CPU_Temp"
        elif "k10temp" in sensor_key.lower():
            name = "CPU_Tctl" if "tctl" in label.lower() else "CPU_Temp"
        elif "nvidia" in sensor_key.lower() or "gpu" in sensor_key.lower():
            name = "GPU_Temp"
        elif "nvme" in sensor_key.lower():
            name = "NVMe_Temp"
        else:
            name = label[:10] if label else "TEMP"

    elif sensor_type == "fan":
        if "fan" in label.lower():
            import re
            match = re.search(r'(\d+)', label)
            if match:
                name = f"FAN{match.group(1)}"
            else:
                name = "FAN"
        else:
            name = label[:10] if label else "FAN"

    # Clean up
    name = name.replace(" ", "_").replace("-", "_")

    # Truncate if too long
    if len(name) > 10:
        name = name[:10]

    return name if name else "SENSOR"


# ============================================================================
# GPU Sensor Discovery
# ============================================================================

def _discover_nvidia_sensors():
    """
    Discover NVIDIA GPU sensors via pynvml (nvidia-ml-py3).
    Populates sensor_database["gpu"] and nvml_handles.
    Returns True if any GPU was found.
    """
    global nvml_handles
    try:
        import pynvml
        pynvml.nvmlInit()
        device_count = pynvml.nvmlDeviceGetCount()

        for i in range(device_count):
            handle = pynvml.nvmlDeviceGetHandleByIndex(i)
            nvml_handles[i] = handle

            try:
                gpu_name = pynvml.nvmlDeviceGetName(handle)
                if isinstance(gpu_name, bytes):
                    gpu_name = gpu_name.decode("utf-8")
            except Exception:
                gpu_name = f"NVIDIA GPU {i}"

            prefix = f"GPU{i}" if device_count > 1 else "GPU"

            # GPU Usage %
            try:
                util_val = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
            except Exception:
                util_val = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_USE",
                "display_name": f"GPU Usage [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "percent",
                "unit": "%",
                "gpu_index": i,
                "metric": "utilization",
                "custom_label": "",
                "current_value": util_val
            })

            # GPU Memory Used (MB)
            try:
                mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
                mem_val = int(mem_info.used / (1024 ** 2))
            except Exception:
                mem_val = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_MEM",
                "display_name": f"GPU Memory [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "memory",
                "unit": "MB",
                "gpu_index": i,
                "metric": "memory_used",
                "custom_label": "",
                "current_value": mem_val
            })

            # GPU Core Frequency (MHz)
            try:
                freq_val = pynvml.nvmlDeviceGetClockInfo(handle, pynvml.NVML_CLOCK_GRAPHICS)
            except Exception:
                freq_val = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_FRQ",
                "display_name": f"GPU Freq [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "frequency",
                "unit": "MHz",
                "gpu_index": i,
                "metric": "clock_graphics",
                "custom_label": "",
                "current_value": freq_val
            })

            # GPU Fan Speed (%)
            try:
                fan_val = pynvml.nvmlDeviceGetFanSpeed(handle)
            except Exception:
                fan_val = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_FAN",
                "display_name": f"GPU Fan [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "percent",
                "unit": "%",
                "gpu_index": i,
                "metric": "fan_speed",
                "custom_label": "",
                "current_value": fan_val
            })

            # GPU Power (W)
            try:
                power_val = int(pynvml.nvmlDeviceGetPowerUsage(handle) / 1000)
            except Exception:
                power_val = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_PWR",
                "display_name": f"GPU Power [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "power",
                "unit": "W",
                "gpu_index": i,
                "metric": "power_usage",
                "custom_label": "",
                "current_value": power_val
            })

            # GPU Temperature (°C)
            try:
                temp_val = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
            except Exception:
                temp_val = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_TMP",
                "display_name": f"GPU Temp [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "temperature",
                "unit": "C",
                "gpu_index": i,
                "metric": "temperature",
                "custom_label": "",
                "current_value": temp_val
            })

            # GPU Memory Used %
            try:
                mem_info = pynvml.nvmlDeviceGetMemoryInfo(handle)
                mem_pct = int(mem_info.used * 100 / mem_info.total) if mem_info.total > 0 else 0
            except Exception:
                mem_pct = 0
            sensor_database["gpu"].append({
                "name": f"{prefix}_MEMP",
                "display_name": f"GPU Mem % [{gpu_name}]",
                "source": "nvml_gpu",
                "type": "percent",
                "unit": "%",
                "gpu_index": i,
                "metric": "memory_percent",
                "custom_label": "",
                "current_value": mem_pct
            })

        if device_count > 0:
            print(f"  NVIDIA: {device_count} GPU(s) detected via pynvml")
            return True
        return False

    except ImportError:
        print("  NVIDIA: pynvml not installed (pip install nvidia-ml-py3)")
    except Exception as e:
        print(f"  NVIDIA: {e}")

    return False


def _discover_amd_sensors():
    """
    Discover AMD GPU sensors via Linux sysfs (/sys/class/drm/).
    Populates sensor_database["gpu"].
    Returns True if any GPU was found.
    """
    AMD_VENDOR_ID = "0x1002"
    drm_cards = sorted(_glob.glob("/sys/class/drm/card[0-9]"))
    found = False

    def _read_int(path):
        try:
            with open(path) as f:
                return int(f.read().strip())
        except OSError:
            return None

    for card_path in drm_cards:
        device_path = os.path.join(card_path, "device")
        try:
            with open(os.path.join(device_path, "vendor")) as f:
                if f.read().strip().lower() != AMD_VENDOR_ID:
                    continue
        except OSError:
            continue

        card_name = os.path.basename(card_path)          # e.g. "card0"
        gpu_name  = f"AMD GPU ({card_name})"
        prefix    = card_name.upper()                     # e.g. "CARD0"

        hwmon_dirs = sorted(_glob.glob(os.path.join(device_path, "hwmon", "hwmon*")))
        hwmon_path = hwmon_dirs[0] if hwmon_dirs else None

        # GPU Usage %
        busy_val = _read_int(os.path.join(device_path, "gpu_busy_percent"))
        if busy_val is not None:
            sensor_database["gpu"].append({
                "name": f"{prefix}_USE",
                "display_name": f"GPU Usage [{gpu_name}]",
                "source": "amd_sysfs",
                "type": "percent",
                "unit": "%",
                "device_path": device_path,
                "hwmon_path": hwmon_path,
                "metric": "gpu_busy_percent",
                "custom_label": "",
                "current_value": busy_val
            })
            found = True

        # GPU Memory Used (MB)
        vram_val = _read_int(os.path.join(device_path, "mem_info_vram_used"))
        if vram_val is not None:
            sensor_database["gpu"].append({
                "name": f"{prefix}_MEM",
                "display_name": f"GPU Memory [{gpu_name}]",
                "source": "amd_sysfs",
                "type": "memory",
                "unit": "MB",
                "device_path": device_path,
                "hwmon_path": hwmon_path,
                "metric": "mem_info_vram_used",
                "custom_label": "",
                "current_value": int(vram_val / (1024 ** 2))
            })
            found = True

        # GPU Memory Used %
        vram_total_val = _read_int(os.path.join(device_path, "mem_info_vram_total"))
        if vram_val is not None and vram_total_val is not None and vram_total_val > 0:
            sensor_database["gpu"].append({
                "name": f"{prefix}_MEMP",
                "display_name": f"GPU Mem % [{gpu_name}]",
                "source": "amd_sysfs",
                "type": "percent",
                "unit": "%",
                "device_path": device_path,
                "hwmon_path": hwmon_path,
                "metric": "mem_percent",
                "custom_label": "",
                "current_value": int(vram_val * 100 / vram_total_val)
            })
            found = True

        if hwmon_path:
            # GPU Temperature (millidegrees C → °C)
            temp_val = _read_int(os.path.join(hwmon_path, "temp1_input"))
            if temp_val is not None:
                sensor_database["gpu"].append({
                    "name": f"{prefix}_TMP",
                    "display_name": f"GPU Temp [{gpu_name}]",
                    "source": "amd_sysfs",
                    "type": "temperature",
                    "unit": "C",
                    "device_path": device_path,
                    "hwmon_path": hwmon_path,
                    "metric": "temp1_input",
                    "custom_label": "",
                    "current_value": temp_val // 1000
                })
                found = True

            # GPU Core Frequency (Hz → MHz)
            freq_val = _read_int(os.path.join(hwmon_path, "freq1_input"))
            if freq_val is not None:
                sensor_database["gpu"].append({
                    "name": f"{prefix}_FRQ",
                    "display_name": f"GPU Freq [{gpu_name}]",
                    "source": "amd_sysfs",
                    "type": "frequency",
                    "unit": "MHz",
                    "device_path": device_path,
                    "hwmon_path": hwmon_path,
                    "metric": "freq1_input",
                    "custom_label": "",
                    "current_value": freq_val // 1_000_000
                })
                found = True

            # Fan Speed (RPM)
            fan_val = _read_int(os.path.join(hwmon_path, "fan1_input"))
            if fan_val is not None:
                sensor_database["gpu"].append({
                    "name": f"{prefix}_FAN",
                    "display_name": f"GPU Fan [{gpu_name}]",
                    "source": "amd_sysfs",
                    "type": "fan",
                    "unit": "RPM",
                    "device_path": device_path,
                    "hwmon_path": hwmon_path,
                    "metric": "fan1_input",
                    "custom_label": "",
                    "current_value": fan_val
                })
                found = True

            # Power (µW → W); prefer power1_average, fall back to power1_input
            for pwr_metric in ("power1_average", "power1_input"):
                pwr_val = _read_int(os.path.join(hwmon_path, pwr_metric))
                if pwr_val is not None:
                    sensor_database["gpu"].append({
                        "name": f"{prefix}_PWR",
                        "display_name": f"GPU Power [{gpu_name}]",
                        "source": "amd_sysfs",
                        "type": "power",
                        "unit": "W",
                        "device_path": device_path,
                        "hwmon_path": hwmon_path,
                        "metric": pwr_metric,
                        "custom_label": "",
                        "current_value": int(pwr_val / 1_000_000)
                    })
                    found = True
                    break

    if found:
        amd_count = sum(1 for s in sensor_database["gpu"] if s["source"] == "amd_sysfs")
        print(f"  AMD: {amd_count} metric(s) detected via sysfs")
    else:
        print("  AMD: no GPU found (requires amdgpu kernel driver)")

    return found


# ============================================================================
# CLI Helper Functions - Validation
# ============================================================================

def validate_ip(ip: str) -> str:
    """
    Validate IPv4 address format
    """
    if not ip:
        raise ValueError("IP address cannot be empty")

    parts = ip.split('.')
    if len(parts) != 4:
        raise ValueError("Invalid IP format (must be xxx.xxx.xxx.xxx)")

    for part in parts:
        try:
            num = int(part)
            if num < 0 or num > 255:
                raise ValueError("IP octets must be 0-255")
        except ValueError:
            raise ValueError("IP octets must be numbers")

    return ip


def validate_port(port_str: str) -> int:
    """
    Validate UDP port number
    """
    try:
        port = int(port_str)
        if port < 1 or port > 65535:
            raise ValueError("Port must be between 1 and 65535")
        return port
    except ValueError:
        raise ValueError("Port must be a valid number (1-65535)")


def validate_interval(interval_str: str) -> float:
    """
    Validate update interval
    """
    try:
        interval = float(interval_str)
        if interval < 0.5:
            raise ValueError("Interval must be at least 0.5 seconds")
        return interval
    except ValueError:
        raise ValueError("Interval must be a valid number (>= 0.5)")


# ============================================================================
# CLI Helper Functions - Input
# ============================================================================

def prompt_with_default(prompt: str, default: str, validator=None) -> str:
    """
    Prompt user with a default value
    Returns default if user presses Enter, otherwise validates and returns input
    """
    while True:
        try:
            user_input = input(f"{prompt} [{default}]: ").strip()

            # Use default if empty
            if not user_input:
                value = default
            else:
                value = user_input

            # Validate if validator provided
            if validator:
                return str(validator(value))
            else:
                return value

        except ValueError as e:
            print(f"  ✗ Error: {e}")
            continue
        except KeyboardInterrupt:
            print("\n\nConfiguration cancelled.")
            return None


def parse_number_list(input_str: str, max_num: int) -> list:
    """
    Parse comma-separated list of numbers with validation
    Returns list of integers or raises ValueError
    """
    if not input_str.strip():
        raise ValueError("Please enter at least one metric number")

    # Split by comma and parse
    numbers = []
    for part in input_str.split(','):
        try:
            num = int(part.strip())
            if num < 1 or num > max_num:
                raise ValueError(f"Number {num} is out of range (1-{max_num})")
            numbers.append(num)
        except ValueError as e:
            if "invalid literal" in str(e):
                raise ValueError(f"'{part.strip()}' is not a valid number")
            else:
                raise

    # Check for duplicates
    if len(numbers) != len(set(numbers)):
        raise ValueError("Duplicate numbers detected")

    # Check max limit
    if len(numbers) > MAX_METRICS:
        raise ValueError(f"Too many metrics selected (max {MAX_METRICS})")

    return numbers


def load_config():
    """
    Load configuration from file
    """
    if not os.path.exists(CONFIG_FILE):
        return None

    try:
        with open(CONFIG_FILE, 'r') as f:
            config = json.load(f)
        print(f"\n✓ Loaded configuration from {CONFIG_FILE}")
        print(f"  Selected metrics: {len(config.get('metrics', []))}")
        return config
    except Exception as e:
        print(f"\n✗ Error loading config: {e}")
        return None


def save_config(config):
    """
    Save configuration to file
    """
    try:
        with open(CONFIG_FILE, 'w') as f:
            json.dump(config, f, indent=2)
        print(f"\n✓ Configuration saved to {CONFIG_FILE}")
        return True
    except Exception as e:
        print(f"\n✗ Error saving config: {e}")
        return False


def setup_autostart_systemd(enable=True):
    """
    Setup systemd service for autostart on Linux
    """
    import subprocess

    service_name = "pc-monitor"
    service_file = f"{service_name}.service"
    user_service_dir = os.path.expanduser("~/.config/systemd/user")
    service_path = os.path.join(user_service_dir, service_file)

    script_path = os.path.abspath(__file__)
    script_dir = os.path.dirname(script_path)

    if enable:
        # Create systemd user service directory if it doesn't exist
        os.makedirs(user_service_dir, exist_ok=True)

        # Generate service file content
        service_content = f"""[Unit]
Description=PC Stats Monitor for ESP32
After=network.target

[Service]
Type=simple
WorkingDirectory={script_dir}
ExecStart={sys.executable} {script_path}
Restart=on-failure
RestartSec=10

[Install]
WantedBy=default.target
"""

        try:
            # Write service file
            with open(service_path, 'w') as f:
                f.write(service_content)

            # Reload systemd daemon
            subprocess.run(["systemctl", "--user", "daemon-reload"], check=True)

            # Enable service
            subprocess.run(["systemctl", "--user", "enable", service_name], check=True)

            # Start service
            subprocess.run(["systemctl", "--user", "start", service_name], check=True)

            print(f"\n✓ Autostart enabled via systemd!")
            print(f"  Service file: {service_path}")
            print(f"  Service name: {service_name}")
            print(f"\nUseful commands:")
            print(f"  Check status: systemctl --user status {service_name}")
            print(f"  View logs:    journalctl --user -u {service_name} -f")
            print(f"  Stop service: systemctl --user stop {service_name}")
            return True

        except subprocess.CalledProcessError as e:
            print(f"\n✗ Error setting up systemd service: {e}")
            print("  Make sure systemd is available on your system")
            return False
        except Exception as e:
            print(f"\n✗ Error: {e}")
            return False

    else:
        # Disable autostart
        try:
            # Stop service
            subprocess.run(["systemctl", "--user", "stop", service_name],
                         stderr=subprocess.DEVNULL)

            # Disable service
            subprocess.run(["systemctl", "--user", "disable", service_name],
                         stderr=subprocess.DEVNULL)

            # Remove service file
            if os.path.exists(service_path):
                os.remove(service_path)

            # Reload systemd daemon
            subprocess.run(["systemctl", "--user", "daemon-reload"],
                         stderr=subprocess.DEVNULL)

            print(f"\n✓ Autostart disabled!")
            print(f"  Service stopped and removed: {service_name}")
            return True

        except Exception as e:
            print(f"\n✗ Error removing service: {e}")
            return False


def check_autostart_status():
    """
    Check if autostart is enabled
    """
    import subprocess

    service_name = "pc-monitor"

    try:
        result = subprocess.run(
            ["systemctl", "--user", "is-enabled", service_name],
            capture_output=True,
            text=True
        )
        return result.returncode == 0 and "enabled" in result.stdout.lower()
    except:
        return False


# ============================================================================
# GUI Configuration Mode (requires tkinter)
# ============================================================================

class MetricSelectorGUI:
    """
    Tkinter GUI for selecting metrics and configuring settings - Linux version
    Note: tkinter is imported when this class is instantiated (see main())
    """
    def __init__(self, root, existing_config=None):
        self.root = root
        self.root.title("PC Monitor v2.0 - Linux Configuration")
        self.root.geometry("1200x850")
        self.root.resizable(False, False)

        self.selected_metrics = []
        self.checkboxes = []
        self.label_entries = {}

        # Load existing config if available
        if existing_config:
            self.config = existing_config
        else:
            self.config = DEFAULT_CONFIG.copy()

        self.create_widgets()

        # Load existing selections if editing
        if existing_config and existing_config.get("metrics"):
            self.load_existing_metrics(existing_config["metrics"])

    def create_widgets(self):
        # Title
        title_frame = tk.Frame(self.root, bg="#1e1e1e", height=60)
        title_frame.pack(fill=tk.X)
        title_frame.pack_propagate(False)

        title_label = tk.Label(
            title_frame,
            text="PC Monitor Configuration - Linux",
            font=("Arial", 18, "bold"),
            bg="#1e1e1e",
            fg="#00d4ff"
        )
        title_label.pack(pady=15)

        # Settings frame (ESP IP, Port, Interval)
        settings_frame = tk.Frame(self.root, bg="#2d2d2d")
        settings_frame.pack(fill=tk.X, padx=10, pady=5)

        # ESP IP
        tk.Label(settings_frame, text="ESP32 IP:", bg="#2d2d2d", fg="#ffffff", font=("Arial", 10)).grid(row=0, column=0, padx=10, pady=5, sticky="e")
        self.ip_var = tk.StringVar(value=self.config.get("esp32_ip", "192.168.1.197"))
        tk.Entry(settings_frame, textvariable=self.ip_var, width=20).grid(row=0, column=1, padx=5, pady=5, sticky="w")

        # UDP Port
        tk.Label(settings_frame, text="UDP Port:", bg="#2d2d2d", fg="#ffffff", font=("Arial", 10)).grid(row=0, column=2, padx=10, pady=5, sticky="e")
        self.port_var = tk.StringVar(value=str(self.config.get("udp_port", 4210)))
        tk.Entry(settings_frame, textvariable=self.port_var, width=10).grid(row=0, column=3, padx=5, pady=5, sticky="w")

        # Update Interval
        tk.Label(settings_frame, text="Update Interval (seconds):", bg="#2d2d2d", fg="#ffffff", font=("Arial", 10)).grid(row=0, column=4, padx=10, pady=5, sticky="e")
        self.interval_var = tk.StringVar(value=str(self.config.get("update_interval", 3)))
        tk.Entry(settings_frame, textvariable=self.interval_var, width=10).grid(row=0, column=5, padx=5, pady=5, sticky="w")

        # Autostart section (second row)
        tk.Label(settings_frame, text="Systemd Autostart:", bg="#2d2d2d", fg="#ffffff", font=("Arial", 10)).grid(row=1, column=0, padx=10, pady=5, sticky="e")

        autostart_frame = tk.Frame(settings_frame, bg="#2d2d2d")
        autostart_frame.grid(row=1, column=1, columnspan=2, padx=5, pady=5, sticky="w")

        self.autostart_status = tk.Label(
            autostart_frame,
            text=self.get_autostart_status_text(),
            bg="#2d2d2d",
            fg=self.get_autostart_status_color(),
            font=("Arial", 10, "bold")
        )
        self.autostart_status.pack(side=tk.LEFT, padx=5)

        enable_btn = tk.Button(
            autostart_frame,
            text="Enable",
            command=self.enable_autostart,
            bg="#00d4ff",
            fg="#000000",
            font=("Arial", 9),
            relief=tk.FLAT,
            padx=10,
            pady=2
        )
        enable_btn.pack(side=tk.LEFT, padx=5)

        disable_btn = tk.Button(
            autostart_frame,
            text="Disable",
            command=self.disable_autostart,
            bg="#ff6666",
            fg="#000000",
            font=("Arial", 9),
            relief=tk.FLAT,
            padx=10,
            pady=2
        )
        disable_btn.pack(side=tk.LEFT, padx=5)

        # Counter frame
        counter_frame = tk.Frame(self.root, bg="#2d2d2d", height=50)
        counter_frame.pack(fill=tk.X)
        counter_frame.pack_propagate(False)

        self.counter_label = tk.Label(
            counter_frame,
            text=f"Selected: 0/{MAX_METRICS}",
            font=("Arial", 12),
            bg="#2d2d2d",
            fg="#ffffff"
        )
        self.counter_label.pack(side=tk.LEFT, padx=20, pady=10)

        # Search box
        search_label = tk.Label(counter_frame, text="Search:", bg="#2d2d2d", fg="#ffffff")
        search_label.pack(side=tk.LEFT, padx=(50, 5))

        self.search_var = tk.StringVar()
        self.search_var.trace_add('write', lambda *_: self.on_search())
        search_entry = tk.Entry(counter_frame, textvariable=self.search_var, width=20)
        search_entry.pack(side=tk.LEFT, padx=5)

        # Info note about static values
        info_label = tk.Label(
            counter_frame,
            text="ℹ Values are static from GUI launch",
            bg="#2d2d2d",
            fg="#888888",
            font=("Arial", 9, "italic")
        )
        info_label.pack(side=tk.LEFT, padx=(20, 0))

        # Buttons
        clear_btn = tk.Button(
            counter_frame,
            text="Clear All",
            command=self.clear_all,
            bg="#444444",
            fg="#ffffff",
            relief=tk.FLAT,
            padx=10
        )
        clear_btn.pack(side=tk.RIGHT, padx=20)

        # Main scrollable frame
        main_frame = tk.Frame(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

        canvas = tk.Canvas(main_frame, bg="#ffffff")
        scrollbar = ttk.Scrollbar(main_frame, orient="vertical", command=canvas.yview)
        scrollable_frame = tk.Frame(canvas, bg="#ffffff")

        scrollable_frame.bind(
            "<Configure>",
            lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
        )

        canvas.create_window((0, 0), window=scrollable_frame, anchor="nw")
        canvas.configure(yscrollcommand=scrollbar.set)

        canvas.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")

        # Create checkboxes by category
        row = 0
        col = 0

        categories = [
            ("SYSTEM METRICS", "system"),
            ("TEMPERATURES", "temperature"),
            ("FANS & COOLING", "fan"),
            ("NETWORK DATA", "data"),
            ("NETWORK THROUGHPUT", "throughput"),
            ("GPU METRICS", "gpu")
        ]

        for cat_title, cat_key in categories:
            if not sensor_database.get(cat_key):
                continue

            # Category header
            cat_frame = tk.Frame(scrollable_frame, bg="#f0f0f0", relief=tk.RIDGE, borderwidth=2)
            cat_frame.grid(row=row, column=col, sticky="nsew", padx=5, pady=5)

            cat_label = tk.Label(
                cat_frame,
                text=cat_title,
                font=("Arial", 11, "bold"),
                bg="#f0f0f0",
                fg="#333333"
            )
            cat_label.pack(pady=5)

            # Sensors in category
            for sensor in sensor_database[cat_key]:
                var = tk.BooleanVar()

                # Create sensor row frame
                sensor_frame = tk.Frame(cat_frame, bg="#f0f0f0")
                sensor_frame.pack(fill=tk.X, padx=10, pady=2)

                # Checkbox with current value
                value_text = f" - {sensor['current_value']}{sensor['unit']}" if sensor.get('current_value') is not None else ""
                cb = tk.Checkbutton(
                    sensor_frame,
                    text=f"{sensor['display_name']} ({sensor['name']}){value_text}",
                    variable=var,
                    bg="#f0f0f0",
                    anchor="w",
                    command=lambda s=sensor, v=var: self.on_checkbox_toggle(s, v)
                )
                cb.pack(side=tk.TOP, fill=tk.X)

                # Custom label entry (small, below checkbox)
                label_frame = tk.Frame(sensor_frame, bg="#f0f0f0")
                label_frame.pack(side=tk.TOP, fill=tk.X, padx=20)

                tk.Label(label_frame, text="Label:", bg="#f0f0f0", fg="#666", font=("Arial", 8)).pack(side=tk.LEFT)
                label_entry = tk.Entry(label_frame, width=15, font=("Arial", 8))
                label_entry.pack(side=tk.LEFT, padx=5)

                # Store reference to label entry
                sensor_key = f"{sensor['source']}_{sensor['name']}"
                self.label_entries[sensor_key] = label_entry

                self.checkboxes.append((cb, sensor, var, sensor_frame))

            col += 1
            if col >= 3:
                col = 0
                row += 1

        # Preview frame
        preview_frame = tk.Frame(self.root, bg="#2d2d2d", height=80)
        preview_frame.pack(fill=tk.X)
        preview_frame.pack_propagate(False)

        preview_label = tk.Label(
            preview_frame,
            text="SELECTED PREVIEW (names sent to ESP32):",
            font=("Arial", 9, "bold"),
            bg="#2d2d2d",
            fg="#888888"
        )
        preview_label.pack(anchor="w", padx=10, pady=(10, 0))

        self.preview_text = tk.Label(
            preview_frame,
            text="",
            font=("Courier", 9),
            bg="#2d2d2d",
            fg="#00ff00",
            anchor="w",
            justify=tk.LEFT
        )
        self.preview_text.pack(fill=tk.X, padx=10, pady=(0, 10))

        # Bottom buttons
        button_frame = tk.Frame(self.root, bg="#1e1e1e", height=60)
        button_frame.pack(fill=tk.X)
        button_frame.pack_propagate(False)

        cancel_btn = tk.Button(
            button_frame,
            text="Cancel",
            command=self.root.quit,
            bg="#666666",
            fg="#ffffff",
            font=("Arial", 12),
            relief=tk.FLAT,
            padx=20,
            pady=5
        )
        cancel_btn.pack(side=tk.LEFT, padx=20, pady=10)

        save_btn = tk.Button(
            button_frame,
            text="Save & Start Monitoring",
            command=self.save_and_start,
            bg="#00d4ff",
            fg="#000000",
            font=("Arial", 12, "bold"),
            relief=tk.FLAT,
            padx=20,
            pady=5
        )
        save_btn.pack(side=tk.RIGHT, padx=20, pady=10)

        # Update counter
        self.update_counter()

    def load_existing_metrics(self, metrics):
        """Load existing metric selections when editing config"""
        for metric in metrics:
            # Find matching sensor and check it
            for cb, sensor, var, frame in self.checkboxes:
                sensor_key = f"{sensor['source']}_{sensor['name']}"
                metric_key = f"{metric['source']}_{metric['name']}"

                if sensor_key == metric_key:
                    var.set(True)
                    self.selected_metrics.append(sensor)

                    # Set custom label if exists
                    if metric.get('custom_label') and sensor_key in self.label_entries:
                        self.label_entries[sensor_key].insert(0, metric['custom_label'])
                    break

        self.update_counter()

    def on_checkbox_toggle(self, sensor, var):
        if var.get():
            if len(self.selected_metrics) >= MAX_METRICS:
                messagebox.showwarning(
                    "Limit Reached",
                    f"Maximum {MAX_METRICS} metrics allowed!\nDeselect some metrics first."
                )
                var.set(False)
                return
            self.selected_metrics.append(sensor)
        else:
            if sensor in self.selected_metrics:
                self.selected_metrics.remove(sensor)

        self.update_counter()

    def update_counter(self):
        count = len(self.selected_metrics)
        self.counter_label.config(text=f"Selected: {count}/{MAX_METRICS}")

        if count >= MAX_METRICS:
            self.counter_label.config(fg="#ff6666")
        else:
            self.counter_label.config(fg="#ffffff")

        # Update preview
        preview = " | ".join([f"{i+1}. {m['name']}" for i, m in enumerate(self.selected_metrics[:MAX_METRICS])])
        self.preview_text.config(text=preview if preview else "(none selected)")

    def clear_all(self):
        for cb, sensor, var, frame in self.checkboxes:
            var.set(False)
        self.selected_metrics.clear()
        self.update_counter()

    def on_search(self, *args):
        search_term = self.search_var.get().lower()
        for cb, sensor, var, frame in self.checkboxes:
            if search_term in sensor['display_name'].lower() or search_term in sensor['name'].lower():
                cb.config(bg="#ffffcc")
                frame.config(bg="#ffffcc")
            else:
                cb.config(bg="#f0f0f0")
                frame.config(bg="#f0f0f0")

    def get_autostart_status_text(self):
        """Check if autostart is enabled"""
        if check_autostart_status():
            return "✓ Enabled"
        else:
            return "✗ Disabled"

    def get_autostart_status_color(self):
        """Get color for autostart status"""
        status = self.get_autostart_status_text()
        if "Enabled" in status:
            return "#00ff00"
        elif "Disabled" in status:
            return "#ff6666"
        else:
            return "#888888"

    def update_autostart_status(self):
        """Update the autostart status label"""
        self.autostart_status.config(
            text=self.get_autostart_status_text(),
            fg=self.get_autostart_status_color()
        )

    def enable_autostart(self):
        """Enable autostart via systemd"""
        try:
            success = setup_autostart_systemd(enable=True)
            if success:
                self.update_autostart_status()
                messagebox.showinfo("Success", "Autostart enabled!\n\nThe service will start automatically on system boot.\n\nUseful commands:\n• Check status: systemctl --user status pc-monitor\n• View logs: journalctl --user -u pc-monitor -f")
            else:
                messagebox.showerror("Error", "Failed to enable autostart.\nCheck console for details.")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to enable autostart:\n{str(e)}\n\nMake sure systemd is available on your system.")

    def disable_autostart(self):
        """Disable autostart via systemd"""
        try:
            success = setup_autostart_systemd(enable=False)
            if success:
                self.update_autostart_status()
                messagebox.showinfo("Success", "Autostart disabled!\n\nThe service has been stopped and removed.")
            else:
                messagebox.showwarning("Warning", "Could not disable autostart.\nCheck console for details.")
        except Exception as e:
            messagebox.showerror("Error", f"Failed to disable autostart:\n{str(e)}")

    def save_and_start(self):
        if len(self.selected_metrics) == 0:
            messagebox.showwarning("No Selection", "Please select at least one metric!")
            return

        # Validate settings
        try:
            esp_ip = self.ip_var.get().strip()
            udp_port = int(self.port_var.get())
            update_interval = float(self.interval_var.get())

            if not esp_ip:
                raise ValueError("ESP32 IP cannot be empty")
            if udp_port < 1 or udp_port > 65535:
                raise ValueError("Invalid port number")
            if update_interval < 0.5:
                raise ValueError("Update interval must be at least 0.5 seconds")
        except ValueError as e:
            messagebox.showerror("Invalid Settings", str(e))
            return

        # Build config
        config = {
            "version": "2.0-linux",
            "esp32_ip": esp_ip,
            "udp_port": udp_port,
            "update_interval": update_interval,
            "metrics": []
        }

        # Assign IDs and add custom labels
        for i, sensor in enumerate(self.selected_metrics):
            metric_config = sensor.copy()
            metric_config["id"] = i + 1

            # Get custom label if set
            sensor_key = f"{sensor['source']}_{sensor['name']}"
            if sensor_key in self.label_entries:
                custom_label = self.label_entries[sensor_key].get().strip()
                if custom_label:
                    metric_config["custom_label"] = custom_label[:10]  # Max 10 chars

            config["metrics"].append(metric_config)

        if save_config(config):
            messagebox.showinfo("Success", f"Configuration saved!\n{len(self.selected_metrics)} metrics will be monitored.")
            self.root.quit()
        else:
            messagebox.showerror("Error", "Failed to save configuration!")


# ============================================================================
# CLI Configuration Mode
# ============================================================================

def display_all_sensors_cli():
    """
    Display all available sensors with sequential numbering for CLI selection
    Returns a mapping of numbers to sensor objects
    """
    print("\n" + "=" * 70)
    print("  AVAILABLE METRICS")
    print("=" * 70)

    sensor_map = {}
    counter = 1

    categories = [
        ("SYSTEM METRICS", "system"),
        ("TEMPERATURES", "temperature"),
        ("FANS & COOLING", "fan"),
        ("NETWORK DATA", "data"),
        ("NETWORK THROUGHPUT", "throughput"),
        ("GPU METRICS", "gpu")
    ]

    for cat_title, cat_key in categories:
        sensors = sensor_database.get(cat_key, [])
        if not sensors:
            continue

        print(f"\n{cat_title}:")
        print("-" * 70)

        for sensor in sensors:
            # Format: [#] Display Name (short_name) - CurrentValue Unit
            value_str = f" - {sensor['current_value']}{sensor['unit']}" if sensor.get('current_value') is not None else ""
            print(f"  [{counter:2d}] {sensor['display_name']} ({sensor['name']}){value_str}")

            sensor_map[counter] = sensor
            counter += 1

    print("\n" + "=" * 70)
    print(f"Total available metrics: {len(sensor_map)}")
    print("=" * 70 + "\n")

    return sensor_map


def configure_cli_mode(existing_config=None):
    """
    CLI configuration mode for selecting metrics and settings
    Returns configuration dictionary or None if cancelled
    """
    print("\n" + "=" * 70)
    print("  CLI CONFIGURATION MODE")
    print("=" * 70)

    # Determine defaults from existing config or DEFAULT_CONFIG
    if existing_config:
        default_ip = existing_config.get("esp32_ip", DEFAULT_CONFIG["esp32_ip"])
        default_port = str(existing_config.get("udp_port", DEFAULT_CONFIG["udp_port"]))
        default_interval = str(existing_config.get("update_interval", DEFAULT_CONFIG["update_interval"]))
    else:
        default_ip = DEFAULT_CONFIG["esp32_ip"]
        default_port = str(DEFAULT_CONFIG["udp_port"])
        default_interval = str(DEFAULT_CONFIG["update_interval"])

    # Step 1: Configure ESP32 connection settings
    print("\nStep 1: ESP32 Connection Settings")
    print("-" * 70)

    esp_ip = prompt_with_default("ESP32 IP address", default_ip, validate_ip)
    if esp_ip is None:  # Cancelled
        return None

    port = prompt_with_default("UDP Port", default_port, validate_port)
    if port is None:  # Cancelled
        return None

    interval = prompt_with_default("Update Interval (seconds)", default_interval, validate_interval)
    if interval is None:  # Cancelled
        return None

    # Step 2: Metrics selection (check if editing existing config)
    print("\n" + "=" * 70)
    print("Step 2: Select Metrics to Monitor")
    print("=" * 70)

    selected_sensors = []
    keep_metrics = None  # Track if user wants to keep existing metrics

    # If editing existing config with metrics, show current selection
    if existing_config and existing_config.get("metrics"):
        print("\nCurrent metric selection:")
        print("-" * 70)
        for i, metric in enumerate(existing_config["metrics"]):
            label_info = f" - Label: \"{metric['custom_label']}\"" if metric.get('custom_label') else ""
            print(f"  {i+1}. {metric['display_name']} ({metric['name']}){label_info}")
        print("-" * 70)

        keep_metrics = input("\nKeep current metrics? (y/n) [y]: ").strip().lower()

        if keep_metrics in ['', 'y', 'yes']:
            # Keep existing metrics
            selected_sensors = existing_config["metrics"]
            print(f"\n✓ Keeping {len(selected_sensors)} existing metric(s)")
        else:
            # Re-select metrics
            print("\nRe-selecting metrics...")

    # If no existing metrics or user wants to re-select
    if not selected_sensors:
        sensor_map = display_all_sensors_cli()

        if not sensor_map:
            print("\n✗ No sensors found! Cannot continue.")
            return None

        # Step 3: Get metric selection
        print(f"Select up to {MAX_METRICS} metrics by entering their numbers separated by commas.")
        print(f"Example: 1,2,5,8")

        while True:
            try:
                selection = input(f"\nEnter metric numbers (comma-separated) [max {MAX_METRICS}]: ").strip()
                if not selection:
                    print("  ✗ Error: Please enter at least one metric number")
                    continue

                # Parse and validate
                numbers = parse_number_list(selection, len(sensor_map))

                # Get selected sensors
                selected_sensors = [sensor_map[num] for num in numbers]

                print(f"\n✓ Selected {len(selected_sensors)} metric(s)")
                break

            except ValueError as e:
                print(f"  ✗ Error: {e}")
                continue
            except KeyboardInterrupt:
                print("\n\nConfiguration cancelled.")
                return None

    # Step 3: Custom labels (only if newly selected metrics or user chose to re-select)
    custom_labels = {}
    kept_existing_metrics = existing_config and existing_config.get("metrics") and keep_metrics in ['', 'y', 'yes']

    if not kept_existing_metrics:
        print("\n" + "=" * 70)
        print("Step 3: Custom Labels (Optional)")
        print("=" * 70)
        print("You can assign custom labels (max 10 characters) to each metric.")
        print("Custom labels will be displayed on the ESP32 OLED.")

        configure_labels = input("\nConfigure custom labels? (y/n) [n]: ").strip().lower()

        if configure_labels in ['y', 'yes']:
            print("\nEnter custom label for each metric (press Enter to use default):\n")

            for i, sensor in enumerate(selected_sensors):
                default_name = sensor['name']
                label = input(f"  [{i+1}] {sensor['display_name']} (default: {default_name}): ").strip()

                if label:
                    # Truncate to 10 chars
                    label = label[:10]
                    sensor_key = f"{sensor['source']}_{sensor['name']}"
                    custom_labels[sensor_key] = label
                    print(f"      → Will use: '{label}'")
                else:
                    print(f"      → Will use default: '{default_name}'")

    # Step 4: Build configuration
    config = {
        "version": "2.0-linux",
        "esp32_ip": esp_ip,
        "udp_port": int(port),
        "update_interval": float(interval),
        "metrics": []
    }

    # Add metrics
    if kept_existing_metrics:
        # Keep existing metrics with their IDs and custom labels
        config["metrics"] = selected_sensors
    else:
        # Build new metrics with custom labels
        for i, sensor in enumerate(selected_sensors):
            metric_config = sensor.copy()
            metric_config["id"] = i + 1

            # Apply custom label if set
            sensor_key = f"{sensor['source']}_{sensor['name']}"
            if sensor_key in custom_labels:
                metric_config["custom_label"] = custom_labels[sensor_key]

            config["metrics"].append(metric_config)

    # Step 6: Show summary and confirm
    print("\n" + "=" * 70)
    print("  CONFIGURATION SUMMARY")
    print("=" * 70)
    print(f"\nESP32 IP:        {config['esp32_ip']}")
    print(f"UDP Port:        {config['udp_port']}")
    print(f"Update Interval: {config['update_interval']}s")
    print(f"\nSelected Metrics ({len(config['metrics'])}):")
    print("-" * 70)

    for metric in config["metrics"]:
        label_info = f" - Label: \"{metric['custom_label']}\"" if metric.get('custom_label') else ""
        print(f"  {metric['id']}. {metric['display_name']} ({metric['name']}){label_info}")

    print("=" * 70)

    confirm = input("\nSave and start monitoring? (y/n) [y]: ").strip().lower()
    if confirm in ['', 'y', 'yes']:
        if save_config(config):
            print("\n✓ Configuration saved successfully!")

            # Ask about autostart (systemd service)
            print("\n" + "=" * 70)
            print("  SYSTEMD AUTOSTART (OPTIONAL)")
            print("=" * 70)
            print("You can enable automatic monitoring on system boot using systemd.")
            print("This will create a user service that starts automatically.")

            # Check current autostart status
            if check_autostart_status():
                print("\nℹ  Autostart is currently: ENABLED")
                autostart_choice = input("Keep autostart enabled? (y/n) [y]: ").strip().lower()
                if autostart_choice not in ['', 'y', 'yes']:
                    # Disable autostart - then run script normally
                    print("\nDisabling autostart...")
                    if setup_autostart_systemd(False):
                        print("✓ Autostart disabled")
                    else:
                        print("✗ Failed to disable autostart")
                    print("\nStarting monitoring in foreground mode...")
                    return config  # Run monitoring normally
                else:
                    # Keep autostart enabled - start service and exit
                    print("\n✓ Autostart remains enabled")
                    print("\nStarting monitoring service...")
                    import subprocess
                    try:
                        subprocess.run(["systemctl", "--user", "start", "pc-monitor"], check=True)
                        print("✓ Monitoring service started successfully!")
                        print("\nThe service is now running in the background.")
                        print("\nUseful commands:")
                        print("  • Check status: systemctl --user status pc-monitor")
                        print("  • View logs:    journalctl --user -u pc-monitor -f")
                        print("  • Stop service: systemctl --user stop pc-monitor")
                        print("  • Restart:      systemctl --user restart pc-monitor")
                        print("\nExiting configuration...")
                        sys.exit(0)  # Exit cleanly
                    except subprocess.CalledProcessError:
                        print("✗ Failed to start service")
                        print("  Starting monitoring in foreground mode instead...")
                        return config  # Fallback to normal execution
            else:
                print("\nℹ  Autostart is currently: DISABLED")
                autostart_choice = input("Enable autostart? (y/n) [n]: ").strip().lower()
                if autostart_choice in ['y', 'yes']:
                    # Enable autostart - start service and exit
                    print("\nEnabling autostart...")
                    if setup_autostart_systemd(True):
                        print("✓ Autostart enabled successfully!")
                        print("\nStarting monitoring service...")
                        import subprocess
                        try:
                            subprocess.run(["systemctl", "--user", "start", "pc-monitor"], check=True)
                            print("✓ Monitoring service started successfully!")
                            print("\nThe service is now running in the background and will")
                            print("start automatically on system boot.")
                            print("\nUseful commands:")
                            print("  • Check status: systemctl --user status pc-monitor")
                            print("  • View logs:    journalctl --user -u pc-monitor -f")
                            print("  • Stop service: systemctl --user stop pc-monitor")
                            print("  • Restart:      systemctl --user restart pc-monitor")
                            print("\nExiting configuration...")
                            sys.exit(0)  # Exit cleanly
                        except subprocess.CalledProcessError:
                            print("✗ Failed to start service")
                            print("  Starting monitoring in foreground mode instead...")
                            return config  # Fallback to normal execution
                    else:
                        print("✗ Failed to enable autostart")
                        print("\nStarting monitoring in foreground mode...")
                        return config  # Run monitoring normally
                else:
                    # No autostart - run script normally
                    print("\nStarting monitoring in foreground mode...")
                    return config  # Run monitoring normally
        else:
            print("\n✗ Failed to save configuration!")
            return None
    else:
        print("\nConfiguration discarded.")
        return None


def get_metric_value(metric_config):
    """
    Get current value for a configured metric - Linux version
    """
    global network_last_sample, network_last_time

    source = metric_config["source"]

    if source == "psutil":
        method = metric_config["psutil_method"]

        if method == "cpu_percent":
            return int(psutil.cpu_percent(interval=0))
        elif method == "virtual_memory.percent":
            return int(psutil.virtual_memory().percent)
        elif method == "virtual_memory.used":
            return int(psutil.virtual_memory().used / (1024**3))  # GB
        elif method == "swap_memory.percent":
            return int(psutil.swap_memory().percent)
        elif method == "swap_memory.used":
            return int(psutil.swap_memory().used / (1024**3))  # GB
        elif method == "disk_usage":
            return int(psutil.disk_usage('/').percent)

    elif source == "psutil_temp":
        try:
            temps = psutil.sensors_temperatures()
            sensor_key = metric_config["sensor_key"]
            sensor_label = metric_config["sensor_label"]

            if sensor_key in temps:
                for entry in temps[sensor_key]:
                    if entry.label == sensor_label:
                        return int(entry.current)
        except:
            pass

    elif source == "psutil_fan":
        try:
            fans = psutil.sensors_fans()
            sensor_key = metric_config["sensor_key"]
            sensor_label = metric_config["sensor_label"]

            if sensor_key in fans:
                for entry in fans[sensor_key]:
                    if entry.label == sensor_label:
                        return int(entry.current)
        except:
            pass

    elif source == "psutil_net":
        try:
            net_io = psutil.net_io_counters(pernic=True)
            interface = metric_config["interface"]
            metric_name = metric_config["metric"]

            if interface in net_io:
                value = getattr(net_io[interface], metric_name)
                return int(value / (1024**2))  # Convert to MB
        except:
            pass

    elif source == "psutil_net_speed":
        try:
            current_time = time.time()
            net_io = psutil.net_io_counters(pernic=True)
            interface = metric_config["interface"]
            metric_name = metric_config["metric"]

            if interface in net_io:
                current_bytes = getattr(net_io[interface], metric_name)

                # Calculate speed if we have previous sample
                key = f"{interface}_{metric_name}"
                if key in network_last_sample and network_last_time:
                    time_delta = current_time - network_last_time
                    bytes_delta = current_bytes - network_last_sample[key]

                    if time_delta > 0:
                        # MB/s
                        speed = (bytes_delta / time_delta) / (1024**2)
                        return int(speed) if speed >= 1 else 0

                # Update last sample
                network_last_sample[key] = current_bytes

                return 0
        except:
            pass

    elif source == "nvml_gpu":
        try:
            import pynvml
            gpu_index = metric_config["gpu_index"]
            # Lazy-init: works even when monitoring starts from a saved config
            if gpu_index not in nvml_handles:
                if not nvml_handles:
                    pynvml.nvmlInit()
                nvml_handles[gpu_index] = pynvml.nvmlDeviceGetHandleByIndex(gpu_index)
            handle = nvml_handles[gpu_index]
            metric = metric_config["metric"]

            if metric == "utilization":
                return pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
            elif metric == "memory_used":
                return int(pynvml.nvmlDeviceGetMemoryInfo(handle).used / (1024 ** 2))
            elif metric == "memory_percent":
                info = pynvml.nvmlDeviceGetMemoryInfo(handle)
                return int(info.used * 100 / info.total) if info.total > 0 else 0
            elif metric == "clock_graphics":
                return pynvml.nvmlDeviceGetClockInfo(handle, pynvml.NVML_CLOCK_GRAPHICS)
            elif metric == "fan_speed":
                return pynvml.nvmlDeviceGetFanSpeed(handle)
            elif metric == "power_usage":
                return int(pynvml.nvmlDeviceGetPowerUsage(handle) / 1000)
            elif metric == "temperature":
                return pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
        except Exception:
            pass

    elif source == "amd_sysfs":
        try:
            metric      = metric_config["metric"]
            device_path = metric_config["device_path"]
            hwmon_path  = metric_config.get("hwmon_path")

            if metric == "gpu_busy_percent":
                with open(os.path.join(device_path, metric)) as f:
                    return int(f.read().strip())
            elif metric == "mem_info_vram_used":
                with open(os.path.join(device_path, metric)) as f:
                    return int(int(f.read().strip()) / (1024 ** 2))
            elif metric == "freq1_input":
                with open(os.path.join(hwmon_path, metric)) as f:
                    return int(f.read().strip()) // 1_000_000
            elif metric == "fan1_input":
                with open(os.path.join(hwmon_path, metric)) as f:
                    return int(f.read().strip())
            elif metric in ("power1_average", "power1_input"):
                with open(os.path.join(hwmon_path, metric)) as f:
                    return int(int(f.read().strip()) / 1_000_000)
            elif metric == "temp1_input":
                with open(os.path.join(hwmon_path, metric)) as f:
                    return int(f.read().strip()) // 1000
            elif metric == "mem_percent":
                used  = int(open(os.path.join(device_path, "mem_info_vram_used")).read().strip())
                total = int(open(os.path.join(device_path, "mem_info_vram_total")).read().strip())
                return int(used * 100 / total) if total > 0 else 0
        except Exception:
            pass

    return 0


def send_metrics(sock, config):
    """
    Collect metric values and send to ESP32 - Linux version
    """
    global network_last_time

    # Update network sample time
    network_last_time = time.time()

    # Build JSON payload
    payload = {
        "version": "2.0",
        "timestamp": datetime.now().strftime('%H:%M'),
        "metrics": []
    }

    for metric_config in config["metrics"]:
        value = get_metric_value(metric_config)

        # Use custom label if set, otherwise use generated name
        display_name = metric_config.get("custom_label", "")
        if not display_name:
            display_name = metric_config["name"]

        metric_data = {
            "id": metric_config["id"],
            "name": display_name,
            "value": value,
            "unit": metric_config["unit"]
        }
        payload["metrics"].append(metric_data)

    # Send via UDP
    try:
        message = json.dumps(payload).encode('utf-8')
        sock.sendto(message, (config["esp32_ip"], config["udp_port"]))

        # Print status
        timestamp = payload["timestamp"]
        metrics_str = " | ".join([f"{m['name']}:{m['value']}{m['unit']}" for m in payload["metrics"][:4]])
        if len(payload["metrics"]) > 4:
            metrics_str += f" ... +{len(payload['metrics'])-4} more"
        print(f"[{timestamp}] {metrics_str}")

        return True
    except Exception as e:
        print(f"Error sending data: {e}")
        return False


def run_monitoring(config):
    """Run monitoring loop in console mode - Linux version"""
    print(f"\nMonitoring {len(config['metrics'])} metrics:")
    for m in config["metrics"]:
        label_info = f" (Label: {m['custom_label']})" if m.get('custom_label') else ""
        print(f"  {m['id']}. {m['display_name']} ({m['name']}){label_info} - {m['source']}")

    print(f"\nESP32 IP: {config['esp32_ip']}")
    print(f"UDP Port: {config['udp_port']}")
    print(f"Update Interval: {config['update_interval']}s")
    print("\nStarting monitoring... (Press Ctrl+C to stop)\n")

    # Create UDP socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # Warm up psutil
    psutil.cpu_percent(interval=1)

    # Main monitoring loop
    try:
        while True:
            send_metrics(sock, config)
            time.sleep(config["update_interval"])
    except KeyboardInterrupt:
        print("\n\nMonitoring stopped.")
    finally:
        sock.close()


def main():
    """
    Main entry point - Linux version
    """
    # Parse command line arguments
    parser = argparse.ArgumentParser(description='PC Stats Monitor v2.0 - Linux Edition')
    parser.add_argument('--configure', action='store_true', help='Force configuration GUI')
    parser.add_argument('--edit', action='store_true', help='Edit existing configuration')
    parser.add_argument('--cli', '--nogui', action='store_true', dest='cli_mode',
                       help='Configure and run in CLI mode (no GUI required)')
    parser.add_argument('--autostart', choices=['enable', 'disable'], help='Enable/disable systemd autostart')
    args = parser.parse_args()

    # Handle autostart
    if args.autostart:
        try:
            success = setup_autostart_systemd(args.autostart == 'enable')
            if success and args.autostart == 'enable':
                print("\nTIP: The service will start automatically on system boot")
                print("     Use systemctl --user status pc-monitor to check status")
        except Exception as e:
            print(f"\n✗ Error setting up autostart: {e}")
            print("  Make sure systemd is available on your system")
        return

    print("\n" + "=" * 60)
    print("  PC STATS MONITOR v2.0 - LINUX EDITION")
    print("  Dynamic Sensor Monitoring with GUI Configuration")
    print("=" * 60 + "\n")

    # Check for config file
    config = load_config()

    # Determine if configuration is needed
    needs_config = args.configure or args.edit or config is None

    # Auto-detect headless environment (optional)
    if needs_config and not args.cli_mode:
        try:
            if not os.environ.get('DISPLAY'):
                print("\n⚠  No DISPLAY environment variable detected (headless system).")
                print("   Switching to CLI mode automatically.")
                print("   Use --configure to force GUI mode on systems with display.\n")
                args.cli_mode = True
        except:
            pass

    # Configuration mode
    if needs_config:
        if args.cli_mode:
            # CLI configuration mode
            if config is None:
                print("\nNo configuration found. Starting CLI configuration...")
            else:
                print("\nOpening CLI configuration editor...")

            # Discover sensors
            discover_sensors()

            # Run CLI configuration
            config = configure_cli_mode(config if args.edit else None)

            if config is None:
                print("\nConfiguration cancelled. Exiting.")
                return

        else:
            # GUI configuration mode
            if config is None:
                print("\nNo configuration found. Starting GUI...")
            else:
                print("\nOpening configuration editor...")

            # Import tkinter only when GUI mode is needed
            try:
                import tkinter as tk
                from tkinter import ttk, messagebox
            except ImportError:
                print("\n✗ Error: tkinter is not installed!")
                print("  On headless systems, use CLI mode instead:")
                print("  python3 pc_stats_monitor_v2_linux.py --cli")
                print("\n  To install tkinter:")
                print("  apt install python3-tk")
                return

            # Discover sensors
            discover_sensors()

            # Show GUI
            root = tk.Tk()
            app = MetricSelectorGUI(root, config if args.edit else None)
            root.mainloop()
            root.destroy()

            # Reload config after GUI
            config = load_config()
            if config is None:
                print("\nNo configuration saved. Exiting.")
                return

    # Validate config
    if not config.get("metrics"):
        print("\nNo metrics configured. Run with --edit to configure.")
        return

    # Run monitoring
    run_monitoring(config)


if __name__ == "__main__":
    main()