MainWindow.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0 — BastionGuard™ is a trademark of Calogero Scarnà.
 */
 
#include "MainWindow.hpp"
#include "Resource.hpp"
#include "util/AppResolver.hpp"
 
#include <glibmm/i18n.h>
#include <glibmm/miscutils.h>
#include <gdkmm/pixbuf.h>
#include <gio/gio.h>
#include <gtk/gtk.h>
 
#include <cstdlib>          // setenv
#include <algorithm>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <locale.h>
#include <optional>
#include <sstream>
#include <libintl.h>
 
#define _(text) gettext(text)
 
#ifndef BSC_SERVICECTL_PATH
#define BSC_SERVICECTL_PATH "/usr/libexec/bastionguard/bastionguard-service"
#endif
namespace {
 
    constexpr int kNotifDesktopActive = 15;
    constexpr int kNotifDesktopIdle   = 16;
 
    std::optional<bool> queryScreensaverActiveOnce(const char* bus_name,
                                                   const char* object_path,
                                                   const char* interface_name)
    {
        GError* error = nullptr;
        GDBusConnection* conn = g_bus_get_sync(G_BUS_TYPE_SESSION, nullptr, &error);
        if (!conn) {
            if (error) g_error_free(error);
            return std::nullopt;
        }
 
        GVariant* reply = g_dbus_connection_call_sync(
            conn,
            bus_name,
            object_path,
            interface_name,
            "GetActive",
            nullptr,
            G_VARIANT_TYPE("(b)"),
            G_DBUS_CALL_FLAGS_NONE,
            180,
            nullptr,
            &error);
 
        g_object_unref(conn);
 
        if (!reply) {
            if (error) g_error_free(error);
            return std::nullopt;
        }
 
        gboolean active = FALSE;
        g_variant_get(reply, "(b)", &active);
        g_variant_unref(reply);
        return active == TRUE;
    }
 
    std::optional<bool> queryScreensaverActive()
    {
        struct Candidate {
            const char* bus;
            const char* path;
            const char* iface;
        };
 
        static constexpr Candidate candidates[] = {
            {"org.freedesktop.ScreenSaver", "/org/freedesktop/ScreenSaver", "org.freedesktop.ScreenSaver"},
            {"org.gnome.ScreenSaver",       "/org/gnome/ScreenSaver",       "org.gnome.ScreenSaver"},
            {"org.cinnamon.ScreenSaver",    "/org/cinnamon/ScreenSaver",    "org.cinnamon.ScreenSaver"},
            {"org.mate.ScreenSaver",        "/org/mate/ScreenSaver",        "org.mate.ScreenSaver"},
        };
 
        for (const auto& c : candidates) {
            if (auto v = queryScreensaverActiveOnce(c.bus, c.path, c.iface))
                return v;
        }
        return std::nullopt;
    }
 
    constexpr const char* kUISocketPath = "unix:///tmp/bsd-daemon.sock";
 
    constexpr const char* kServiceName = "bsc-daemon.service";
    constexpr const char* kServiceCtlPath = BSC_SERVICECTL_PATH;
    constexpr const char* kSystemAutostartDesktop = "/etc/xdg/autostart/bastionguard-sc-autostart.desktop";
    constexpr const char* kFallbackSystemAutostartDesktop = "/etc/xdg/autostart/bastionguard-sc.desktop";
    constexpr const char* kSystemAutostartBackupDesktop = "/etc/xdg/autostart/bastionguard-sc-autostart.desktop.bak";
 
    std::string autostartDesktopContent()
    {
        return std::string(
            "[Desktop Entry]\n"
            "Name=BastionGuard Secure Connection\n"
            "Name[it]=BastionGuard Connessione Sicura\n"
            "Comment=Interactive application firewall\n"
            "Comment[it]=Firewall applicativo interattivo\n"
            "Exec=bastionguard-sc-ui --start-minimized\n"
            "Icon=/usr/share/bastionguard-sc/data/logo.svg\n"
            "Terminal=false\n"
            "Type=Application\n"
            "Categories=Network;Security;System;\n"
            "Keywords=firewall;network;security;connection;\n"
            "StartupNotify=true\n");
    }
 
    bool writeServiceControlPreference(bool enabled, const std::string& backupFile)
    {
        try {
            const std::filesystem::path cfgDir =
                std::filesystem::path(Glib::get_user_config_dir()) / "bastionguard-sc";
            std::filesystem::create_directories(cfgDir);
 
            std::ofstream out(cfgDir / "service-control.ini", std::ios::trunc);
            out << "[ServiceControl]\n";
            out << "enabled=" << (enabled ? "true" : "false") << "\n";
            out << "autostart_enabled=" << (enabled ? "true" : "false") << "\n";
            out << "daemon_enabled=" << (enabled ? "true" : "false") << "\n";
            out << "service=" << kServiceName << "\n";
            out << "autostart_path=" << kSystemAutostartDesktop << "\n";
            out << "fallback_autostart_path=" << kFallbackSystemAutostartDesktop << "\n";
            out << "generated_autostart_file=" << (cfgDir / "bastionguard-sc-autostart.desktop").string() << "\n";
            out << "backup_path=" << backupFile << "\n";
            return static_cast<bool>(out);
        } catch (...) {
            return false;
        }
    }
 
