ui_main.py

from __future__ import annotations

from datetime import datetime
from pathlib import Path

from PySide6.QtCore import QProcess, QThread, QTimer, Qt, Signal, QSize
from PySide6.QtGui import QAction, QCloseEvent, QIcon, QResizeEvent, QShowEvent
from PySide6.QtWidgets import (
    QApplication,
    QButtonGroup,
    QFrame,
    QHBoxLayout,
    QHeaderView,
    QLabel,
    QMainWindow,
    QMenu,
    QMessageBox,
    QPushButton,
    QScrollArea,
    QSizePolicy,
    QStackedWidget,
    QSystemTrayIcon,
    QTableWidget,
    QTableWidgetItem,
    QTextEdit,
    QVBoxLayout,
    QWidget,
)

import apache_welcome
import package_manager
import port_scanner
import privileged
import service_assets
import service_manager
from port_scanner import Conflict, PortEntry
from service_manager import ServiceInfo

REFRESH_INTERVAL_MS = 1500
LOG_LIMIT = 200
ACTION_BTN_MARGIN_H = 5
ACTION_BTN_HEIGHT = 26
ACTION_ROW_HEIGHT = 52
STYLESHEET_PATH = Path(__file__).resolve().parent / "styles" / "dark.qss"
ICON_PATH = Path(__file__).resolve().parent / "assets" / "icons" / "amper.png"
ICONS_DIR = Path(__file__).resolve().parent / "assets" / "icons"

DEVELOPER_LINKS = [
    ("socialLinkedIn", "social-linkedin.svg", "LinkedIn", "https://www.linkedin.com/in/hesham-yasser-78673831b/"),
    ("socialX", "social-x.svg", "X", "https://x.com/HaSh_Perfecto"),
    ("socialGitHub", "social-github.svg", "GitHub", "https://github.com/HaSh3003"),
]

def load_stylesheet() -> str:
    if STYLESHEET_PATH.is_file():
        return STYLESHEET_PATH.read_text(encoding="utf-8")
    return ""


def load_app_icon() -> QIcon:
    if ICON_PATH.is_file():
        return QIcon(str(ICON_PATH))
    return QIcon()


def _social_button(object_name: str, icon_file: str, tooltip: str, url: str) -> QPushButton:
    button = QPushButton()
    button.setObjectName(object_name)
    icon_path = ICONS_DIR / icon_file
    if icon_path.is_file():
        button.setIcon(QIcon(str(icon_path)))
    button.setIconSize(QSize(22, 22))
    button.setFixedSize(42, 42)
    button.setToolTip(tooltip)
    button.setCursor(Qt.CursorShape.PointingHandCursor)
    button.clicked.connect(lambda: service_assets.open_url(url))
    return button


def _action_button(object_name: str, label: str, tooltip: str) -> QPushButton:
    button = QPushButton(label)
    button.setObjectName(object_name)
    button.setToolTip(tooltip)
    button.setCursor(Qt.CursorShape.PointingHandCursor)
    button.setFixedHeight(ACTION_BTN_HEIGHT)
    button.setMinimumWidth(56)
    button.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
    return button


def _make_transparent(widget: QWidget) -> QWidget:
    widget.setAutoFillBackground(False)
    widget.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground, True)
    return widget


def _action_button_slot(button: QPushButton) -> QWidget:
    slot = _make_transparent(QWidget())
    slot.setObjectName("actionBtnSlot")
    slot.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
    slot_layout = QHBoxLayout(slot)
    slot_layout.setContentsMargins(ACTION_BTN_MARGIN_H, 0, ACTION_BTN_MARGIN_H, 0)
    slot_layout.setSpacing(0)
    slot_layout.addWidget(button)
    return slot


