NetworkPage.cpp

Go to the documentation of this file.

/*
 * BastionGuard™ Secure Connection
 * Copyright (C) 2025–2026 Calogero Scarnà
 * GPL-3.0
 */
 
#include "NetworkPage.hpp"
#include "../util/AppResolver.hpp"
 
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <filesystem>
#include <fstream>
#include <glibmm/i18n.h>
#include <gtk/gtk.h>
#include <sstream>
#include <unistd.h>
 
namespace {
    constexpr double kDefaultLat = 20.0;
    constexpr double kDefaultLon = 10.0;
    constexpr double kDefaultZoom = 2.2;
    constexpr double kFocusedZoom = 3.0;
    constexpr double kMaxZoom = 20.0;
    constexpr double kMinZoom = 1.0;
    constexpr auto kHoverHideDelay = std::chrono::milliseconds(140);
    constexpr auto kUserViewportHold = std::chrono::seconds(8);
 
    struct AnimatedMarkerData {
        gint64 start_us = 0;
        int hits = 1;
    };
 
    struct HoverPayload {
        NetworkPage* self = nullptr;
        std::string ip;
        std::string host;
        std::string app_name;
        std::string country_code;
        std::string country_name;
        std::string city;
        std::string isp;
        uint32_t hits{0};
    };
 
    static gboolean animated_marker_tick(GtkWidget* widget,
                                         GdkFrameClock*,
                                         gpointer)
    {
        gtk_widget_queue_draw(widget);
        return G_SOURCE_CONTINUE;
    }
 
    static void animated_marker_data_destroy(gpointer data)
    {
        delete static_cast<AnimatedMarkerData*>(data);
    }
 
    static void hover_payload_destroy(gpointer data, GClosure*)
    {
        delete static_cast<HoverPayload*>(data);
    }
 
    static void animated_marker_draw(GtkDrawingArea*,
                                     cairo_t* cr,
                                     int width,
                                     int height,
                                     gpointer user_data)
    {
        auto* data = static_cast<AnimatedMarkerData*>(user_data);
        if (!data) return;
 
        const gint64 now = g_get_monotonic_time();
        const double t = (now - data->start_us) / 1000000.0;
 
        const double cx = width * 0.5;
        const double cy = height * 0.5;
 
        const double base_r =
        std::clamp(5.0 + std::log2(static_cast<double>(std::max(1, data->hits)) + 1.0) * 1.8,
                   5.0,
                   11.0);
 
        const double pulse01 = (std::sin(t * 2.8) + 1.0) * 0.5;
        const double ring_r = base_r + 4.0 + pulse01 * 10.0;
        const double ring_alpha = 0.10 + (1.0 - pulse01) * 0.22;
        const double glow_r = base_r + 7.0 + pulse01 * 4.0;
        const double glow_alpha = 0.12 + pulse01 * 0.10;
 
        cairo_save(cr);
 
        cairo_pattern_t* glow =
        cairo_pattern_create_radial(cx, cy, base_r * 0.3, cx, cy, glow_r);
        cairo_pattern_add_color_stop_rgba(glow, 0.0, 1.0, 0.42, 0.28, glow_alpha);
        cairo_pattern_add_color_stop_rgba(glow, 1.0, 1.0, 0.42, 0.28, 0.0);
        cairo_set_source(cr, glow);
        cairo_arc(cr, cx, cy, glow_r, 0.0, 2.0 * M_PI);
        cairo_fill(cr);
        cairo_pattern_destroy(glow);
 
        cairo_set_source_rgba(cr, 1.0, 0.53, 0.30, ring_alpha);
        cairo_set_line_width(cr, 2.0);
        cairo_arc(cr, cx, cy, ring_r, 0.0, 2.0 * M_PI);
        cairo_stroke(cr);
 
        cairo_set_source_rgba(cr, 1.0, 0.36, 0.26, 0.98);
        cairo_arc(cr, cx, cy, base_r, 0.0, 2.0 * M_PI);
        cairo_fill(cr);
 
        cairo_set_source_rgba(cr, 1.0, 0.95, 0.92, 0.95);
        cairo_set_line_width(cr, 1.5);
        cairo_arc(cr, cx, cy, base_r, 0.0, 2.0 * M_PI);
        cairo_stroke(cr);
 
        cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0.30);
        cairo_arc(cr,
                  cx - base_r * 0.30,
                  cy - base_r * 0.32,
                  std::max(1.5, base_r * 0.33),
                  0.0,
                  2.0 * M_PI);
        cairo_fill(cr);
 
        cairo_restore(cr);
    }
 
    static GtkWidget* create_animated_dot_widget(int hits)
    {
        auto* area = gtk_drawing_area_new();
 
        const int size = std::clamp(
            32 + static_cast<int>(std::log2(static_cast<double>(std::max(1, hits)) + 1.0) * 8.0),
                                    32,
                                    54
        );
 
        auto* data = new AnimatedMarkerData{};
        data->start_us = g_get_monotonic_time();
        data->hits = hits;
 
        gtk_widget_set_size_request(area, size, size);
        gtk_drawing_area_set_content_width(GTK_DRAWING_AREA(area), size);
        gtk_drawing_area_set_content_height(GTK_DRAWING_AREA(area), size);
        gtk_drawing_area_set_draw_func(
            GTK_DRAWING_AREA(area),
                                       animated_marker_draw,
                                       data,
                                       animated_marker_data_destroy
        );
 
        gtk_widget_add_tick_callback(area, animated_marker_tick, nullptr, nullptr);
        gtk_widget_set_halign(area, GTK_ALIGN_CENTER);
        gtk_widget_set_valign(area, GTK_ALIGN_CENTER);
 
        return area;
    }
 
    static void map_fx_draw(GtkDrawingArea*,
                            cairo_t* cr,
                            int width,
                            int height,
                            gpointer user_data)
    {
        // user_data contiene il NetworkPage*. Se null, non disegniamo nulla
        // (overlay trasparente).
        auto* page = static_cast<NetworkPage*>(user_data);
        if (!page) return;
        page->drawConnectionArcs(cr, width, height);
    }
} // namespace
 
// drawConnectionArcs e' definito come metodo di NetworkPage piu' sotto —
// ha bisogno di accedere ai pin privati e al viewport shumate.
 