    bool writeConfigAutostartDesktop(const std::filesystem::path& path)
    {
        try {
            std::filesystem::create_directories(path.parent_path());
            std::ofstream out(path, std::ios::trunc);
            out << autostartDesktopContent();
            return static_cast<bool>(out);
        } catch (...) {
            return false;
        }
    }
 
    std::string shellQuote(const std::string& s)
    {
        std::string out = "'";
        for (char c : s) {
            if (c == '\'') out += "'\\''";
            else out += c;
        }
        out += "'";
        return out;
    }
 
    bool runCommand(const std::string& cmd)
    {
        const int rc = std::system(cmd.c_str());
        return rc == 0;
    }
 
    std::string firstExistingPath(const std::initializer_list<std::string>& candidates)
    {
        for (const auto& p : candidates) {
            if (std::filesystem::exists(p)) return p;
        }
        return {};
    }
 
    std::string displayNameForStatus(const ConnectionInfo& info)
    {
        return bsc::ui_util::best_connection_display_name(
            info.app_comm, info.app_path, info.app_args, info.dest_ip, info.src_ip);
    }
 
}
 
MainWindow::MainWindow()
{
    set_title("");
    set_resizable(true);
    set_default_size(1158, 803);
    set_size_request(1158, 803);
 
    m_configFile = Glib::get_user_config_dir() + "/bastionguard-sc/settings.ini";
    m_cssProvider = Gtk::CssProvider::create();
 
    loadConfig();
    applyLanguage(m_language);   // applica lingua prima di costruire la UI
    loadTheme(m_darkMode);
    buildHeaderBar();
    refreshSystemIntegrationStatus();
 
    m_stack.add(m_connectionsPage, "connections");
    m_stack.add(m_appsPage,        "apps");
    m_stack.add(m_networkPage,     "network");
    m_stack.add(m_rulesPage,       "rules");
    m_stack.add(m_statsPage,       "stats");
    m_stack.add(m_aboutPage,       "about");
    m_stack.add(m_settingsPage,    "settings");
    m_settingsPage.signal_toggle_protection_requested().connect(
        sigc::mem_fun(*this, &MainWindow::applyProtectionEnabled));
 
    // Transizione animata al cambio pagina
    m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
    m_stack.set_transition_duration(220);   // ms — abbastanza veloce da non dare fastidio
 
    m_stack.set_hexpand(true);
    m_stack.set_vexpand(true);
 
    buildSidebar();
    m_mainBox.append(m_stack);
 
    // Carica il log delle connessioni precedenti (se esiste). Retention
    // 7 giorni applicata da loadLog(): record piu' vecchi scartati.
    m_connectionsPage.loadLog();
    m_networkPage.loadLog();
 
    m_statusCtx = m_statusbar.get_context_id("daemon");
    setStatus(_("In attesa del daemon..."));
 
    auto outerBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
    outerBox->append(m_mainBox);
    outerBox->append(m_statusbar);
    set_child(*outerBox);
 
    // ── Segnali UIServer ──────────────────────────────────────────────
    m_uiServer.signal_daemon_connected.connect(
        sigc::mem_fun(*this, &MainWindow::onDaemonConnected));
    m_uiServer.signal_daemon_disconnected.connect(
        sigc::mem_fun(*this, &MainWindow::onDaemonDisconnected));
    m_uiServer.signal_new_connection.connect(
        sigc::mem_fun(*this, &MainWindow::onNewConnection));
    m_uiServer.signal_alert.connect(
        sigc::mem_fun(*this, &MainWindow::onDaemonAlert));
 
    m_uiServer.start(kUISocketPath);
    startDesktopActivityMonitor();
 
    // ── Systray D-Bus ─────────────────────────────────────────────────
    m_tray.bind_ui_context();
    m_tray.set_on_activate([this]() {
        noteDesktopActivity();
        if (is_visible() && is_active()) {
            hide();
        } else {
            // Torna sempre alla pagina Connessioni quando si riapre
            m_stack.set_transition_type(Gtk::StackTransitionType::NONE);
            m_stack.set_visible_child("connections");
            m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
            if (!m_sidebarButtons.empty())
                activateSidebarButton(m_sidebarButtons[0]);
            present();
        }
    });
 
    m_tray.set_on_make_startup_persistent([this]() {
        applyProtectionEnabled(true);
        refreshSystemIntegrationStatus();
    });
 
    // FIX: "Esci" dalla systray ora chiude davvero il programma
    // Prima chiamava solo get_application()->quit(), che in certi DE non
    // funziona se l'app è in hold(). Chiamiamo prima close() sulla finestra
    // (che triggera on_close_request), poi forziamo il rilascio dell'hold
    // e infine quit() sull'applicazione.
    m_tray.set_on_quit([this]() {
        m_tray.stop();
        close();                          // bypassa on_close_request → vedi sotto
        if (auto app = get_application()) {
            app->release();              // bilancia il hold() in Application::on_activate
            app->quit();
        }
    });
    m_tray.start();
 
    if (!m_sidebarButtons.empty())
        activateSidebarButton(m_sidebarButtons[0]);
}
 