class ModuleRowActions(QWidget):
    action_requested = Signal(str, str)
    file_open_requested = Signal(str, str)
    url_open_requested = Signal(str, str)
    package_requested = Signal(str, str)

    def __init__(self, service: ServiceInfo, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        self.service = service
        self.unit = service.unit
        self.service_key = service.key
        self.setObjectName("moduleRowActions")
        _make_transparent(self)
        layout = QHBoxLayout(self)
        layout.setContentsMargins(6, 8, 6, 8)
        layout.setSpacing(0)
        self.btn_install = _action_button("btnInstall", "Install", "Install this module")
        self.btn_uninstall = _action_button("btnUninstall", "Remove", "Uninstall this module")
        self.btn_start = _action_button("btnStart", "Start", "Start this service")
        self.btn_stop = _action_button("btnStop", "Stop", "Stop this service")
        self.btn_admin = _action_button("btnAdmin", "Admin", "Open web admin in browser")
        self.btn_config = _action_button("btnConfig", "Config", "Open configuration files")
        self.btn_logs = _action_button("btnLogs", "Logs", "Open log files")
        self._action_buttons = (
            self.btn_install,
            self.btn_uninstall,
            self.btn_start,
            self.btn_stop,
            self.btn_admin,
            self.btn_config,
            self.btn_logs,
        )
        self.btn_install.clicked.connect(
            lambda: self.package_requested.emit(self.service_key, "install")
        )
        self.btn_uninstall.clicked.connect(self._request_uninstall)
        self.btn_start.clicked.connect(lambda: self.action_requested.emit(self.unit, "start"))
        self.btn_stop.clicked.connect(lambda: self.action_requested.emit(self.unit, "stop"))
        self.btn_admin.clicked.connect(self._open_admin)
        self.btn_config.clicked.connect(self._show_config_menu)
        self.btn_logs.clicked.connect(self._show_logs_menu)
        for button in self._action_buttons:
            layout.addWidget(_action_button_slot(button))
        layout.addStretch()
        self.setMinimumHeight(ACTION_ROW_HEIGHT)
        self.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
        self.config_menu = QMenu(self)
        self.logs_menu = QMenu(self)
        self._assets = service_assets.get_assets(self.service_key)
        self._rebuild_asset_menus()

    def _rebuild_asset_menus(self) -> None:
        self.config_menu.clear()
        self.logs_menu.clear()
        assets = service_assets.get_assets(self.service_key)
        for link in assets.configs:
            action = self.config_menu.addAction(link.label)
            action.setData(link.path)
        for link in assets.logs:
            action = self.logs_menu.addAction(link.label)
            action.setData(link.path)
        self._assets = assets

    def _request_uninstall(self) -> None:
        label = self.service.label
        command = package_manager.build_uninstall_command(self.service_key)
        packages = ", ".join(command.packages) if command else self.service_key
        reply = QMessageBox.warning(
            self.window(),
            "Confirm Uninstall",
            f"Are you sure you want to uninstall {label}?\n\n"
            f"Packages to remove:\n{packages}\n\n"
            "This will delete the module from your system.",
            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
            QMessageBox.StandardButton.No,
        )
        if reply == QMessageBox.StandardButton.Yes:
            self.package_requested.emit(self.service_key, "uninstall")

    def _open_admin(self) -> None:
        if self._assets.admin_url:
            self.url_open_requested.emit(self.service_key, self._assets.admin_url)

    def _show_config_menu(self) -> None:
        if self.config_menu.isEmpty():
            return
        self.config_menu.exec(self.btn_config.mapToGlobal(self.btn_config.rect().bottomLeft()))

    def _show_logs_menu(self) -> None:
        if self.logs_menu.isEmpty():
            return
        self.logs_menu.exec(self.btn_logs.mapToGlobal(self.btn_logs.rect().bottomLeft()))

    def connect_menus(self) -> None:
        self.config_menu.triggered.connect(self._on_config_selected)
        self.logs_menu.triggered.connect(self._on_log_selected)

    def _on_config_selected(self, action: QAction) -> None:
        path = action.data()
        if isinstance(path, str):
            self.file_open_requested.emit(self.service_key, path)

    def _on_log_selected(self, action: QAction) -> None:
        path = action.data()
        if isinstance(path, str):
            self.file_open_requested.emit(self.service_key, path)

    def update_state(
        self,
        service: ServiceInfo,
        pending: bool,
        package_pending: bool,
    ) -> None:
        self.service = service
        assets = service_assets.get_assets(self.service_key)
        self._assets = assets
        manageable = package_manager.can_manage_packages(self.service_key)
        busy = pending or package_pending
        self.btn_install.setEnabled(manageable and not service.available and not package_pending)
        self.btn_uninstall.setEnabled(manageable and service.available and not package_pending)
        if not service.available:
            self.btn_start.setEnabled(False)
            self.btn_stop.setEnabled(False)
            self.btn_admin.setEnabled(False)
            self.btn_config.setEnabled(False)
            self.btn_logs.setEnabled(False)
            return
        self.btn_config.setEnabled(bool(assets.configs) and not package_pending)
        self.btn_logs.setEnabled(bool(assets.logs) and not package_pending)
        self.btn_admin.setEnabled(bool(assets.admin_url) and not package_pending)
        if not service.controllable:
            self.btn_start.setEnabled(False)
            self.btn_stop.setEnabled(False)
            return
        is_active = service.state == "active"
        self.btn_start.setEnabled(not busy and not is_active)
        self.btn_stop.setEnabled(not busy and is_active)


class ModulesDashboard(QFrame):
    action_requested = Signal(str, str)
    file_open_requested = Signal(str, str)
    url_open_requested = Signal(str, str)
    package_requested = Signal(str, str)

    def __init__(self, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        self.setObjectName("contentPanel")
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(12)
        header = QHBoxLayout()
        title = QLabel("Linux Services")
        title.setObjectName("pageTitle")
        subtitle = QLabel("Manage Apache, databases, and other systemd modules")
        subtitle.setObjectName("pageSubtitle")
        header_col = QVBoxLayout()
        header_col.setSpacing(2)
        header_col.addWidget(title)
        header_col.addWidget(subtitle)
        header.addLayout(header_col)
        header.addStretch()
        layout.addLayout(header)
        self.table = QTableWidget(0, 5)
        self.table.setObjectName("modulesTable")
        self.table.setHorizontalHeaderLabels(
            ["Module", "Status", "PID", "Port", "Actions"]
        )
        self.table.setAlternatingRowColors(True)
        self.table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
        self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
        self.table.verticalHeader().setVisible(False)
        self.table.verticalHeader().setDefaultSectionSize(ACTION_ROW_HEIGHT)
        self.table.setShowGrid(True)
        header_view = self.table.horizontalHeader()
        header_view.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
        header_view.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
        header_view.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
        header_view.setSectionResizeMode(3, QHeaderView.ResizeMode.Stretch)
        header_view.setSectionResizeMode(4, QHeaderView.ResizeMode.Fixed)
        self.table.setColumnWidth(4, 640)
        self.table.viewport().setAutoFillBackground(False)
        layout.addWidget(self.table)
        self.action_widgets: dict[str, ModuleRowActions] = {}

    def rebuild(self, services: list[ServiceInfo]) -> None:
        self.table.setRowCount(len(services))
        self.action_widgets.clear()
        for row, service in enumerate(services):
            module_item = QTableWidgetItem(service.label)
            module_item.setFlags(module_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            self.table.setItem(row, 0, module_item)
            status_item = QTableWidgetItem(self._status_text(service))
            status_item.setFlags(status_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            status_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self._apply_status_style(status_item, service, False)
            self.table.setItem(row, 1, status_item)
            pid_item = QTableWidgetItem(self._pid_text(service))
            pid_item.setFlags(pid_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            pid_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
            self.table.setItem(row, 2, pid_item)
            port_item = QTableWidgetItem(self._default_port_text(service))
            port_item.setFlags(port_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
            self.table.setItem(row, 3, port_item)
            actions = ModuleRowActions(service)
            actions.action_requested.connect(self.action_requested.emit)
            actions.file_open_requested.connect(self.file_open_requested.emit)
            actions.url_open_requested.connect(self.url_open_requested.emit)
            actions.package_requested.connect(self.package_requested.emit)
            actions.connect_menus()
            actions.update_state(service, False, False)
            self.table.setCellWidget(row, 4, actions)
            key = service.key if service.key else service.unit
            self.action_widgets[key] = actions
            self.table.setRowHeight(row, ACTION_ROW_HEIGHT)

    def update_services(
        self,
        services: list[ServiceInfo],
        ports: list[PortEntry],
        pending_units: set[str],
        pending_packages: set[str],
    ) -> None:
        for row, service in enumerate(services):
            if row >= self.table.rowCount():
                break
            status_item = self.table.item(row, 1)
            pid_item = self.table.item(row, 2)
            port_item = self.table.item(row, 3)
            if status_item is not None:
                status_item.setText(self._status_text(service))
                pending = service.unit in pending_units if service.unit else False
                self._apply_status_style(status_item, service, pending)
            if pid_item is not None:
                pid_item.setText(self._pid_text(service))
            if port_item is not None:
                active_ports = port_scanner.get_ports_for_service(service, ports)
                port_item.setText(self._port_text(service, active_ports))
            key = service.key if service.key else service.unit
            actions = self.action_widgets.get(key)
            if actions is not None:
                pending = service.unit in pending_units if service.unit else False
                package_pending = service.key in pending_packages
                actions.update_state(service, pending, package_pending)

    def _status_text(self, service: ServiceInfo) -> str:
        if not service.available:
            return "Not Installed"
        if service.key == "php" and service.state == "active":
            return "Ready"
        if service.state == "active":
            return "Running"
        if service.state in {"inactive", "dead"}:
            return "Stopped"
        if service.state == "failed":
            return "Failed"
        return service.state.capitalize()

    def _pid_text(self, service: ServiceInfo) -> str:
        if not service.available or service.main_pid <= 0:
            return "—"
        return str(service.main_pid)

    def _default_port_text(self, service: ServiceInfo) -> str:
        if service.ports:
            return ", ".join(str(port) for port in service.ports)
        return "—"

    def _port_text(self, service: ServiceInfo, active_ports: list[int]) -> str:
        if active_ports:
            return ", ".join(str(port) for port in active_ports)
        if service.state == "active" and service.ports:
            return ", ".join(str(port) for port in service.ports)
        if service.ports:
            return ", ".join(str(port) for port in service.ports)
        return "—"

    def _apply_status_style(
        self,
        item: QTableWidgetItem,
        service: ServiceInfo,
        pending: bool,
    ) -> None:
        if not service.available:
            item.setForeground(Qt.GlobalColor.gray)
            return
        if pending:
            item.setForeground(Qt.GlobalColor.magenta)
            return
        if service.state == "active":
            item.setForeground(Qt.GlobalColor.green)
            return
        if service.state == "failed":
            item.setForeground(Qt.GlobalColor.red)
            return
        item.setForeground(Qt.GlobalColor.red)


class PortMonitorPanel(QFrame):
    def __init__(self, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        self.setObjectName("contentPanel")
        layout = QVBoxLayout(self)
        layout.setContentsMargins(20, 20, 20, 20)
        layout.setSpacing(12)
        header = QHBoxLayout()
        title = QLabel("Network Ports")
        title.setObjectName("pageTitle")
        subtitle = QLabel("Live view of listening ports and conflicts")
        subtitle.setObjectName("pageSubtitle")
        header_col = QVBoxLayout()
        header_col.setSpacing(2)
        header_col.addWidget(title)
        header_col.addWidget(subtitle)
        header.addLayout(header_col)
        header.addStretch()
        layout.addLayout(header)
        self.table = QTableWidget(0, 5)
        self.table.setObjectName("netTable")
        self.table.setHorizontalHeaderLabels(
            ["PORT", "PID", "PROCESS", "ADDR", "CONFLICT"]
        )
        self.table.setAlternatingRowColors(True)
        self.table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
        self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
        self.table.verticalHeader().setVisible(False)
        header_view = self.table.horizontalHeader()
        header_view.setSectionResizeMode(0, QHeaderView.ResizeMode.ResizeToContents)
        header_view.setSectionResizeMode(1, QHeaderView.ResizeMode.ResizeToContents)
        header_view.setSectionResizeMode(2, QHeaderView.ResizeMode.Stretch)
        header_view.setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)
        header_view.setSectionResizeMode(4, QHeaderView.ResizeMode.Stretch)
        self.table.viewport().setAutoFillBackground(False)
        layout.addWidget(self.table)

    def update_ports(self, ports: list[PortEntry], conflicts: list[Conflict]) -> None:
        conflict_ports = port_scanner.conflict_port_set(conflicts)
        self.table.setRowCount(len(ports))
        for row, entry in enumerate(ports):
            conflict_text = ""
            if entry.port in conflict_ports:
                conflict_text = port_scanner.conflict_labels_for_port(entry.port, conflicts)
            values = [
                str(entry.port),
                str(entry.pid) if entry.pid else "—",
                entry.process_name or "—",
                entry.address or "—",
                conflict_text or "—",
            ]
            for column, value in enumerate(values):
                item = QTableWidgetItem(value)
                if conflict_text:
                    item.setForeground(Qt.GlobalColor.red)
                self.table.setItem(row, column, item)


class AboutPanel(QFrame):
    def __init__(self, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        self.setObjectName("contentPanel")
        outer = QVBoxLayout(self)
        outer.setContentsMargins(0, 0, 0, 0)
        scroll = QScrollArea()
        scroll.setObjectName("aboutScroll")
        scroll.setWidgetResizable(True)
        scroll.setFrameShape(QFrame.Shape.NoFrame)
        scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        scroll_host = QWidget()
        scroll_host.setObjectName("aboutScrollHost")
        scroll_layout = QVBoxLayout(scroll_host)
        scroll_layout.setContentsMargins(20, 20, 20, 20)
        scroll_layout.addStretch()
        card = QFrame()
        card.setObjectName("aboutCard")
        card_layout = QVBoxLayout(card)
        card_layout.setContentsMargins(40, 40, 40, 40)
        card_layout.setSpacing(14)
        card_layout.setAlignment(Qt.AlignmentFlag.AlignCenter)
        icon_label = QLabel()
        icon_label.setObjectName("aboutIcon")
        icon_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        app_icon = load_app_icon()
        if not app_icon.isNull():
            icon_label.setPixmap(app_icon.pixmap(96, 96))
        title = QLabel("Amper")
        title.setObjectName("aboutTitle")
        title.setAlignment(Qt.AlignmentFlag.AlignCenter)
        subtitle = QLabel("Linux Control Panel")
        subtitle.setObjectName("aboutSubtitle")
        subtitle.setAlignment(Qt.AlignmentFlag.AlignCenter)
        body = QTextEdit()
        body.setObjectName("aboutBody")
        body.setReadOnly(True)
        body.setFrameShape(QFrame.Shape.NoFrame)
        body.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        body.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
        body.setPlainText(
            "Amper is an open-source desktop control panel for Linux.\n\n"
            "Manage Apache, PHP, MySQL, phpMyAdmin, and other systemd services "
            "from one place. Monitor ports, edit configs, view logs, and install "
            "or remove modules with your system package manager."
        )
        body.setLineWrapMode(QTextEdit.LineWrapMode.WidgetWidth)
        body.document().setDocumentMargin(4)
        body.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum)
        self.about_body = body
        version = QLabel("Version 1.0")
        version.setObjectName("aboutVersion")
        version.setAlignment(Qt.AlignmentFlag.AlignCenter)
        copyright_label = QLabel("Copyright © 2026 Amper Linux Control Panel")
        copyright_label.setObjectName("aboutCopyright")
        copyright_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        dev_divider = QFrame()
        dev_divider.setObjectName("aboutDivider")
        dev_divider.setFixedHeight(1)
        dev_heading = QLabel("About Developer")
        dev_heading.setObjectName("aboutDevHeading")
        dev_heading.setAlignment(Qt.AlignmentFlag.AlignCenter)
        dev_name = QLabel("Hesham Yasser")
        dev_name.setObjectName("aboutDevName")
        dev_name.setAlignment(Qt.AlignmentFlag.AlignCenter)
        dev_role = QLabel("Software Engineer")
        dev_role.setObjectName("aboutDevRole")
        dev_role.setAlignment(Qt.AlignmentFlag.AlignCenter)
        social_row = QHBoxLayout()
        social_row.setSpacing(0)
        social_row.setContentsMargins(0, 8, 0, 8)
        social_row.setAlignment(Qt.AlignmentFlag.AlignCenter)
        for object_name, icon_file, tooltip, url in DEVELOPER_LINKS:
            social_row.addWidget(_social_button(object_name, icon_file, tooltip, url))
        social_host = QWidget()
        social_host.setLayout(social_row)
        self.perm_status = QLabel()
        self.perm_status.setObjectName("aboutPermStatus")
        self.perm_status.setAlignment(Qt.AlignmentFlag.AlignCenter)
        self.perm_status.setWordWrap(True)
        self.btn_grant_perms = QPushButton("Grant Permissions (once)")
        self.btn_grant_perms.setObjectName("btnGrantPerms")
        self.btn_grant_perms.setCursor(Qt.CursorShape.PointingHandCursor)
        self.btn_grant_perms.clicked.connect(self._grant_permissions)
        self._refresh_permission_status()
        card_layout.addWidget(icon_label)
        card_layout.addWidget(title)
        card_layout.addWidget(subtitle)
        card_layout.addWidget(body)
        card_layout.addWidget(version)
        card_layout.addWidget(copyright_label)
        card_layout.addWidget(dev_divider)
        card_layout.addWidget(dev_heading)
        card_layout.addWidget(dev_name)
        card_layout.addWidget(dev_role)
        card_layout.addWidget(social_host)
        card_layout.addWidget(self.perm_status)
        card_layout.addWidget(self.btn_grant_perms)
        scroll_layout.addWidget(card, alignment=Qt.AlignmentFlag.AlignHCenter)
        scroll_layout.addStretch()
        scroll.setWidget(scroll_host)
        outer.addWidget(scroll)
        QTimer.singleShot(0, self._sync_about_body_height)

    def showEvent(self, event: QShowEvent) -> None:
        super().showEvent(event)
        self._sync_about_body_height()

    def resizeEvent(self, event: QResizeEvent) -> None:
        super().resizeEvent(event)
        self._sync_about_body_height()

    def _sync_about_body_height(self) -> None:
        body = self.about_body
        width = max(body.viewport().width(), 400)
        body.document().setTextWidth(width)
        height = int(body.document().size().height()) + 16
        body.setFixedHeight(max(100, height))

    def _refresh_permission_status(self) -> None:
        if privileged.is_ready():
            self.perm_status.setText("Permissions active — actions run without password prompts.")
            self.btn_grant_perms.setEnabled(False)
            self.btn_grant_perms.hide()
        else:
            self.perm_status.setText(
                "One-time setup required. Click below and enter your password once. "
                "After that, Start, Stop, Install, and Remove work without prompts."
            )
            self.btn_grant_perms.setEnabled(True)
            self.btn_grant_perms.show()

    def _grant_permissions(self) -> None:
        script = privileged.setup_script_path()
        if not script.is_file():
            return
        process = QProcess(self)
        process.setProgram("pkexec")
        process.setArguments(["bash", str(script)])
        process.finished.connect(self._on_permissions_setup_finished)
        process.start()

    def _on_permissions_setup_finished(self, exit_code: int, _status: QProcess.ExitStatus) -> None:
        self._refresh_permission_status()
        window = self.window()
        if isinstance(window, MainWindow):
            if exit_code == 0:
                window._log("Permissions installed. Log out and back in, or run: newgrp amper")
            else:
                window._log("Permission setup failed or was cancelled")


class SidebarNav(QFrame):
    page_changed = Signal(int)

    def __init__(self, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        self.setObjectName("sidebar")
        self.setFixedWidth(168)
        layout = QVBoxLayout(self)
        layout.setContentsMargins(0, 16, 0, 16)
        layout.setSpacing(4)
        brand = QLabel("Control Panel")
        brand.setObjectName("sidebarBrand")
        brand.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(brand)
        layout.addSpacing(12)
        self.button_group = QButtonGroup(self)
        self.button_group.setExclusive(True)
        self.btn_linux = QPushButton("Linux")
        self.btn_linux.setObjectName("navButton")
        self.btn_linux.setCheckable(True)
        self.btn_linux.setChecked(True)
        self.btn_net = QPushButton("Net")
        self.btn_net.setObjectName("navButton")
        self.btn_net.setCheckable(True)
        self.btn_about = QPushButton("About")
        self.btn_about.setObjectName("navButton")
        self.btn_about.setCheckable(True)
        self.button_group.addButton(self.btn_linux, 0)
        self.button_group.addButton(self.btn_net, 1)
        self.button_group.addButton(self.btn_about, 2)
        layout.addWidget(self.btn_linux)
        layout.addWidget(self.btn_net)
        layout.addWidget(self.btn_about)
        layout.addStretch()
        version = QLabel("v1.0")
        version.setObjectName("sidebarVersion")
        version.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(version)
        self.button_group.idClicked.connect(self.page_changed.emit)


class ActivityLogPanel(QFrame):
    def __init__(self, parent: QWidget | None = None) -> None:
        super().__init__(parent)
        self.setObjectName("activityLog")
        self.setFixedHeight(130)
        layout = QVBoxLayout(self)
        layout.setContentsMargins(16, 10, 16, 10)
        layout.setSpacing(6)
        title = QLabel("Activity Log")
        title.setObjectName("logTitle")
        layout.addWidget(title)
        self.text = QTextEdit()
        self.text.setObjectName("logText")
        self.text.setReadOnly(True)
        self.text.setPlaceholderText("Service changes will appear here...")
        layout.addWidget(self.text)
        self._lines: list[str] = []

    def append(self, message: str) -> None:
        stamp = datetime.now().strftime("%H:%M:%S")
        line = f"[{stamp}] {message}"
        self._lines.append(line)
        if len(self._lines) > LOG_LIMIT:
            self._lines = self._lines[-LOG_LIMIT:]
        self.text.setPlainText("\n".join(self._lines))
        scrollbar = self.text.verticalScrollBar()
        scrollbar.setValue(scrollbar.maximum())


class WelcomeDeployWorker(QThread):
    finished = Signal(bool, str, str)

    def run(self) -> None:
        ok, root, message = apache_welcome.sync_welcome_if_needed()
        self.finished.emit(ok, root, message)


class SystemTrayManager:
    def __init__(self, window: QMainWindow) -> None:
        self.window = window
        self.tray: QSystemTrayIcon | None = None
        self.menu = QMenu()
        self.show_action = QAction("Show Amper", self.menu)
        self.hide_action = QAction("Hide Amper", self.menu)
        self.quit_action = QAction("Quit", self.menu)
        self.service_actions: dict[str, dict[str, QAction]] = {}
        self.show_action.triggered.connect(self._show_window)
        self.hide_action.triggered.connect(self._hide_window)
        self.quit_action.triggered.connect(QApplication.quit)
        self.menu.addAction(self.show_action)
        self.menu.addAction(self.hide_action)
        self.menu.addSeparator()
        self.quit_action.setMenuRole(QAction.MenuRole.QuitRole)
        self.menu.addAction(self.quit_action)
        if QSystemTrayIcon.isSystemTrayAvailable():
            self.tray = QSystemTrayIcon(self.window)
            app_icon = load_app_icon()
            if not app_icon.isNull():
                self.tray.setIcon(app_icon)
            self.tray.setToolTip("Amper Linux Control Panel")
            self.tray.setContextMenu(self.menu)
            self.tray.activated.connect(self._on_activated)
            self.tray.show()

    def is_available(self) -> bool:
        return self.tray is not None

    def rebuild_service_menu(self, services: list[ServiceInfo]) -> None:
        for actions in self.service_actions.values():
            menu_action = actions.get("menu")
            if menu_action is not None:
                self.menu.removeAction(menu_action)
                menu_action.deleteLater()
        self.service_actions.clear()
        for action in list(self.menu.actions()):
            if action not in {self.show_action, self.hide_action, self.quit_action}:
                self.menu.removeAction(action)
                if action.menu() is not None:
                    action.menu().deleteLater()
                action.deleteLater()
        controllable = [
            service for service in services if service.available and service.controllable and service.unit
        ]
        if controllable:
            self.menu.insertSeparator(self.quit_action)
        for service in controllable:
            submenu = QMenu(service.label, self.menu)
            start_action = submenu.addAction("Start")
            stop_action = submenu.addAction("Stop")
            restart_action = submenu.addAction("Restart")
            start_action.setData(("action", service.unit, "start"))
            stop_action.setData(("action", service.unit, "stop"))
            restart_action.setData(("action", service.unit, "restart"))
            menu_action = self.menu.insertMenu(self.quit_action, submenu)
            self.service_actions[service.unit] = {
                "start": start_action,
                "stop": stop_action,
                "restart": restart_action,
                "menu": menu_action,
            }

    def update_service_states(self, services: list[ServiceInfo], pending_units: set[str]) -> None:
        for service in services:
            actions = self.service_actions.get(service.unit)
            if actions is None:
                continue
            busy = service.unit in pending_units
            is_active = service.state == "active"
            actions["start"].setEnabled(not busy and not is_active)
            actions["stop"].setEnabled(not busy and is_active)
            actions["restart"].setEnabled(not busy and is_active)

    def connect_action_handler(self, handler) -> None:
        self.menu.triggered.connect(handler)

    def _show_window(self) -> None:
        self.window.showNormal()
        self.window.raise_()
        self.window.activateWindow()

    def _hide_window(self) -> None:
        self.window.hide()

    def _on_activated(self, reason: QSystemTrayIcon.ActivationReason) -> None:
        if reason == QSystemTrayIcon.ActivationReason.DoubleClick:
            if self.window.isVisible():
                self._hide_window()
            else:
                self._show_window()


class MainWindow(QMainWindow):
    def __init__(self) -> None:
        super().__init__()
        self.setWindowTitle("Amper Linux Control Panel")
        app_icon = load_app_icon()
        if not app_icon.isNull():
            self.setWindowIcon(app_icon)
        self.resize(1100, 620)
        self.setMinimumSize(980, 520)
        self.services: list[ServiceInfo] = []
        self.pending_units: set[str] = set()
        self.pending_packages: set[str] = set()
        self.pending_actions: dict[str, str] = {}
        self.processes: dict[str, QProcess] = {}
        self.package_processes: dict[str, QProcess] = {}
        self.previous_states: dict[str, str] = {}
        self.welcome_worker: WelcomeDeployWorker | None = None
        central = QWidget()
        central.setObjectName("appRoot")
        self.setCentralWidget(central)
        root = QVBoxLayout(central)
        root.setContentsMargins(0, 0, 0, 0)
        root.setSpacing(0)
        banner = QFrame()
        banner.setObjectName("xamppBanner")
        banner_layout = QHBoxLayout(banner)
        banner_layout.setContentsMargins(20, 12, 20, 12)
        banner_title = QLabel("Amper")
        banner_title.setObjectName("bannerTitle")
        banner_subtitle = QLabel("Linux Control Panel")
        banner_subtitle.setObjectName("bannerSubtitle")
        banner_layout.addWidget(banner_title)
        banner_layout.addWidget(banner_subtitle)
        banner_layout.addStretch()
        root.addWidget(banner)
        workspace = QWidget()
        workspace_layout = QHBoxLayout(workspace)
        workspace_layout.setContentsMargins(0, 0, 0, 0)
        workspace_layout.setSpacing(0)
        self.sidebar = SidebarNav()
        self.sidebar.page_changed.connect(self._switch_page)
        workspace_layout.addWidget(self.sidebar)
        content_host = QWidget()
        content_host.setObjectName("workspace")
        content_layout = QVBoxLayout(content_host)
        content_layout.setContentsMargins(0, 0, 0, 0)
        content_layout.setSpacing(0)
        self.pages = QStackedWidget()
        self.pages.setObjectName("pageStack")
        self.modules_panel = ModulesDashboard()
        self.modules_panel.action_requested.connect(self._handle_service_action)
        self.modules_panel.file_open_requested.connect(self._handle_open_file)
        self.modules_panel.url_open_requested.connect(self._handle_open_url)
        self.modules_panel.package_requested.connect(self._handle_package_action)
        self.port_panel = PortMonitorPanel()
        self.about_panel = AboutPanel()
        self.pages.addWidget(self.modules_panel)
        self.pages.addWidget(self.port_panel)
        self.pages.addWidget(self.about_panel)
        content_layout.addWidget(self.pages)
        workspace_layout.addWidget(content_host, stretch=1)
        root.addWidget(workspace, stretch=1)
        self.activity_log = ActivityLogPanel()
        root.addWidget(self.activity_log)
        self.tray_manager = SystemTrayManager(self)
        self.tray_manager.connect_action_handler(self._handle_tray_action)
        self.refresh_timer = QTimer(self)
        self.refresh_timer.setInterval(REFRESH_INTERVAL_MS)
        self.refresh_timer.timeout.connect(self.refresh_ui)
        self._build_modules()
        self.refresh_ui()
        self.refresh_timer.start()
        QTimer.singleShot(800, self._sync_apache_welcome)
        if not privileged.is_ready():
            self._log("Tip: open About tab and click Grant Permissions once to skip password prompts")

    def showEvent(self, event) -> None:
        super().showEvent(event)
        if hasattr(self, "about_panel"):
            self.about_panel._refresh_permission_status()

    def _sync_apache_welcome(self) -> None:
        if self.welcome_worker is not None and self.welcome_worker.isRunning():
            return
        document_root = apache_welcome.find_document_root()
        if not document_root or not apache_welcome.should_deploy(document_root):
            return
        self._log("Apache: installing Amper welcome page...")
        self.welcome_worker = WelcomeDeployWorker(self)
        self.welcome_worker.finished.connect(self._on_welcome_deploy_finished)
        self.welcome_worker.start()

    def _on_welcome_deploy_finished(self, ok: bool, root: str, message: str) -> None:
        if ok:
            self._log(f"Apache: welcome page deployed to {message}")
        elif root and "already up to date" not in message:
            self._log(f"Apache: welcome page deploy failed — {message}")
        if self.welcome_worker is not None:
            self.welcome_worker.deleteLater()
            self.welcome_worker = None

    def _switch_page(self, index: int) -> None:
        self.pages.setCurrentIndex(index)

    def _build_modules(self) -> None:
        self.services = service_manager.list_catalog_services()
        self.modules_panel.rebuild(self.services)
        for service in self.services:
            if service.available and service.unit:
                self.previous_states[service.unit] = service.state
        controllable = [
            service for service in self.services if service.available and service.controllable
        ]
        self.tray_manager.rebuild_service_menu(controllable)

    def _label_for_unit(self, unit: str) -> str:
        for service in self.services:
            if service.unit == unit:
                return service.label
        return unit

    def _status_label(self, state: str) -> str:
        if state == "active":
            return "Running"
        if state in {"inactive", "dead"}:
            return "Stopped"
        if state == "failed":
            return "Failed"
        return state.capitalize()

    def _log(self, message: str) -> None:
        self.activity_log.append(message)

    def _label_for_key(self, key: str) -> str:
        for service in self.services:
            if service.key == key:
                return service.label
        return key

    def _handle_open_file(self, service_key: str, path: str) -> None:
        label = self._label_for_key(service_key)
        if service_assets.open_path(path):
            self._log(f"{label}: opened {path}")
        else:
            self._log(f"{label}: file not found — {path}")

    def _handle_open_url(self, service_key: str, url: str) -> None:
        label = self._label_for_key(service_key)
        service_assets.open_url(url)
        self._log(f"{label}: opened {url}")

    def _handle_package_action(self, service_key: str, action: str) -> None:
        if service_key in self.pending_packages:
            return
        label = self._label_for_key(service_key)
        if action == "install":
            command = package_manager.build_install_command(service_key)
        else:
            command = package_manager.build_uninstall_command(service_key)
        if command is None:
            self._log(f"{label}: package manager not available for this module")
            return
        packages = ", ".join(command.packages)
        self._log(f"{label}: {action} requested ({packages})...")
        process = QProcess(self)
        process.setProgram(command.argv[0])
        process.setArguments(command.argv[1:])
        process.finished.connect(
            lambda code, _status, key=service_key, act=action, p=process: self._on_package_finished(
                key, act, code, p
            )
        )
        self.package_processes[service_key] = process
        self.pending_packages.add(service_key)
        process.start()
        self.refresh_ui()

    def _on_package_finished(
        self,
        service_key: str,
        action: str,
        exit_code: int,
        process: QProcess,
    ) -> None:
        self.pending_packages.discard(service_key)
        self.package_processes.pop(service_key, None)
        process.deleteLater()
        label = self._label_for_key(service_key)
        service_manager.invalidate_unit_cache()
        self._build_modules()
        if exit_code != 0:
            self._log(f"{label}: {action} failed (exit {exit_code})")
        else:
            self._log(f"{label}: {action} completed successfully")
        self.refresh_ui()

    def _handle_tray_action(self, action: QAction) -> None:
        data = action.data()
        if not isinstance(data, tuple) or len(data) != 3:
            return
        kind, unit, verb = data
        if kind == "action":
            self._handle_service_action(unit, verb)

    def _handle_service_action(self, unit: str, action: str) -> None:
        if not unit or unit in self.pending_units:
            return
        label = self._label_for_unit(unit)
        verb = action.capitalize()
        self._log(f"{label}: {verb} requested...")
        argv = privileged.wrap(["systemctl", action, unit])
        process = QProcess(self)
        process.setProgram(argv[0])
        process.setArguments(argv[1:])
        process.finished.connect(
            lambda code, status, u=unit, a=action, p=process: self._on_action_finished(u, a, code, p)
        )
        self.processes[unit] = process
        self.pending_units.add(unit)
        self.pending_actions[unit] = action
        process.start()
        self.refresh_ui()

    def _on_action_finished(self, unit: str, action: str, exit_code: int, process: QProcess) -> None:
        self.pending_units.discard(unit)
        self.pending_actions.pop(unit, None)
        self.processes.pop(unit, None)
        service_manager.clear_pending(unit)
        process.deleteLater()
        self.services = service_manager.refresh_all(self.services)
        label = self._label_for_unit(unit)
        service = next((item for item in self.services if item.unit == unit), None)
        if exit_code != 0:
            self._log(f"{label}: {action.capitalize()} failed (exit {exit_code})")
        elif service is not None:
            status = self._status_label(service.state)
            self._log(f"{label}: {action.capitalize()} completed — now {status}")
            self.previous_states[unit] = service.state
        else:
            self._log(f"{label}: {action.capitalize()} completed")
        self.refresh_ui()

    def refresh_ui(self) -> None:
        for unit in list(self.pending_units):
            process = self.processes.get(unit)
            if process is not None and process.state() == QProcess.ProcessState.NotRunning:
                self.pending_units.discard(unit)
                self.processes.pop(unit, None)
                service_manager.clear_pending(unit)
        for service_key in list(self.pending_packages):
            process = self.package_processes.get(service_key)
            if process is not None and process.state() == QProcess.ProcessState.NotRunning:
                self.pending_packages.discard(service_key)
                self.package_processes.pop(service_key, None)
        self.services = service_manager.refresh_all(self.services)
        for service in self.services:
            if service.available and service.unit:
                self.previous_states[service.unit] = service.state
        ports = port_scanner.scan_listening_ports()
        conflicts = port_scanner.detect_conflicts(
            [service for service in self.services if service.available],
            ports,
        )
        self.modules_panel.update_services(
            self.services, ports, self.pending_units, self.pending_packages
        )
        self.port_panel.update_ports(ports, conflicts)
        controllable = [
            service for service in self.services if service.available and service.controllable
        ]
        self.tray_manager.update_service_states(controllable, self.pending_units)

    def closeEvent(self, event: QCloseEvent) -> None:
        if self.tray_manager.is_available():
            event.ignore()
            self.hide()
            return
        event.accept()


def create_main_window() -> MainWindow:
    app = QApplication.instance()
    if app is not None:
        app.setStyle("Fusion")
        app_icon = load_app_icon()
        if not app_icon.isNull():
            app.setWindowIcon(app_icon)
        stylesheet = load_stylesheet()
        if stylesheet:
            app.setStyleSheet(stylesheet)
    window = MainWindow()
    return window