NetworkPage::NetworkPage()
: Gtk::Box(Gtk::Orientation::VERTICAL, 0)
{
    get_style_context()->add_class("bsc-page");
    get_style_context()->add_class("bsc-network-page");
 
    buildUI();
 
    m_geoDispatcher.connect([this]() { onGeoResolved(); });
 
    bsc::ui_util::GeoResolver::instance().on_resolved(
        [this](const std::string& ip, const bsc::ui_util::GeoEntry& e) {
            {
                std::lock_guard lk(m_pendingMu);
                m_pendingGeo.emplace_back(ip, e);
            }
            m_geoDispatcher.emit();
        });
 
    // Richiedi la posizione del PC in background. Il risultato arrivera'
    // via onGeoResolved() con ip="__self__".
    requestSelfLocation();
 
    // Pulse timer per animazioni (marker self + puntini destinazione +
    // cleanup pin stale). 66 ms = ~15 Hz: fluido per animazioni lente,
    // leggero sulla CPU.
    //
    // NOTA: niente cleanup periodico di pin "stale" — nella v3 l'utente
    // vuole vedere TUTTI i pin raccolti durante la sessione (e anche
    // quelli delle sessioni precedenti, fino a 7 giorni). La vecchia
    // finestra 30 s era troppo aggressiva.
    m_pulseTimerId = g_timeout_add(66, +[](gpointer data) -> gboolean {
        auto* self = static_cast<NetworkPage*>(data);
        self->m_pulseFrame = (self->m_pulseFrame + 1) % 10000;
        self->triggerFxRedraw();
        return G_SOURCE_CONTINUE;
    }, this);
}
 
NetworkPage::~NetworkPage()
{
    if (m_pulseTimerId != 0) {
        g_source_remove(m_pulseTimerId);
        m_pulseTimerId = 0;
    }
 
    m_markerLayer = nullptr;
    m_viewport = nullptr;
    m_simpleMap = nullptr;
    m_mapFxArea = nullptr;
    m_mapOverlay = nullptr;
    m_hoverCard = nullptr;
    m_hoverCardTitle = nullptr;
    m_hoverCardBody = nullptr;
 
    if (m_hoverHideSource != 0) {
        g_source_remove(m_hoverHideSource);
        m_hoverHideSource = 0;
    }
}
 
void NetworkPage::buildUI()
{
    set_margin_start(12);
    set_margin_end(12);
    set_margin_top(12);
    set_margin_bottom(12);
 
    auto header = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    header->get_style_context()->add_class("bsc-page-header");
 
    m_headerLabel.set_markup("<b>" + Glib::ustring(_("Monitor di rete")) + "</b>");
    m_headerLabel.set_halign(Gtk::Align::START);
    m_headerLabel.get_style_context()->add_class("bsc-page-title");
    header->append(m_headerLabel);
 
    m_summaryLabel.set_halign(Gtk::Align::START);
    m_summaryLabel.set_hexpand(true);
    m_summaryLabel.get_style_context()->add_class("bsc-page-subtitle");
    m_summaryLabel.set_margin_start(12);
    header->append(m_summaryLabel);
 
    m_clearBtn.set_label(_("Pulisci"));
    m_clearBtn.get_style_context()->add_class("bsc-toolbar-button");
    m_clearBtn.signal_clicked().connect([this]() { clear(); });
    header->append(m_clearBtn);
 
    append(*header);
 
    m_mapHost.set_hexpand(true);
    m_mapHost.set_vexpand(false);
    m_mapHost.set_margin_top(8);
    m_mapHost.set_margin_bottom(8);
    m_mapHost.set_size_request(-1, 475);
    m_mapHost.get_style_context()->add_class("bsc-map");
    buildMapWidget();
    append(m_mapHost);
 
    m_store = Gtk::ListStore::create(m_columns);
    m_treeView.set_model(m_store);
    m_treeView.set_headers_visible(true);
    m_treeView.set_hexpand(true);
    m_treeView.set_vexpand(true);
    m_treeView.get_style_context()->add_class("bsc-treeview");
    m_treeView.get_style_context()->add_class("bsc-network-treeview");
 
    m_treeView.append_column(_("Paese"),   m_columns.col_country);
    m_treeView.append_column(_("Città"),   m_columns.col_city);
    m_treeView.append_column(_("IP"),      m_columns.col_ip);
    m_treeView.append_column(_("Host"),    m_columns.col_host);
    m_treeView.append_column(_("App"),     m_columns.col_app);
    m_treeView.append_column(_("ISP/AS"),  m_columns.col_isp);
    m_treeView.append_column(_("Hit"),     m_columns.col_hits);
 
    for (guint i = 0; i < m_treeView.get_n_columns(); ++i) {
        if (auto* c = m_treeView.get_column(i)) {
            c->set_resizable(true);
            c->set_reorderable(false);
        }
    }
 
    m_scroll.set_child(m_treeView);
    m_scroll.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    m_scroll.set_hexpand(true);
    m_scroll.set_vexpand(true);
    m_scroll.get_style_context()->add_class("bsc-scrolled");
    append(m_scroll);
 
    updateSummary();
}
 
GtkWidget* NetworkPage::createHoverCard()
{
    auto* frame = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
    gtk_widget_add_css_class(frame, "bsc-network-popover");
    gtk_widget_set_size_request(frame, 320, -1);
    gtk_widget_set_halign(frame, GTK_ALIGN_START);
    gtk_widget_set_valign(frame, GTK_ALIGN_START);
    gtk_widget_set_margin_start(frame, 28);
    gtk_widget_set_margin_top(frame, 28);
    gtk_widget_set_visible(frame, FALSE);
    gtk_widget_set_can_target(frame, FALSE);
 
    m_hoverCardTitle = gtk_label_new(nullptr);
    gtk_widget_add_css_class(m_hoverCardTitle, "bsc-network-popover-title");
    gtk_label_set_xalign(GTK_LABEL(m_hoverCardTitle), 0.0f);
    gtk_widget_set_can_target(m_hoverCardTitle, FALSE);
    gtk_box_append(GTK_BOX(frame), m_hoverCardTitle);
 
    m_hoverCardBody = gtk_label_new(nullptr);
    gtk_widget_add_css_class(m_hoverCardBody, "bsc-network-popover-meta");
    gtk_label_set_xalign(GTK_LABEL(m_hoverCardBody), 0.0f);
    gtk_label_set_wrap(GTK_LABEL(m_hoverCardBody), TRUE);
    gtk_widget_set_can_target(m_hoverCardBody, FALSE);
    gtk_box_append(GTK_BOX(frame), m_hoverCardBody);
 
    return frame;
}
 