MainWindow::~MainWindow()
{
    if (m_desktopActivityTimer != 0) {
        g_source_remove(m_desktopActivityTimer);
        m_desktopActivityTimer = 0;
    }
 
    // Salva i log — vengono letti al prossimo avvio.
    // Il file viene cancellato solo da "Pulisci" nelle rispettive pagine.
    m_connectionsPage.saveLog();
    m_networkPage.saveLog();
 
    m_tray.stop();
    m_uiServer.stop();
}
 
// ---------------------------------------------------------------------------
// Config
// ---------------------------------------------------------------------------
 
void MainWindow::saveConfig()
{
    try {
        std::filesystem::create_directories(
            std::filesystem::path(m_configFile).parent_path());
        std::ofstream f(m_configFile);
        f << "[General]\n";
        f << "dark_mode=" << (m_darkMode ? "true" : "false") << "\n";
        if (!m_language.empty())
            f << "language=" << m_language << "\n";
        f << "protection_enabled=" << (m_protectionEnabled ? "true" : "false") << "\n";
        if (!m_autostartBackupFile.empty())
            f << "autostart_backup=" << m_autostartBackupFile << "\n";
    } catch (const std::exception& e) {
        std::cerr << "⚠ Impossibile salvare config: " << e.what() << "\n";
    }
}
 
void MainWindow::loadConfig()
{
    m_darkMode = false;
    m_language.clear();
    m_protectionEnabled = true;
    m_autostartBackupFile = kSystemAutostartBackupDesktop;
 
    std::ifstream f(m_configFile);
    if (f.is_open()) {
        std::string line;
        while (std::getline(f, line)) {
            if (line.find("dark_mode=true") != std::string::npos)
                m_darkMode = true;
 
            // ── Lingua ──────────────────────────────────────────────────────
            const std::string langKey = "language=";
            auto pos = line.find(langKey);
            if (pos != std::string::npos)
                m_language = line.substr(pos + langKey.size());
 
            if (line.find("protection_enabled=false") != std::string::npos)
                m_protectionEnabled = false;
 
            const std::string backupKey = "autostart_backup=";
            pos = line.find(backupKey);
            if (pos != std::string::npos)
                m_autostartBackupFile = line.substr(pos + backupKey.size());
        }
    }
 
    // service-control.ini è la sorgente esplicita per autostart e daemon.
    // Se esiste, sincronizza lo stato UI anche dopo modifiche fatte da Settings.
    const std::filesystem::path serviceControlFile =
        std::filesystem::path(m_configFile).parent_path() / "service-control.ini";
    std::ifstream sc(serviceControlFile);
    bool sawServiceControlState = false;
    bool serviceControlEnabled = true;
    std::string line;
    while (std::getline(sc, line)) {
        if (line == "enabled=true" || line == "autostart_enabled=true" || line == "daemon_enabled=true") {
            sawServiceControlState = true;
        }
        if (line == "enabled=false" || line == "autostart_enabled=false" || line == "daemon_enabled=false") {
            sawServiceControlState = true;
            serviceControlEnabled = false;
        }
 
        const std::string backupPathKey = "backup_path=";
        auto backupPathPos = line.find(backupPathKey);
        if (backupPathPos == 0) {
            m_autostartBackupFile = line.substr(backupPathKey.size());
        }
    }
    if (sawServiceControlState) {
        m_protectionEnabled = serviceControlEnabled;
    }
}
 
// ---------------------------------------------------------------------------
// Lingua (gettext)
// ---------------------------------------------------------------------------
 
/**
 * Imposta la variabile d'ambiente LANGUAGE e reinizializza gettext.
 * Deve essere chiamata PRIMA che qualsiasi stringa tradotta venga costruita.
 * Poiché GTK/GLib non supportano il cambio di lingua a runtime senza riavvio,
 * il metodo si limita a impostare l'ambiente: l'effetto si vedrà al prossimo
 * avvio (il LanguageDialog avvisa l'utente di questo).
 */
void MainWindow::applyLanguage(const std::string& lang)
{
    if (!lang.empty()) {
        ::setenv("LANGUAGE", lang.c_str(), 1);
        ::setenv("LANG",     (lang + ".UTF-8").c_str(), 1);
        ::setlocale(LC_ALL, (lang + ".UTF-8").c_str());
    } else {
        ::unsetenv("LANGUAGE");
        ::setlocale(LC_ALL, "");
    }
 
    // Reinizializza gettext (il dominio e la dir devono già essere configurati in main.cpp)
    ::textdomain("bastionguard-sc");
}
 
void MainWindow::showLanguageDialog()
{
    m_langDialog = std::make_unique<LanguageDialog>(m_configFile, m_language);
    m_langDialog->set_transient_for(*this);
    m_langDialog->set_modal(true);
    m_langDialog->signal_hide().connect([this]() {
        // Se la lingua è cambiata aggiorna il membro (la UI si aggiorna al prossimo avvio)
        const std::string chosen = m_langDialog->selectedLanguage();
        if (chosen != m_language) {
            m_language = chosen;
            // Il file è già stato scritto da LanguageDialog::onApply()
            setStatus(_("Lingua aggiornata — riavvia per applicare la modifica."));
        }
    });
    m_langDialog->present();
}
 
// ---------------------------------------------------------------------------
// Tema
// ---------------------------------------------------------------------------
 