void NetworkPage::showHoverCard(const std::string& country_code,
                                const std::string& country_name,
                                const std::string& city,
                                const std::string& ip,
                                const std::string& host,
                                const std::string& app_name,
                                const std::string& isp,
                                uint32_t hits)
{
    if (!m_hoverCard || !m_hoverCardTitle || !m_hoverCardBody) return;
 
    if (m_hoverHideSource != 0) {
        g_source_remove(m_hoverHideSource);
        m_hoverHideSource = 0;
    }
 
    std::string title;
    if (!country_code.empty() && !country_name.empty()) {
        title = country_code + "  " + country_name;
    } else if (!country_name.empty()) {
        title = country_name;
    } else {
        title = "Connessione";
    }
 
    std::ostringstream body;
    if (!city.empty()) body << city << "\n";
    body << "IP: " << ip;
    if (!host.empty()) body << "\nHost: " << host;
    if (!app_name.empty()) body << "\nApp: " << app_name;
    if (!isp.empty()) body << "\nISP/AS: " << isp;
    body << "\nHit: " << hits;
 
    gtk_label_set_text(GTK_LABEL(m_hoverCardTitle), title.c_str());
    gtk_label_set_text(GTK_LABEL(m_hoverCardBody), body.str().c_str());
    gtk_widget_set_visible(m_hoverCard, TRUE);
}
 
void NetworkPage::hideHoverCard()
{
    if (!m_hoverCard) return;
 
    if (m_hoverHideSource != 0) {
        g_source_remove(m_hoverHideSource);
        m_hoverHideSource = 0;
    }
 
    m_hoverHideSource = g_timeout_add(
        static_cast<guint>(kHoverHideDelay.count()),
        +[](gpointer data) -> gboolean {
            auto* self = static_cast<NetworkPage*>(data);
            self->m_hoverHideSource = 0;
            if (self->m_hoverCard) {
                gtk_widget_set_visible(self->m_hoverCard, FALSE);
            }
            return G_SOURCE_REMOVE;
        },
        this
    );
}
 
void NetworkPage::buildMapWidget()
{
    m_mapOverlay = gtk_overlay_new();
 
    m_simpleMap = GTK_WIDGET(shumate_simple_map_new());
    m_viewport = shumate_simple_map_get_viewport(SHUMATE_SIMPLE_MAP(m_simpleMap));
    m_markerLayer = shumate_marker_layer_new(m_viewport);
 
    auto* registry = shumate_map_source_registry_new();
    if (registry != nullptr) {
        shumate_map_source_registry_populate_defaults(registry);
 
        auto* source =
        SHUMATE_MAP_SOURCE(g_list_model_get_object(G_LIST_MODEL(registry), 0));
        if (source != nullptr) {
            shumate_simple_map_set_map_source(SHUMATE_SIMPLE_MAP(m_simpleMap), source);
            g_object_unref(source);
        }
        g_object_unref(registry);
    }
 
    shumate_simple_map_set_show_zoom_buttons(SHUMATE_SIMPLE_MAP(m_simpleMap), TRUE);
    shumate_simple_map_add_overlay_layer(
        SHUMATE_SIMPLE_MAP(m_simpleMap),
                                         SHUMATE_LAYER(m_markerLayer));
 
    shumate_viewport_set_min_zoom_level(m_viewport, kMinZoom);
    shumate_viewport_set_max_zoom_level(m_viewport, kMaxZoom);
    shumate_location_set_location(SHUMATE_LOCATION(m_viewport), kDefaultLat, kDefaultLon);
    shumate_viewport_set_zoom_level(m_viewport, kDefaultZoom);
 
    gtk_widget_set_focusable(m_simpleMap, TRUE);
    gtk_widget_set_hexpand(m_simpleMap, TRUE);
    gtk_widget_set_vexpand(m_simpleMap, FALSE);
    gtk_widget_set_size_request(m_simpleMap, 720, 475);
    gtk_widget_add_css_class(m_simpleMap, "bsc-map-widget");
 
    gtk_overlay_set_child(GTK_OVERLAY(m_mapOverlay), m_simpleMap);
 
    // Zoom con rotella/trackpad del mouse. Il controller e' agganciato
    // all'overlay in fase CAPTURE, non solo al widget Shumate: cosi' funziona
    // anche quando il cursore e' sopra marker, hover-card o overlay grafico.
    auto* zoom_scroll = gtk_event_controller_scroll_new(
        static_cast<GtkEventControllerScrollFlags>(
            GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES | GTK_EVENT_CONTROLLER_SCROLL_DISCRETE));
    gtk_event_controller_set_propagation_phase(
        GTK_EVENT_CONTROLLER(zoom_scroll), GTK_PHASE_CAPTURE);
    g_signal_connect(
        zoom_scroll,
        "scroll",
        G_CALLBACK(+[](GtkEventControllerScroll*, double dx, double dy, gpointer data) -> gboolean {
            auto* self = static_cast<NetworkPage*>(data);
            if (!self->m_viewport) return GDK_EVENT_PROPAGATE;
            const double delta = (std::abs(dy) >= std::abs(dx)) ? dy : dx;
            if (delta == 0.0) return GDK_EVENT_PROPAGATE;
 
            self->noteUserViewportInteraction();
 
            double zoom = shumate_viewport_get_zoom_level(self->m_viewport);
            const double step = std::abs(delta) < 1.0 ? 0.25 : 0.45;
            zoom += (delta < 0.0) ? step : -step;
            zoom = std::clamp(zoom, kMinZoom, kMaxZoom);
            shumate_viewport_set_zoom_level(self->m_viewport, zoom);
            self->triggerFxRedraw();
            return GDK_EVENT_STOP;
        }),
        this
    );
    gtk_widget_add_controller(m_mapOverlay, GTK_EVENT_CONTROLLER(zoom_scroll));
 
    m_mapFxArea = gtk_drawing_area_new();
    gtk_widget_set_hexpand(m_mapFxArea, TRUE);
    gtk_widget_set_vexpand(m_mapFxArea, TRUE);
    gtk_widget_set_can_target(m_mapFxArea, FALSE);
    // Passiamo `this` come user_data cosi' map_fx_draw puo' accedere ai pin.
    gtk_drawing_area_set_draw_func(GTK_DRAWING_AREA(m_mapFxArea),
                                   map_fx_draw, this, nullptr);
    gtk_overlay_add_overlay(GTK_OVERLAY(m_mapOverlay), m_mapFxArea);
 
    m_hoverCard = createHoverCard();
    gtk_overlay_add_overlay(GTK_OVERLAY(m_mapOverlay), m_hoverCard);
 
    gtk_widget_set_focusable(m_mapOverlay, TRUE);
    gtk_widget_set_hexpand(m_mapOverlay, TRUE);
    gtk_widget_set_vexpand(m_mapOverlay, FALSE);
    gtk_widget_set_size_request(m_mapOverlay, 720, 475);
 
    gtk_box_append(GTK_BOX(m_mapHost.gobj()), m_mapOverlay);
}
 