void MainWindow::loadTheme(bool dark)
{
    const std::string cssFile = dark ? resource("BSC-dark.css") : resource("BSC.css");
    try {
        m_cssProvider->load_from_path(cssFile);
        Gtk::StyleContext::add_provider_for_display(
            get_display(),
                                                    m_cssProvider,
                                                    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    } catch (const Glib::Error& e) {
        std::cerr << "⚠ CSS: " << e.what() << "\n";
    }
}
 
void MainWindow::applyTheme(bool dark)
{
    m_darkMode = dark;
    loadTheme(dark);
    saveConfig();
 
    if (m_btnLight && m_btnDark) {
        if (dark) {
            m_btnLight->get_style_context()->remove_class("theme-btn-active");
            m_btnDark->get_style_context()->add_class("theme-btn-active");
        } else {
            m_btnDark->get_style_context()->remove_class("theme-btn-active");
            m_btnLight->get_style_context()->add_class("theme-btn-active");
        }
    }
}
 
// ---------------------------------------------------------------------------
// Header bar
// ---------------------------------------------------------------------------
 
void MainWindow::buildHeaderBar()
{
    auto header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->get_style_context()->add_class("custom-headerbar");
 
    auto headerLeft = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    headerLeft->set_size_request(240, -1);
    headerLeft->set_hexpand(false);
    headerLeft->get_style_context()->add_class("header-left");
    header->pack_start(*headerLeft);
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer->set_hexpand(true);
    header->pack_start(*spacer);
 
    auto headerRight = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 4);
    headerRight->set_hexpand(false);
    headerRight->get_style_context()->add_class("header-right");
 
    // ── Bottone selezione lingua ────────────────────────────────────────
    auto btnLang = Gtk::make_managed<Gtk::Button>("🌐");
    btnLang->get_style_context()->add_class("theme-btn");
    btnLang->set_tooltip_text(_("Cambia lingua"));
    btnLang->signal_clicked().connect(
        sigc::mem_fun(*this, &MainWindow::showLanguageDialog));
    headerRight->append(*btnLang);
 
    // ── Tema ────────────────────────────────────────────────────────────
    m_btnLight = Gtk::make_managed<Gtk::Button>("☀");
    m_btnDark  = Gtk::make_managed<Gtk::Button>("🌙");
 
    m_btnLight->get_style_context()->add_class("theme-btn");
    m_btnDark->get_style_context()->add_class("theme-btn");
 
    m_btnLight->set_tooltip_text(_("Tema chiaro"));
    m_btnDark->set_tooltip_text(_("Tema scuro"));
 
    if (m_darkMode)
        m_btnDark->get_style_context()->add_class("theme-btn-active");
    else
        m_btnLight->get_style_context()->add_class("theme-btn-active");
 
    m_btnLight->signal_clicked().connect([this]() { applyTheme(false); });
    m_btnDark->signal_clicked().connect([this]() { applyTheme(true); });
 
    headerRight->append(*m_btnLight);
    headerRight->append(*m_btnDark);
 
    auto addWinBtn = [&](const std::string& iconRes,
                         const std::string& fallback,
                         auto cb)
    {
        auto btn = Gtk::make_managed<Gtk::Button>();
        btn->get_style_context()->add_class("header-button");
 
        try {
            auto pix = Gdk::Pixbuf::create_from_file(resource(iconRes), 32, 32, true);
            btn->set_child(*Gtk::make_managed<Gtk::Image>(pix));
        } catch (...) {
            btn->set_label(fallback);
        }
 
        btn->signal_clicked().connect(cb);
        headerRight->append(*btn);
    };
 
    addWinBtn("icon-minimize.png", "—", [this]() { minimize(); });
    addWinBtn("icon-close.png",    "✕", [this]() { hide(); });
 
    header->pack_end(*headerRight);
    set_titlebar(*header);
}
 
// ---------------------------------------------------------------------------
// Sidebar
// ---------------------------------------------------------------------------
 
void MainWindow::buildSidebar()
{
    auto sidebar = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 10);
    sidebar->set_size_request(240, -1);
    sidebar->set_hexpand(false);
    sidebar->set_vexpand(true);
    sidebar->get_style_context()->add_class("sidebar");
 
    // Header logo + titolo
    {
        auto hdr = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
        hdr->set_hexpand(false);
        hdr->get_style_context()->add_class("sidebar-header");
 
        auto ico = Gtk::make_managed<Gtk::Image>();
        try {
            auto pix = Gdk::Pixbuf::create_from_file(
                resource("logo-sidebar.png"), 32, 32, true);
            ico->set(pix);
        } catch (...) {
            ico->set_from_icon_name("security-high-symbolic");
            ico->set_pixel_size(28);
        }
 
        ico->set_hexpand(false);
        hdr->append(*ico);
 
        auto lbl = Gtk::make_managed<Gtk::Label>(
            "BastionGuard™\nSecure Connection");
        lbl->set_justify(Gtk::Justification::LEFT);
        lbl->set_wrap(true);
        lbl->set_max_width_chars(16);
        lbl->set_width_chars(16);
        lbl->get_style_context()->add_class("sidebar-title");
        lbl->set_halign(Gtk::Align::START);
        lbl->set_hexpand(false);
        hdr->append(*lbl);
 
        sidebar->append(*hdr);
    }
 
    sidebar->append(*makeSidebarButton(
        resource("icons/connections.svg"), _("Connessioni"), "connections"));
    sidebar->append(*makeSidebarButton(
        resource("icons/apps.svg"), _("Applicazioni"), "apps"));
    sidebar->append(*makeSidebarButton(
        resource("icons/network.svg"), _("Monitor di rete"), "network"));
    sidebar->append(*makeSidebarButton(
        resource("icons/rules.svg"), _("Regole"), "rules"));
    sidebar->append(*makeSidebarButton(
        resource("icons/stats.svg"), _("Statistiche"), "stats"));
    sidebar->append(*makeSidebarButton(
        resource("icons/about.svg"), _("Impostazioni"), "settings"));
 
    sidebar->append(*makeSidebarButton(
        resource("icons/about.svg"), _("Informazioni"), "about"));
 
    auto spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(true);
    sidebar->append(*spacer);
 
    auto sep = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
    sep->get_style_context()->add_class("sidebar-separator");
    sidebar->append(*sep);
 
    m_daemonLabel = Gtk::make_managed<Gtk::Label>(_("⚙ Daemon: in attesa..."));
    m_daemonLabel->get_style_context()->add_class("daemon-status");
    m_daemonLabel->set_halign(Gtk::Align::START);
    m_daemonLabel->set_margin_top(6);
    m_daemonLabel->set_margin_start(8);
    m_daemonLabel->set_margin_bottom(6);
    sidebar->append(*m_daemonLabel);
 
    m_mainBox.append(*sidebar);
}
 