GtkWidget* NetworkPage::createMarkerWidget(const Pin& pin)
{
    auto* marker = shumate_marker_new();
 
    // ── Ancoraggio del marker ────────────────────────────────────────
    // Problema visto nelle screenshot utente: il cerchio rosso della
    // destinazione risultava disegnato sopra la posizione reale (dove
    // arriva l'arco arancione), creando un gap di ~20-30 px.
    //
    // Causa: il vecchio layout usava un Gtk::Box verticale [badge, dot]
    // ancorato via valign=END sulla coordinata. Ma Shumate centra il
    // widget sulla coordinata (non allinea il bordo), quindi il BOX
    // veniva centrato e il cerchio — che era META' in basso del box —
    // finiva sotto la coordinata, mentre il badge — meta' sopra —
    // finiva sopra. Risultato: i due elementi stavano AI LATI della
    // coordinata, con l'arco che puntava al punto medio tra i due.
    //
    // Fix: usiamo Gtk::Overlay col cerchio come widget base CENTRATO
    // (cosi' il suo centro coincide con la coordinata geografica), e
    // il badge paese come OVERLAY posizionato con margin-bottom positivo
    // per galleggiare sopra il cerchio senza spostarlo.
    auto* overlay = gtk_overlay_new();
    auto* dot = create_animated_dot_widget(pin.hits);
    gtk_widget_set_halign(dot, GTK_ALIGN_CENTER);
    gtk_widget_set_valign(dot, GTK_ALIGN_CENTER);
    gtk_overlay_set_child(GTK_OVERLAY(overlay), dot);
 
    if (!pin.country_code.empty()) {
        auto* badge = gtk_label_new(pin.country_code.c_str());
        gtk_widget_add_css_class(badge, "caption");
        gtk_widget_add_css_class(badge, "numeric");
        gtk_widget_add_css_class(badge, "bsc-network-marker-badge");
        gtk_widget_set_opacity(badge, 0.94);
 
        // Badge galleggia SOPRA il cerchio, sfalsato a destra cosi' non
        // lo copre. Con halign=START e valign=START + margin, il badge
        // si posiziona in alto-sinistra dentro l'overlay, ma sopra il
        // cerchio (dimensione overlay = dimensione cerchio centrato).
        // Per uscire dai bounds del cerchio e mostrarsi sopra/a lato,
        // usiamo margin negativi — GTK lo permette sugli overlay child.
        gtk_widget_set_halign(badge, GTK_ALIGN_CENTER);
        gtk_widget_set_valign(badge, GTK_ALIGN_START);
        gtk_widget_set_margin_top(badge, -18);
        gtk_overlay_add_overlay(GTK_OVERLAY(overlay), badge);
    }
 
    auto* payload = new HoverPayload{};
    payload->self = this;
    payload->ip = pin.ip;
    payload->host = pin.host;
    payload->app_name = pin.app_name;
    payload->country_code = pin.country_code;
    payload->country_name = pin.country_name;
    payload->city = pin.city;
    payload->isp = pin.isp;
    payload->hits = pin.hits;
 
    auto* motion = gtk_event_controller_motion_new();
 
    g_signal_connect_data(
        motion,
        "enter",
        G_CALLBACK(+[](GtkEventControllerMotion*, double, double, gpointer data) {
            auto* payload = static_cast<HoverPayload*>(data);
            payload->self->showHoverCard(
                payload->country_code,
                payload->country_name,
                payload->city,
                payload->ip,
                payload->host,
                payload->app_name,
                payload->isp,
                payload->hits
            );
        }),
        payload,
        hover_payload_destroy,
        G_CONNECT_DEFAULT
    );
 
    g_signal_connect(
        motion,
        "leave",
        G_CALLBACK(+[](GtkEventControllerMotion*, gpointer data) {
            static_cast<NetworkPage*>(data)->hideHoverCard();
        }),
        this
    );
 
    gtk_widget_add_controller(overlay, GTK_EVENT_CONTROLLER(motion));
 
    shumate_marker_set_child(marker, overlay);
    // valign CENTER (era END): con CENTER il widget viene centrato verticalmente
    // sulla coordinata. Combinato col cerchio centrato dentro l'overlay, il
    // CENTRO del cerchio coincide ora con la coordinata geografica esatta —
    // e quindi con il punto di arrivo dell'arco arancione.
    gtk_widget_set_halign(GTK_WIDGET(marker), GTK_ALIGN_CENTER);
    gtk_widget_set_valign(GTK_WIDGET(marker), GTK_ALIGN_CENTER);
    shumate_marker_set_selectable(marker, FALSE);
    shumate_location_set_location(SHUMATE_LOCATION(marker), pin.lat, pin.lon);
 
    return GTK_WIDGET(marker);
}
 
void NetworkPage::maybeRecenterMap(const std::vector<Pin>& pins)
{
    if (m_viewport == nullptr) return;
    if (shouldHoldUserViewport()) return;
 
    // Raccoglie lat/lon di TUTTI i punti che devono essere visibili: pin
    // destinazione validi + la posizione del PC locale (se risolta).
    // Cosi' il fit automatico non nasconde mai il punto blu — era uno
    // dei bug nelle screenshot precedenti dove il marker blu scompariva
    // dietro altri marker o fuori viewport.
    struct LL { double lat, lon; };
    std::vector<LL> all;
    all.reserve(pins.size() + 1);
 
    for (const auto& p : pins) {
        if (p.geo_resolved && !(p.lat == 0.0 && p.lon == 0.0)) {
            all.push_back({p.lat, p.lon});
        }
    }
    if (m_selfResolved && !(m_selfLat == 0.0 && m_selfLon == 0.0)) {
        all.push_back({m_selfLat, m_selfLon});
    }
 
    if (all.empty()) {
        shumate_location_set_location(
            SHUMATE_LOCATION(m_viewport),
                                      kDefaultLat,
                                      kDefaultLon
        );
        shumate_viewport_set_zoom_level(m_viewport, kDefaultZoom);
        return;
    }
 
    double min_lat = all.front().lat;
    double max_lat = all.front().lat;
    double min_lon = all.front().lon;
    double max_lon = all.front().lon;
 
    for (const auto& q : all) {
        min_lat = std::min(min_lat, q.lat);
        max_lat = std::max(max_lat, q.lat);
        min_lon = std::min(min_lon, q.lon);
        max_lon = std::max(max_lon, q.lon);
    }
 
    const double center_lat = (min_lat + max_lat) * 0.5;
    const double center_lon = (min_lon + max_lon) * 0.5;
    const double span = std::max(max_lat - min_lat, max_lon - min_lon);
 
    // Auto-zoom "cluster aware": piu' i pin sono concentrati, piu' zoommiamo.
    // Numeri tarati sullo schermo 720×475 del map widget.
    //
    // Prima della v3 (con finestra 30s) bastava uno zoom basso perche'
    // tipicamente c'erano 2-5 pin sparsi. Ora l'utente accumula
    // connessioni per giorni: uno zoom piu' ravvicinato evidenzia meglio
    // le concentrazioni geografiche (la citta' del PC vs un singolo
    // data center all'estero) senza far sparire il contesto mondiale.
    double zoom;
    if      (span < 0.5)   zoom = 9.0;     // stessa citta'
    else if (span < 2.0)   zoom = 7.0;     // stessa regione
    else if (span < 5.0)   zoom = 6.0;     // paese piccolo
    else if (span < 12.0)  zoom = 5.0;     // paese grande
    else if (span < 25.0)  zoom = 4.2;     // multi-paese
    else if (span < 50.0)  zoom = 3.6;     // continente
    else if (span < 100.0) zoom = 3.0;     // emisfero
    else                   zoom = kDefaultZoom;  // mondo
 
    zoom = std::clamp(zoom, kMinZoom, kMaxZoom);
 
    shumate_location_set_location(
        SHUMATE_LOCATION(m_viewport),
                                  center_lat,
                                  center_lon
    );
    shumate_viewport_set_zoom_level(m_viewport, zoom);
}
 
void NetworkPage::rebuildMapMarkers()
{
    if (m_markerLayer == nullptr) return;
 
    hideHoverCard();
 
    std::vector<Pin> pins_copy;
    {
        std::lock_guard lk(m_mu);
        pins_copy.reserve(m_pins.size());
        for (const auto& [_, p] : m_pins) pins_copy.push_back(p);
    }
 
    std::sort(
        pins_copy.begin(),
              pins_copy.end(),
              [](const Pin& a, const Pin& b) { return a.hits < b.hits; }
    );
 
    shumate_marker_layer_remove_all(m_markerLayer);
 
    // Prima tutti i marker destinazione (arancioni)...
    for (const auto& p : pins_copy) {
        if (!p.geo_resolved || (p.lat == 0.0 && p.lon == 0.0)) continue;
 
        auto* marker_widget = createMarkerWidget(p);
        shumate_marker_layer_add_marker(
            m_markerLayer,
            SHUMATE_MARKER(marker_widget)
        );
    }
 
    // ...poi il marker PC locale per ULTIMO, cosi' sta SOPRA le destinazioni
    // anche quando coincidono spazialmente (es. connessione a localhost
    // o a un server nello stesso paese). Il punto blu e' l'ancora visiva
    // della mappa e non deve mai venire nascosto.
    if (m_selfResolved) {
        auto* self_marker = createSelfMarkerWidget();
        shumate_marker_layer_add_marker(
            m_markerLayer, SHUMATE_MARKER(self_marker));
    }
 
    maybeRecenterMap(pins_copy);
}
 
void NetworkPage::noteUserViewportInteraction()
{
    m_lastUserViewportInteraction = std::chrono::steady_clock::now();
}
 
bool NetworkPage::shouldHoldUserViewport() const
{
    if (m_lastUserViewportInteraction == std::chrono::steady_clock::time_point{}) return false;
    return (std::chrono::steady_clock::now() - m_lastUserViewportInteraction) < kUserViewportHold;
}
 
void NetworkPage::noteConnection(const ConnectionInfo& info)
{
    const std::string& ip = info.dest_ip;
    if (ip.empty()) return;
 
    bool need_geo = false;
    {
        std::lock_guard lk(m_mu);
        const bool safe_local = bsc::ui_util::is_safe_local_connection(info.dest_ip, info.src_ip);
        const std::string conn_app_name = bsc::ui_util::best_connection_display_name(
            info.app_comm, info.app_path, info.app_args, info.dest_ip, info.src_ip);
 
        auto& p = m_pins[ip];
        if (p.ip.empty()) {
            p.ip = ip;
            p.host = info.dest_host.empty() && safe_local
                ? std::string{"Connessione locale sicura"}
                : info.dest_host;
            p.app_name = conn_app_name;
            if (safe_local) {
                p.country_name = "Locale sicuro";
                p.city = "Loopback";
                p.isp = "Sistema locale";
                p.geo_resolved = false;
                need_geo = false;
            } else {
                need_geo = true;
            }
        } else {
            if (!conn_app_name.empty() && p.app_name.find(conn_app_name) == std::string::npos) {
                p.app_name = p.app_name.empty()
                ? conn_app_name
                : conn_app_name + ", " + p.app_name;
            }
            if (p.host.empty() && !info.dest_host.empty())
                p.host = info.dest_host;
        }
 
        ++p.hits;
        p.last_seen = std::chrono::steady_clock::now();
        p.last_seen_epoch = static_cast<int64_t>(std::time(nullptr));
    }
 
    if (need_geo) {
        if (auto geo = bsc::ui_util::GeoResolver::instance().resolve(ip)) {
            std::lock_guard lk(m_mu);
            auto it = m_pins.find(ip);
            if (it != m_pins.end()) {
                it->second.country_code = geo->country_code;
                it->second.country_name = geo->country_name;
                it->second.city = geo->city;
                it->second.isp = geo->isp.empty() ? geo->asn : geo->isp;
                it->second.lat = geo->lat;
                it->second.lon = geo->lon;
                it->second.geo_resolved = true;
            }
        }
    }
 
    {
        std::lock_guard lk(m_mu);
        auto it = m_pins.find(ip);
        if (it != m_pins.end()) {
            updateRow(it->second);
        }
    }
 
    rebuildMapMarkers();
    updateSummary();
 
    // Salvataggio periodico (ogni 20 connessioni) per resistere a crash.
    // Il salvataggio e' fast: tipicamente < 5 ms con <100 pin, ma non
    // vogliamo farlo ad ogni singola connessione.
    static thread_local int save_counter = 0;
    if (++save_counter >= 20) {
        save_counter = 0;
        saveLog();
    }
}
 