Gtk::Button* MainWindow::makeSidebarButton(const std::string& iconPath,
                                           const std::string& label,
                                           const std::string& pageName)
{
    auto box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
 
    auto pic = Gtk::make_managed<Gtk::Picture>();
    try {
        auto pb = Gdk::Pixbuf::create_from_file(iconPath);
        auto scaled = pb->scale_simple(16, 16, Gdk::InterpType::BILINEAR);
        auto tex = Gdk::Texture::create_for_pixbuf(scaled);
        pic->set_paintable(tex);
        pic->set_content_fit(Gtk::ContentFit::FILL);
    } catch (...) {}
 
    auto iconBox = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    iconBox->set_size_request(16, 16);
    iconBox->set_hexpand(false);
    iconBox->set_valign(Gtk::Align::CENTER);
    iconBox->append(*pic);
    box->append(*iconBox);
 
    auto lbl = Gtk::make_managed<Gtk::Label>(label);
    lbl->set_halign(Gtk::Align::START);
    lbl->set_hexpand(false);
    box->append(*lbl);
 
    auto btn = Gtk::make_managed<Gtk::Button>();
    btn->set_child(*box);
    btn->set_hexpand(true);
    btn->get_style_context()->add_class("sidebar-button");
    m_sidebarButtons.push_back(btn);
 
    btn->signal_clicked().connect([this, btn, pageName]() {
        // Determina direzione animazione in base all'ordine delle pagine
        static const std::vector<std::string> pageOrder = {
            "connections", "apps", "network", "rules", "stats", "settings", "about"
        };
        const std::string currentPage = m_stack.get_visible_child_name();
        auto itCur = std::find(pageOrder.begin(), pageOrder.end(), currentPage);
        auto itDst = std::find(pageOrder.begin(), pageOrder.end(), pageName);
        if (itCur != pageOrder.end() && itDst != pageOrder.end()) {
            if (itDst > itCur)
                m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
            else if (itDst < itCur)
                m_stack.set_transition_type(Gtk::StackTransitionType::SLIDE_RIGHT);
            // stessa pagina: nessun cambio di tipo
        }
        activateSidebarButton(btn);
        m_stack.set_visible_child(pageName);
    });
 
    return btn;
}
 
void MainWindow::activateSidebarButton(Gtk::Button* btn)
{
    for (auto* b : m_sidebarButtons)
        b->get_style_context()->remove_class("active-sidebar-button");
 
    if (btn) {
        btn->get_style_context()->add_class("active-sidebar-button");
        m_activeButton = btn;
    }
}
 
// ---------------------------------------------------------------------------
// Daemon handlers
// ---------------------------------------------------------------------------
 
 
void MainWindow::startDesktopActivityMonitor()
{
    m_lastUiActivity = std::chrono::steady_clock::now();
 
    auto install_activity_controller = [this](GtkEventController* controller) {
        gtk_event_controller_set_propagation_phase(controller, GTK_PHASE_CAPTURE);
        gtk_widget_add_controller(GTK_WIDGET(gobj()), controller);
    };
 
    auto* motion = gtk_event_controller_motion_new();
    g_signal_connect(
        motion,
        "motion",
        G_CALLBACK(+[](GtkEventControllerMotion*, double, double, gpointer data) {
            static_cast<MainWindow*>(data)->noteDesktopActivity();
        }),
        this);
    install_activity_controller(GTK_EVENT_CONTROLLER(motion));
 
    auto* click = gtk_gesture_click_new();
    g_signal_connect(
        click,
        "pressed",
        G_CALLBACK(+[](GtkGestureClick*, int, double, double, gpointer data) {
            static_cast<MainWindow*>(data)->noteDesktopActivity();
        }),
        this);
    install_activity_controller(GTK_EVENT_CONTROLLER(click));
 
    auto* key = gtk_event_controller_key_new();
    g_signal_connect(
        key,
        "key-pressed",
        G_CALLBACK(+[](GtkEventControllerKey*, guint, guint, GdkModifierType, gpointer data) -> gboolean {
            static_cast<MainWindow*>(data)->noteDesktopActivity();
            return GDK_EVENT_PROPAGATE;
        }),
        this);
    install_activity_controller(GTK_EVENT_CONTROLLER(key));
 
    // Il polling non usa “inattività della finestra BSC” perché la UI può
    // restare nel tray mentre l’utente lavora su altre app. Usiamo invece lo
    // stato del desktop/screen saver quando il DE lo espone via D-Bus.
    m_desktopActivityTimer = g_timeout_add_seconds(
        5,
        +[](gpointer data) -> gboolean {
            return static_cast<MainWindow*>(data)->pollDesktopActivity()
                ? G_SOURCE_CONTINUE
                : G_SOURCE_REMOVE;
        },
        this);
 
    pollDesktopActivity();
}
 
bool MainWindow::pollDesktopActivity()
{
    const auto screensaver_active = queryScreensaverActive();
 
    // Se il DE non espone lo stato screen saver/lock, restiamo attivi:
    // meglio non spegnere il monitoraggio mentre l’utente sta lavorando.
    const bool desktop_active = screensaver_active ? !*screensaver_active : true;
    sendDesktopActivityState(desktop_active);
    return true;
}
 
void MainWindow::noteDesktopActivity()
{
    m_lastUiActivity = std::chrono::steady_clock::now();
    sendDesktopActivityState(true);
}
 
void MainWindow::sendDesktopActivityState(bool active, bool force)
{
    if (!force && active == m_desktopActiveSent) return;
    m_desktopActiveSent = active;
 
    m_uiServer.queueNotification(active ? kNotifDesktopActive : kNotifDesktopIdle, "{}");
    if (!active) {
        setStatus(_("⏸ Desktop inattivo: monitoraggio connessioni sospeso"));
    }
}
 
void MainWindow::onDaemonConnected()
{
    setStatus(_("✅ Daemon connesso"));
    if (m_daemonLabel)
        m_daemonLabel->set_text(_("⚙ Daemon: connesso"));
    m_tray.set_tooltip("BastionGuard™ SC — Daemon connesso");
 
    // Allineamento immediato: il daemon parte "idle" per sicurezza finché
    // la UI non conferma che il desktop è attivo.
    pollDesktopActivity();
    sendDesktopActivityState(m_desktopActiveSent, true);
}
 
void MainWindow::onDaemonDisconnected()
{
    setStatus(_("⚠ Daemon disconnesso — in attesa..."));
    if (m_daemonLabel)
        m_daemonLabel->set_text(_("⚙ Daemon: in attesa..."));
    m_tray.set_tooltip("BastionGuard™ SC — Daemon disconnesso");
}
 
// ---------------------------------------------------------------------------
// Nuova connessione → mostra AlertDialog
// ---------------------------------------------------------------------------
 
// ---------------------------------------------------------------------------
// Cache verdetti — chiave di lookup
// ---------------------------------------------------------------------------
 
std::string MainWindow::cacheKey(const std::string& app,
                                 const std::string& host,
                                 const std::string& ip)
{
    return app + "|" + host + "|" + ip;
}
 
void MainWindow::onNewConnection(const ConnectionInfo& info)
{
    // ── Controlla la cache dei verdetti "always" ─────────────────────────
    // Se questa combinazione app+host+ip è già stata decisa con ALLOW_ALWAYS
    // o DENY_ALWAYS, rispondi immediatamente senza mostrare il popup.
    const std::string key = cacheKey(!info.app_path.empty() ? info.app_path : info.app_comm, info.dest_host, info.dest_ip);
    auto it = m_verdictCache.find(key);
    if (it != m_verdictCache.end()) {
        const bool allowed = (it->second == ReplyAction::ALLOW_ALWAYS);
        const std::string esito = allowed
        ? std::string{"✅ "} + _("Consentito (sempre)")
        : std::string{"❌ "} + _("Negato (sempre)");
 
        m_uiServer.sendReply(it->second);
        m_connectionsPage.onNewConnection(info, /*pending=*/false);
        m_connectionsPage.setLastVerdict(esito);
 
        // Anche i verdetti ricavati da cache devono aggiornare le
        // viste aggregate e la mappa, altrimenti dopo il primo "allow
        // always" una app scompare dai grafici.
        m_appsPage.noteConnection(info, esito);
        m_networkPage.noteConnection(info);
 
        if (allowed) ++m_statAllowed; else ++m_statDenied;
        m_statsPage.updateStats(m_statAllowed, m_statDenied,
                                m_statAllowed + m_statDenied);
        setStatus(esito + " — " + displayNameForStatus(info));
        return;
    }
 
    // ── Nessuna regola in cache: mostra il popup ─────────────────────────
    m_connectionsPage.onNewConnection(info, /*pending=*/true);
    m_connectionsPage.saveLog();
 
    if (m_alertDialog && m_alertDialog->is_visible())
        return;
 
    m_alertDialog = std::make_unique<AlertDialog>(
        info.app_comm, info.app_path, info.app_args, info.dest_host, info.dest_ip, info.dest_port);
 
    // IMPORTANTE: NON rendere l'AlertDialog transient_for della main window.
    // Se lo fosse:
    //   - su X11/Wayland, presentarlo presenterebbe anche la main window
    //   - la main window in tray verrebbe forzata visibile
    // Qui vogliamo che l'alert sia una finestra completamente indipendente:
    // il tray resta nel tray, il dialog appare sopra al desktop.
 
    m_alertDialog->signal_verdict.connect(
        [this, info](Verdict v) {
            onVerdict(v, info);
        });
 
    // IMPORTANTE: NON chiamare present() sulla main window.
    // Prima c'era `if (!is_visible()) present()` che apriva la finestra
    // principale ogni volta che arrivava un alert — comportamento sbagliato:
    // l'utente viene disturbato abbastanza dal popup, la main window deve
    // restare discreta nel tray.
    m_alertDialog->present();
}
 