void NetworkPage::onGeoResolved()
{
    std::vector<std::pair<std::string, bsc::ui_util::GeoEntry>> pending;
    {
        std::lock_guard lk(m_pendingMu);
        pending.swap(m_pendingGeo);
    }
 
    bool self_updated = false;
    {
        std::lock_guard lk(m_mu);
        for (const auto& [ip, geo] : pending) {
            // Risoluzione speciale: posizione del PC locale.
            if (ip == "__self__") {
                m_selfLat = geo.lat;
                m_selfLon = geo.lon;
                m_selfResolved = true;
                self_updated = true;
                continue;
            }
 
            auto it = m_pins.find(ip);
            if (it == m_pins.end()) continue;
 
            it->second.country_code = geo.country_code;
            it->second.country_name = geo.country_name;
            it->second.city = geo.city;
            it->second.isp = geo.isp.empty() ? geo.asn : geo.isp;
            it->second.lat = geo.lat;
            it->second.lon = geo.lon;
            it->second.geo_resolved = true;
 
            updateRow(it->second);
        }
    }
 
    rebuildMapMarkers();
    updateSummary();
 
    // Se la posizione locale e' appena arrivata, forza anche un redraw
    // degli archi (altrimenti restano invisibili finche' non arriva una
    // nuova connessione).
    if (self_updated) triggerFxRedraw();
}
 
void NetworkPage::updateRow(const Pin& pin)
{
    Glib::ustring country_cell;
    if (pin.country_code.empty()) {
        country_cell = pin.country_name.empty()
        ? Glib::ustring("?")
        : Glib::ustring(pin.country_name);
    } else {
        country_cell = Glib::ustring(pin.country_code + "  " + pin.country_name);
    }
 
    auto it = m_rows.find(pin.ip);
    if (it != m_rows.end()) {
        auto row = *(it->second);
        row[m_columns.col_country] = country_cell;
        row[m_columns.col_city]    = pin.city;
        row[m_columns.col_ip]      = pin.ip;
        row[m_columns.col_host]    = pin.host;
        row[m_columns.col_app]     = pin.app_name;
        row[m_columns.col_isp]     = pin.isp;
        row[m_columns.col_hits]    = pin.hits;
        return;
    }
 
    auto iter = m_store->append();
    auto row  = *iter;
    row[m_columns.col_country] = country_cell;
    row[m_columns.col_city]    = pin.city;
    row[m_columns.col_ip]      = pin.ip;
    row[m_columns.col_host]    = pin.host;
    row[m_columns.col_app]     = pin.app_name;
    row[m_columns.col_isp]     = pin.isp;
    row[m_columns.col_hits]    = pin.hits;
 
    m_rows.emplace(pin.ip, iter);
}
 
void NetworkPage::updateSummary()
{
    std::size_t total_ips = 0;
    std::size_t total_hits = 0;
    std::size_t countries = 0;
    std::unordered_map<std::string, int> seen_countries;
 
    {
        std::lock_guard lk(m_mu);
        total_ips = m_pins.size();
 
        for (const auto& [_, p] : m_pins) {
            total_hits += p.hits;
            if (!p.country_code.empty() && !seen_countries.count(p.country_code)) {
                seen_countries[p.country_code] = 1;
            }
        }
 
        countries = seen_countries.size();
    }
 
    std::ostringstream oss;
    oss << total_ips << " IP · " << total_hits << " conn. · "
    << countries << " paesi";
    m_summaryLabel.set_text(oss.str());
}
 
// ---------------------------------------------------------------------------
// Nuovo (stile Little Snitch): marker PC locale + archi verso le connessioni
// ---------------------------------------------------------------------------
 
void NetworkPage::requestSelfLocation()
{
    // Tenta subito dalla cache. Se cache miss, il worker di GeoResolver
    // fara' il fetch e chiamera' on_resolved con ip="__self__"; il nostro
    // onGeoResolved() lo riconoscera' e popolera' m_selfLat/Lon.
    if (auto maybe = bsc::ui_util::GeoResolver::instance().resolve_self()) {
        m_selfLat = maybe->lat;
        m_selfLon = maybe->lon;
        m_selfResolved = true;
        rebuildMapMarkers();
    }
    // Altrimenti: il lookup e' in corso. L'aggiornamento arrivera' via
    // onGeoResolved() al completamento.
}
 