void MainWindow::onDaemonAlert(const AlertInfo& alert)
{
    std::string text = alert.text.empty() ? _("Alert dal daemon") : alert.text;
 
    // Mapping dei codici `what` e `type` come definiti in ipc/UIServer.cpp:
    //   what:  0 generic, 2 firewall, 3 connection
    //   type:  0 error, 1 warning, 2 info
    constexpr int kWhatConnection = 3;
    constexpr int kTypeWarning    = 1;
 
    const bool is_connection_alert = alert.what == kWhatConnection && alert.has_connection;
 
    if (is_connection_alert) {
        m_connectionsPage.onNewConnection(alert.connection, /*pending=*/false);
        m_connectionsPage.saveLog();
        std::string esito;
        if (alert.type == kTypeWarning) {
            ++m_statDenied;
            esito = _("❌ Negato");
            m_connectionsPage.setLastVerdict(esito);
        } else {
            ++m_statAllowed;
            esito = _("✅ Consentito");
            m_connectionsPage.setLastVerdict(esito);
        }
        m_appsPage.noteConnection(alert.connection, esito);
        m_networkPage.noteConnection(alert.connection);
        m_statsPage.updateStats(m_statAllowed, m_statDenied, m_statAllowed + m_statDenied);
        setStatus(text);
        m_tray.set_tooltip("BastionGuard™ SC — " + text);
        return;
    }
 
    setStatus(text);
    m_tray.set_tooltip("BastionGuard™ SC — " + text);
 
    // NON chiamare present() qui: gli alert informativi passano tramite il
    // tray, non forzano l'apertura della main window. L'utente apre lei
    // attivamente cliccando sull'icona del tray.
}
 
void MainWindow::onVerdict(Verdict v, const ConnectionInfo& info)
{
    ReplyAction action = ReplyAction::DENY_ONCE;
    std::string esito;
 
    switch (v) {
        case Verdict::ALLOW_ONCE:
            action = ReplyAction::ALLOW_ONCE;
            esito  = std::string{"✅ "} + _("Consentito (una volta)");
            ++m_statAllowed;
            break;
 
        case Verdict::ALLOW_ALWAYS:
            action = ReplyAction::ALLOW_ALWAYS;
            esito  = std::string{"✅ "} + _("Consentito (sempre)");
            ++m_statAllowed;
            break;
 
        case Verdict::DENY_ONCE:
            action = ReplyAction::DENY_ONCE;
            esito  = std::string{"❌ "} + _("Negato (una volta)");
            ++m_statDenied;
            break;
 
        case Verdict::DENY_ALWAYS:
            action = ReplyAction::DENY_ALWAYS;
            esito  = std::string{"❌ "} + _("Negato (sempre)");
            ++m_statDenied;
            break;
    }
 
    m_uiServer.sendReply(action);
 
    // Memorizza in cache solo le regole "always"
    if (v == Verdict::ALLOW_ALWAYS || v == Verdict::DENY_ALWAYS)
        m_verdictCache[cacheKey(!info.app_path.empty() ? info.app_path : info.app_comm, info.dest_host, info.dest_ip)] = action;
 
    // Aggiorna la riga nella pagina Connessioni e salva il log
    m_connectionsPage.setLastVerdict(esito);
    m_connectionsPage.saveLog();
 
    // Aggiorna vista per-applicazione
    m_appsPage.noteConnection(info, esito);
 
    // Aggiorna Monitor di rete (geo lookup async)
    m_networkPage.noteConnection(info);
 
    m_statsPage.updateStats(
        m_statAllowed,
        m_statDenied,
        m_statAllowed + m_statDenied);
 
    setStatus(esito + " — " + displayNameForStatus(info));
}
 
// ---------------------------------------------------------------------------
// Statusbar
// ---------------------------------------------------------------------------
 