GtkWidget* NetworkPage::createSelfMarkerWidget()
{
    // Marker del PC locale: cerchio blu con pulse esterno.
    // Usa shumate_marker come contenitore e un Gtk::DrawingArea custom
    // per disegnare un cerchio blu con alone che pulsa.
    //
    // Questo marker e' l'ANCORA visiva della mappa — deve restare sempre
    // ben riconoscibile sotto qualunque sovrapposizione. Dimensioni e
    // colori scelti per massima visibilita' anche a zoom alti dove i
    // marker destinazione si addensano.
    auto* marker = shumate_marker_new();
    auto* area   = gtk_drawing_area_new();
 
    // Dimensione fissa — il "blob" occupa 32×32 px, piu' grande dei marker
    // destinazione (tipicamente 16-20 px). Il pulse si espande fino a 14 px
    // di raggio esterno.
    gtk_widget_set_size_request(area, 32, 32);
 
    gtk_drawing_area_set_draw_func(
        GTK_DRAWING_AREA(area),
        +[](GtkDrawingArea*, cairo_t* cr, int w, int h, gpointer) {
            const double cx = w * 0.5;
            const double cy = h * 0.5;
 
            // Pulse sinusoidale 0..1 con periodo 2 secondi
            const gint64 us = g_get_monotonic_time();
            const double t  = (us % 2000000) / 2000000.0;
            const double pulse = 0.5 * (1.0 - std::cos(t * 2.0 * M_PI));
 
            // Alone pulsante (blu molto trasparente, si espande)
            const double ring_r = 10.0 + pulse * 6.0;
            const double ring_a = 0.45 * (1.0 - pulse);
            cairo_set_source_rgba(cr, 0.20, 0.60, 1.0, ring_a);
            cairo_arc(cr, cx, cy, ring_r, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Drop shadow: cerchio nero sfumato sotto, per staccare dal
            // fondo della mappa (mare/terra mischiati).
            cairo_set_source_rgba(cr, 0.0, 0.0, 0.0, 0.35);
            cairo_arc(cr, cx, cy + 1.0, 9.0, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Anello bianco esterno (bordo di contrasto)
            cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 1.0);
            cairo_arc(cr, cx, cy, 9.0, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Cerchio pieno blu centrale (il vero marker)
            cairo_set_source_rgba(cr, 0.15, 0.50, 1.0, 1.0);
            cairo_arc(cr, cx, cy, 7.0, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
 
            // Riflesso bianco in alto a sinistra — tocco 3D discreto
            cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0.55);
            cairo_arc(cr, cx - 2.0, cy - 2.0, 2.2, 0.0, 2.0 * M_PI);
            cairo_fill(cr);
        },
        nullptr, nullptr);
 
    shumate_marker_set_child(SHUMATE_MARKER(marker), area);
    shumate_location_set_location(SHUMATE_LOCATION(marker),
                                  m_selfLat, m_selfLon);
    return GTK_WIDGET(marker);
}
 
void NetworkPage::drawConnectionArcs(cairo_t* cr, int width, int height)
{
    if (!m_viewport || !m_selfResolved) return;
    if (width <= 0 || height <= 0) return;
 
    // Converte lat/lon del PC in pixel sul widget mappa.
    // NOTA: le coordinate sono relative a m_simpleMap (widget sotto);
    // l'overlay DrawingArea ha la stessa geometria — stesso sistema.
    double sx = 0.0, sy = 0.0;
    shumate_viewport_location_to_widget_coords(
        m_viewport, m_simpleMap,
        m_selfLat, m_selfLon, &sx, &sy);
 
    // Origine fuori dalla mappa visibile: non abbiamo un punto di partenza
    // valido, skippiamo tutti gli archi (altrimenti partirebbero dal bordo
    // in modo misterioso — come nella screenshot dell'utente: freccia che
    // scende "dal nulla"). Stesso criterio dei target.
    const bool self_visible =
        sx >= 0 && sx <= width && sy >= 0 && sy <= height;
 
    // Snapshot di TUTTI i pin sulla mappa (non solo gli ultimi 30 s).
    // L'utente ha chiesto di vedere tutto lo storico — al limite sparisce
    // solo oltre i 7 giorni via retention al loadLog().
    struct Arc { double tx, ty; bool visible; uint32_t hits; };
    std::vector<Arc> arcs;
    {
        std::lock_guard lk(m_mu);
        arcs.reserve(m_pins.size());
        for (const auto& [ip, p] : m_pins) {
            if (!p.geo_resolved) continue;
            // Salta pin con lat/lon degenere (geoip fallita o "Locale")
            if (p.lat == 0.0 && p.lon == 0.0) continue;
            double tx = 0.0, ty = 0.0;
            shumate_viewport_location_to_widget_coords(
                m_viewport, m_simpleMap, p.lat, p.lon, &tx, &ty);
            // Visibilita' STRETTA: il target deve essere COMPLETAMENTE dentro
            // il viewport. Nessun margin: un arco che "esce" dalla mappa
            // senza mostrare il puntino di arrivo e' confuso per l'utente.
            const bool visible =
                tx >= 0 && tx <= width &&
                ty >= 0 && ty <= height;
            arcs.push_back({tx, ty, visible, p.hits});
        }
    }
 
    // Pulse per i puntini destinazione (stessa fase per tutti — piu'
    // pulito visivamente di un pulse sfasato).
    const gint64 us = g_get_monotonic_time();
    const double t = (us % 1400000) / 1400000.0;   // periodo 1.4s
    const double pulse = 0.5 * (1.0 - std::cos(t * 2.0 * M_PI));
 
    cairo_save(cr);
 
    // Disegna ogni arco: linea curva dal PC al target, poi puntino lampeggiante.
    // Richiede entrambi i punti visibili, altrimenti l'arco "mozzato" al bordo
    // e' peggio di nessun arco.
    for (const auto& a : arcs) {
        if (!a.visible || !self_visible) continue;
 
        // Se origine e destinazione sono praticamente coincidenti (stessa
        // citta' / stesso data center) niente arco — sarebbe un cerchietto
        // illeggibile. Il puntino destinazione si vede comunque grazie al
        // marker arancione di Shumate.
        const double dx_ = a.tx - sx;
        const double dy_ = a.ty - sy;
        const double dist = std::sqrt(dx_ * dx_ + dy_ * dy_);
        if (dist < 8.0) continue;
 
        // Linea dritta con lieve curvatura ascendente (effetto "arco").
        // Il control point e' a meta' strada, spostato perpendicolarmente
        // al segmento per dare profondita'.
        const double mx = (sx + a.tx) * 0.5;
        const double my = (sy + a.ty) * 0.5;
        // Normale perpendicolare al segmento, normalizzata
        const double nx = -dy_ / dist;
        const double ny =  dx_ / dist;
        const double curve = std::min(60.0, dist * 0.18);
        const double cx = mx + nx * curve;
        const double cy = my + ny * curve;
 
        // Colore linea: arancione morbido con opacita' che cresce con hit count
        const double alpha = std::clamp(0.35 + 0.05 * std::log1p(a.hits), 0.35, 0.80);
        cairo_set_source_rgba(cr, 1.0, 0.60, 0.22, alpha);
        cairo_set_line_width(cr, 1.5);
        cairo_move_to(cr, sx, sy);
        cairo_curve_to(cr, cx, cy, cx, cy, a.tx, a.ty);
        cairo_stroke(cr);
 
        // Puntino destinazione lampeggiante (alone + cerchio pieno)
        const double ring_r = 5.0 + pulse * 5.0;
        const double ring_a = 0.55 * (1.0 - pulse);
        cairo_set_source_rgba(cr, 1.0, 0.60, 0.22, ring_a);
        cairo_arc(cr, a.tx, a.ty, ring_r, 0.0, 2.0 * M_PI);
        cairo_fill(cr);
 
        cairo_set_source_rgba(cr, 1.0, 0.70, 0.30, 1.0);
        cairo_arc(cr, a.tx, a.ty, 3.5, 0.0, 2.0 * M_PI);
        cairo_fill(cr);
    }
 
    cairo_restore(cr);
}
 
void NetworkPage::triggerFxRedraw()
{
    if (m_mapFxArea) gtk_widget_queue_draw(m_mapFxArea);
}
 
void NetworkPage::clear()
{
    {
        std::lock_guard lk(m_mu);
        m_pins.clear();
        m_rows.clear();
    }
 
    m_store->clear();
    rebuildMapMarkers();
    updateSummary();
 
    // Cancella anche il log persistente: "Pulisci" e' un reset completo.
    std::error_code ec;
    std::filesystem::remove(logPath(), ec);
}
 
// ---------------------------------------------------------------------------
// Persistenza pin (retention 7 giorni)
// ---------------------------------------------------------------------------
// Formato: JSON Lines. Una riga per pin con tutti i campi necessari a
// ricostruire marker e tabella. Il geo_resolved si deriva dalla presenza
// di lat/lon non nulle.
 
std::string NetworkPage::logPath()
{
    return "/tmp/bastionguard-sc-network-" +
           std::to_string(::getuid()) + ".jsonl";
}
 
namespace {
    // Escape minimo per stringhe JSON (quote, backslash, control chars).
    // Duplicato da ConnectionsPage — sarebbe piu' pulito in un util
    // comune ma non vale la pena per 20 righe.
    std::string net_json_escape(const std::string& s) {
        std::string out;
        out.reserve(s.size());
        for (unsigned char c : s) {
            switch (c) {
                case '"':  out += "\\\""; break;
                case '\\': out += "\\\\"; break;
                case '\n': out += "\\n";  break;
                case '\r': out += "\\r";  break;
                case '\t': out += "\\t";  break;
                default:
                    if (c < 0x20) {
                        char b[8];
                        std::snprintf(b, sizeof(b), "\\u%04x", c);
                        out += b;
                    } else {
                        out += static_cast<char>(c);
                    }
            }
        }
        return out;
    }
 
    // Parser ultra-semplice per i nostri log: chiave stringa o numero.
    // Non gestisce tutti i casi generali (array nested, etc.) — ma i nostri
    // record sono flat e controllati da noi, quindi basta.
    std::string net_json_field_str(const std::string& line,
                                   const std::string& key) {
        const std::string needle = "\"" + key + "\":\"";
        auto pos = line.find(needle);
        if (pos == std::string::npos) return {};
        pos += needle.size();
        auto end = line.find('"', pos);
        return end == std::string::npos ? std::string{}
                                        : line.substr(pos, end - pos);
    }
 
    double net_json_field_double(const std::string& line,
                                 const std::string& key) {
        const std::string needle = "\"" + key + "\":";
        auto pos = line.find(needle);
        if (pos == std::string::npos) return 0.0;
        pos += needle.size();
        return std::strtod(line.c_str() + pos, nullptr);
    }
 
    int64_t net_json_field_i64(const std::string& line,
                               const std::string& key) {
        const std::string needle = "\"" + key + "\":";
        auto pos = line.find(needle);
        if (pos == std::string::npos) return 0;
        pos += needle.size();
        return std::strtoll(line.c_str() + pos, nullptr, 10);
    }
}
 
void NetworkPage::saveLog() const
{
    std::ofstream f(logPath(), std::ios::trunc);
    if (!f.is_open()) return;
 
    // Snapshot sotto lock per non bloccare la UI durante I/O. m_mu
    // protegge m_pins.
    std::vector<Pin> snapshot;
    {
        std::lock_guard lk(m_mu);
        snapshot.reserve(m_pins.size());
        for (const auto& [ip, p] : m_pins) snapshot.push_back(p);
    }
 
    for (const auto& p : snapshot) {
        // Skippiamo pin non geo-risolti: ricostruirli al prossimo avvio
        // significherebbe rifare le chiamate a ip-api e potrebbe esaurire
        // il rate limit. Se proprio serve verranno riaggiunti alla prima
        // connessione dopo restart.
        if (!p.geo_resolved) continue;
 
        f << "{\"ip\":\""          << net_json_escape(p.ip)           << "\""
          << ",\"host\":\""        << net_json_escape(p.host)         << "\""
          << ",\"app\":\""         << net_json_escape(p.app_name)     << "\""
          << ",\"cc\":\""          << net_json_escape(p.country_code) << "\""
          << ",\"country\":\""     << net_json_escape(p.country_name) << "\""
          << ",\"city\":\""        << net_json_escape(p.city)         << "\""
          << ",\"isp\":\""         << net_json_escape(p.isp)          << "\""
          << ",\"lat\":"           << p.lat
          << ",\"lon\":"           << p.lon
          << ",\"hits\":"          << p.hits
          << ",\"last_ts\":"       << p.last_seen_epoch
          << "}\n";
    }
}
 
void NetworkPage::loadLog()
{
    std::ifstream f(logPath());
    if (!f.is_open()) return;
 
    const int64_t now_epoch   = static_cast<int64_t>(std::time(nullptr));
    const int64_t cutoff      = now_epoch - kRetentionSeconds;
    int loaded = 0, dropped = 0;
 
    std::string line;
    while (std::getline(f, line)) {
        if (line.empty() || line[0] != '{') continue;
 
        const int64_t ts = net_json_field_i64(line, "last_ts");
        // Retention 7 giorni: record piu' vecchi vengono scartati.
        if (ts > 0 && ts < cutoff) { ++dropped; continue; }
 
        Pin p;
        p.ip           = net_json_field_str(line, "ip");
        if (p.ip.empty()) continue;
        p.host         = net_json_field_str(line, "host");
        p.app_name     = net_json_field_str(line, "app");
        p.country_code = net_json_field_str(line, "cc");
        p.country_name = net_json_field_str(line, "country");
        p.city         = net_json_field_str(line, "city");
        p.isp          = net_json_field_str(line, "isp");
        p.lat          = net_json_field_double(line, "lat");
        p.lon          = net_json_field_double(line, "lon");
        p.hits         = static_cast<uint32_t>(net_json_field_i64(line, "hits"));
        p.last_seen_epoch = ts;
        // last_seen (steady_clock) non e' ricostruibile esattamente —
        // lo impostiamo a "adesso meno delta" cosi' le animazioni che
        // usano last_seen non impazziscono. Non piu' usato per culling.
        p.last_seen    = std::chrono::steady_clock::now();
        p.geo_resolved = !(p.lat == 0.0 && p.lon == 0.0);
 
        std::lock_guard lk(m_mu);
        m_pins[p.ip] = p;
        updateRow(m_pins[p.ip]);
        ++loaded;
    }
 
    rebuildMapMarkers();
    updateSummary();
 
    g_message("NetworkPage: caricati %d pin, scartati %d per retention 7gg",
              loaded, dropped);
}