void MainWindow::setStatus(const std::string& msg)
{
    m_statusbar.pop(m_statusCtx);
    m_statusbar.push(msg, m_statusCtx);
}
 
 
void MainWindow::applyProtectionEnabled(bool enabled)
{
    const std::filesystem::path cfgDir = std::filesystem::path(m_configFile).parent_path();
    const std::filesystem::path generatedAutostart = cfgDir / "bastionguard-sc-autostart.desktop";
    const std::string backupFile = kSystemAutostartBackupDesktop;
 
    // Settings e systray passano da qui. About resta solo informativa, quindi
    // l'attivazione/disattivazione non è duplicata in più pagine.
    bool ok = !enabled || writeConfigAutostartDesktop(generatedAutostart);
    std::string status;
 
    if (ok) {
        std::ostringstream script;
        script << "set -eu; ";
 
        if (!enabled) {
            // Prima di rimuovere l'autostart attivo da /etc/xdg/autostart,
            // conserva un backup nello stesso percorso di sistema con estensione .bak.
            script << "if [ -f " << shellQuote(kSystemAutostartDesktop) << " ]; then "
                   << "install -m 0644 " << shellQuote(kSystemAutostartDesktop) << " " << shellQuote(backupFile) << "; fi; ";
            script << "if [ ! -f " << shellQuote(backupFile) << " ] && [ -f " << shellQuote(kFallbackSystemAutostartDesktop) << " ]; then "
                   << "install -m 0644 " << shellQuote(kFallbackSystemAutostartDesktop) << " " << shellQuote(backupFile) << "; fi; ";
            script << "rm -f " << shellQuote(kSystemAutostartDesktop) << " " << shellQuote(kFallbackSystemAutostartDesktop) << "; ";
            script << "test -x " << shellQuote(kServiceCtlPath) << "; ";
            script << shellQuote(kServiceCtlPath) << " --system disable --now "
                   << shellQuote(kServiceName) << "; ";
        } else {
            script << "mkdir -p " << shellQuote(std::filesystem::path(kSystemAutostartDesktop).parent_path().string()) << "; ";
            script << "if [ -f " << shellQuote(backupFile) << " ]; then "
                   << "install -D -m 0644 " << shellQuote(backupFile) << " " << shellQuote(kSystemAutostartDesktop) << "; "
                   << "else install -D -m 0644 " << shellQuote(generatedAutostart.string()) << " " << shellQuote(kSystemAutostartDesktop) << "; fi; ";
            script << "rm -f " << shellQuote(kFallbackSystemAutostartDesktop) << "; ";
            script << "test -x " << shellQuote(kServiceCtlPath) << "; ";
            script << shellQuote(kServiceCtlPath) << " --system enable --now "
                   << shellQuote(kServiceName) << "; ";
        }
 
        ok = runCommand("pkexec /bin/sh -c " + shellQuote(script.str()));
    }
 
    if (ok) {
        ok = writeServiceControlPreference(enabled, backupFile);
        if (!ok) {
            status = _("Operazione di sistema completata, ma salvataggio della preferenza in ~/.config non riuscito.");
        }
    }
 
    if (ok) {
        m_protectionEnabled = enabled;
        m_autostartBackupFile = backupFile;
        saveConfig();
        status = enabled
        ? _("Avvio persistente attivato: autostart_enabled=true e daemon_enabled=true salvati, autostart installato e bsc-daemon abilitato.")
        : _("Protezione disattivata: enabled=false, autostart_enabled=false e daemon_enabled=false salvati, bsc-daemon fermato/disabilitato e autostart rimosso. Backup creato in /etc/xdg/autostart.");
    } else if (status.empty()) {
        status = enabled
        ? _("Riattivazione non completata. Controlla PolicyKit, il gestore servizi, il backup in /etc/xdg/autostart e il salvataggio config.")
        : _("Disattivazione non completata. Controlla PolicyKit, il gestore servizi, il backup in /etc/xdg/autostart, bsc-daemon e il salvataggio config.");
    }
 
    m_settingsPage.refreshState();
    m_settingsPage.setProtectionEnabled(m_protectionEnabled);
    m_settingsPage.setSystemIntegrationStatus(status);
    setStatus(status);
}
 
void MainWindow::refreshSystemIntegrationStatus()
{
    const bool serviceEnabled = runCommand(
        shellQuote(kServiceCtlPath) + " --system is-enabled " +
        shellQuote(kServiceName) + " >/dev/null 2>&1");
    const bool autostartPresent = std::filesystem::exists(kSystemAutostartDesktop) ||
                                  std::filesystem::exists(kFallbackSystemAutostartDesktop);
    std::string text;
    if (m_protectionEnabled) {
        text = _("Protezione attiva nelle impostazioni utente.");
    } else {
        text = _("Protezione disattivata nelle impostazioni utente.");
    }
    text += std::string(" ") + (serviceEnabled ? _("Servizio di sistema abilitato.") : _("Servizio di sistema disabilitato."));
    text += std::string(" ") + (autostartPresent ? _("Avvio automatico presente.") : _("Avvio automatico assente."));
    if (!m_autostartBackupFile.empty() && std::filesystem::exists(m_autostartBackupFile)) {
        text += std::string(" ") + _("Backup autostart disponibile.");
    }
    m_settingsPage.refreshState();
    m_settingsPage.setProtectionEnabled(m_protectionEnabled);
    m_settingsPage.setSystemIntegrationStatus(text);
}
 
// ---------------------------------------------------------------------------
// on_close_request
//
// La X sulla header bar e il minimize nascondono la finestra nella systray.
// Il "Esci" nella systray chiama close() direttamente (bypassa questo override
// perché imposta prima m_tray.stop() e poi quit()), ma per sicurezza tracciamo
// lo stato con un flag interno.
// ---------------------------------------------------------------------------
 
bool MainWindow::on_close_request()
{
    // Nascondi nella systray invece di chiudere
    hide();
    return true;   // true = non distruggere la finestra
}