PCM.py

#!/usr/bin/env python3
"""
PCM - Python Connection Manager (GTK3 port)
Ispirato a MobaXterm, sviluppato in Python/GTK3.

Licensed under the European Union Public Licence (EUPL) v1.2
© 2025 - All rights reserved

Dipendenze:
  python3-gi
  gir1.2-gtk-3.0
  gir1.2-vte-2.91
  gir1.2-gtk-vnc-2.0   (VNC integrato nativo)
  python3-paramiko      (SFTP)

FreeBSD equivalenti:
  py311-gobject3  vte3  gtk-vnc  py311-paramiko
"""

import sys
import os
import subprocess
import shutil
import threading
import tempfile
import contextlib
from urllib.parse import urlparse

# ── Controllo dipendenze all'avvio ────────────────────────────────────────────
def _check_deps():
    errors = []
    hints = []

    # Python >= 3.10
    if sys.version_info < (3, 10):
        errors.append(f"Python 3.10+ richiesto (trovato {sys.version.split()[0]})")
        hints.append("Aggiorna Python: https://www.python.org/downloads/")

    # gi / PyGObject
    try:
        import gi as _gi
    except ImportError:
        errors.append("PyGObject (python3-gi) non installato")
        hints.append("  Debian/Ubuntu : sudo apt install python3-gi python3-gi-cairo")
        hints.append("  Arch          : sudo pacman -S python-gobject")
        hints.append("  Fedora        : sudo dnf install python3-gobject")

    if errors:
        _die(errors, hints)

    # GTK 3.0
    try:
        import gi as _gi
        _gi.require_version("Gtk", "3.0")
        from gi.repository import Gtk as _Gtk  # noqa: F401
    except (ValueError, ImportError):
        errors.append("GTK 3.0 non disponibile (gir1.2-gtk-3.0 / typelib-1_0-Gtk-3_0)")
        hints.append("  Debian/Ubuntu : sudo apt install gir1.2-gtk-3.0 libgtk-3-0")
        hints.append("  Arch          : sudo pacman -S gtk3")
        hints.append("  Fedora        : sudo dnf install gtk3")

    # VTE 2.91
    try:
        import gi as _gi
        _gi.require_version("Vte", "2.91")
        from gi.repository import Vte as _Vte  # noqa: F401
    except (ValueError, ImportError):
        errors.append("VTE 2.91 non disponibile (gir1.2-vte-2.91 / typelib-1_0-Vte-2_91)")
        hints.append("  Debian/Ubuntu : sudo apt install gir1.2-vte-2.91 libvte-2.91-0")
        hints.append("  Arch          : sudo pacman -S vte3")
        hints.append("  Fedora        : sudo dnf install vte291")

    if errors:
        _die(errors, hints)


def _die(errors, hints):
    SEP = "═" * 62
    print(f"\n╔{SEP}╗")
    print( "║  PCM — dipendenze mancanti                               ║")
    print(f"╠{SEP}╣")
    for e in errors:
        print(f"║  ✗  {e}")
    if hints:
        print(f"╠{SEP}╣")
        print( "║  Installa le dipendenze mancanti:                        ║")
        for h in hints:
            print(f"║  {h}")
    print(f"╚{SEP}╝\n")
    sys.exit(1)


_check_deps()
# ─────────────────────────────────────────────────────────────────────────────

import gi
gi.require_version("Gtk", "3.0")
gi.require_version("Vte", "2.91")
from gi.repository import Gtk, GLib, Gio

from pcm_logging import get_logger
_log = get_logger("pcm")

# ---------------------------------------------------------------------------
# Moduli PCM (tutti GTK3)
# ---------------------------------------------------------------------------
import config_manager
import translations as _tr
from translations import t
from themes import apply_css
from terminal_widget import TerminalWidget
from session_panel import SessionPanel
from session_dialog import SessionDialog
import protocols
from protocols import refresh_from_plugins as _refresh_protocols
from session_command import build_command
from settings_dialog import SettingsDialog
from tunnel_manager import TunnelManagerDialog, get_active_tunnels, stop_tunnel, reattach_tunnels
from vnc_widget import VncWebWidget
from rdp_widget import RdpEmbedWidget
from sftp_browser import SftpBrowserWidget
from winscp_widget import WinScpWidget, FtpWinScpWidget
from log_viewer import LogViewerWidget
from sysmon_widget import SysMonitorWidget
from panel_monitor import InfoPanelWidget
from cron_widget import CronWidget
from sftp_editor import SftpEditorWidget
from snippets_dialog import SnippetsDialog
from welcome_widget import WelcomeWidget
from quick_connect_dialog import QuickConnectDialog
from plugins.plugin_base import (
    pcm_has_protocol, pcm_build_command, pcm_create_widget,
    pcm_menu_items as _plugin_menu_items,
    pcm_context_actions as _plugin_context_actions,
)
from plugins.plugin_manager import load_plugins as _load_plugins

# ---------------------------------------------------------------------------
# Percorso icone
# ---------------------------------------------------------------------------
_HERE      = os.path.dirname(os.path.abspath(__file__))
_ICONS_DIR = os.path.join(_HERE, "icons")


def _icon_path(name: str) -> str:
    return os.path.join(_ICONS_DIR, name)


def _load_icon(name: str, size: int = 24):
    from gi.repository import GdkPixbuf
    path = _icon_path(name)
    if os.path.isfile(path):
        try:
            return GdkPixbuf.Pixbuf.new_from_file_at_size(path, size, size)
        except Exception as e:
            _log.debug("Icona non caricata '%s': %s", name, e)
    return None


# ===========================================================================
# Finestra principale
# ===========================================================================

class MainWindow(Gtk.ApplicationWindow):

    def __init__(self, app):
        super().__init__(application=app, title=t("app.title"))
        self.set_default_size(1200, 720)
        self.set_position(Gtk.WindowPosition.CENTER)

        _tr.init_from_settings()
        self._settings = config_manager.load_settings()
        config_manager._fix_permissions()
        self._profili:  dict = {}

        # Icona finestra
        pb = _load_icon("app.png", 64)
        if pb:
            self.set_icon(pb)

        self._build_ui()
        self._connect_signals()
        self._setup_accels()
        self._pannello.aggiorna()

        self._auto_lock_timer = 0
        self._avvia_auto_lock()
        self.connect("key-press-event", lambda w, e: self._reset_auto_lock())
        self.connect("motion-notify-event", lambda w, e: self._reset_auto_lock())

        self._pending_cli_uri: str | None = None   # URI da aprire dopo unlock crypto

        # Avvio a cascata: ogni step richiama il successivo dopo il rendering
        # Sblocco credenziali -> notifica tunnel -> ripristino sessioni
        GLib.idle_add(self._startup_chain, 0)

    # ------------------------------------------------------------------
    # Catena di avvio
    # ------------------------------------------------------------------

    def _startup_chain(self, step: int) -> bool:
        """Esegue la catena di inizializzazione a step:
        0: load plugins, 1: unlock crypto, 2: notifica tunnel, 3: restore sessioni, 4: stato live."""
        if step == 0:
            self._load_pcm_plugins()
            GLib.timeout_add(200, self._startup_chain, 1)
        elif step == 1:
            self._check_crypto_unlock()
            GLib.timeout_add(300, self._startup_chain, 2)
        elif step == 2:
            self._notifica_tunnel_avvio()
            GLib.timeout_add(500, self._startup_chain, 3)
        elif step == 3:
            self._ripristina_sessioni()
            GLib.timeout_add(500, self._startup_chain, 4)
        elif step == 4:
            self._timer_stato_live = GLib.timeout_add(3000, self._aggiorna_stato_live)
        return False  # one-shot per ogni step

    # ------------------------------------------------------------------
    # Sblocco credenziali cifrate
    # ------------------------------------------------------------------

    def _load_pcm_plugins(self):
        """Carica i plugin all'avvio e aggiorna il registro protocolli."""
        try:
            loaded = _load_plugins()
            if loaded:
                _refresh_protocols()
                self._pannello.aggiorna()
            _log.info("%d plugin caricati", len(loaded))
        except Exception as e:
            _log.warning("Errore caricamento plugin: %s", e)

    def _check_crypto_unlock(self):
        """Chiamato 300ms dopo l'avvio per sbloccare le credenziali cifrate.

        Gestisce due scenari:
        a) crypto.enabled=True + salt in settings  → flusso normale
        b) ENC: trovati nei profili ma settings incompleto → flusso recovery
           (tipico quando si porta connections.json da un'altra installazione)
        """
        try:
            import crypto_manager
            import config_manager as _cm

            already_unlocked = crypto_manager.is_unlocked()
            if already_unlocked:
                return False

            # --- Scenario A: impostazioni crypto complete ---
            if crypto_manager.is_enabled():
                self._esegui_unlock_dialog()
                return False

            # --- Scenario B: ENC: trovati ma settings incompleto ---
            # Controlla se connections.json ha valori cifrati
            profili = _cm.load_profiles()
            ha_enc = any(
                str(v.get("user","")).startswith("ENC:") or
                str(v.get("password","")).startswith("ENC:")
                for v in profili.values()
            )
            if not ha_enc:
                return False  # nessuna cifratura, niente da fare

            # Ha valori ENC: ma manca la configurazione crypto in settings.
            # Chiedi la password e tenta di recuperare il salt dal vecchio settings.
            s = _cm.load_settings()
            salt_b64 = s.get("crypto", {}).get("salt", "")

            if not salt_b64:
                # Manca il salt: non possiamo decifrare senza il pcm_settings.json originale
                dlg = Gtk.MessageDialog(
                    transient_for=self,
                    modal=True,
                    message_type=Gtk.MessageType.WARNING,
                    buttons=Gtk.ButtonsType.OK,
                    text=t("crypto.unlock.title"),
                    secondary_text=(
                        "Il file connections.json contiene credenziali cifrate (ENC:…)\n"
                        "ma il file pcm_settings.json non contiene il salt di cifratura.\n\n"
                        "Soluzione: copia il pcm_settings.json originale dalla vecchia installazione\n"
                        "e assicurati che contenga la sezione \"crypto\" con salt, verify ed enabled:true.\n\n"
                        "In alternativa, modifica le sessioni manualmente per reinserire le credenziali."
                    )
                )
                dlg.run()
                dlg.destroy()
                return False

            # Il salt c'è ma enabled=False: ripristiniamo enabled e proviamo
            s["crypto"]["enabled"] = True
            _cm.save_settings(s)
            self._esegui_unlock_dialog()

        except ImportError:
            pass
        return False

    _UNLOCK_MAX_TENTATIVI = 3

    def _esegui_unlock_dialog(self):
        """Mostra il dialog password e sblocca le credenziali.

        Consente fino a _UNLOCK_MAX_TENTATIVI tentativi senza dover
        riavviare l'app: alla password sbagliata il dialog si riapre subito.
        Se l'utente annulla, o esaurisce i tentativi, l'app si chiude
        (senza sblocco le sessioni cifrate sarebbero comunque inutilizzabili)."""
        import crypto_manager
        tentativi = 0

        while tentativi < self._UNLOCK_MAX_TENTATIVI:
            dlg = _CryptoUnlockDialog(parent=self)
            resp = dlg.run()
            pwd  = dlg.get_password()
            dlg.destroy()

            if resp != Gtk.ResponseType.OK:
                self.get_application().quit()
                return

            if pwd and crypto_manager.unlock(pwd):
                self._pannello.aggiorna()
                self._aggiorna_welcome_recenti()
                falliti = config_manager.decrypt_failures()
                if falliti:
                    self._warn(
                        "Impossibile decifrare le credenziali di: " + ", ".join(falliti) +
                        " (token corrotto o chiave non corrispondente)"
                    )
                if self._pending_cli_uri:
                    uri, self._pending_cli_uri = self._pending_cli_uri, None
                    GLib.idle_add(self.apri_da_cli, uri)
                return

            tentativi += 1
            rimanenti = self._UNLOCK_MAX_TENTATIVI - tentativi
            err = Gtk.MessageDialog(
                transient_for=self,
                modal=True,
                message_type=Gtk.MessageType.ERROR,
                buttons=Gtk.ButtonsType.OK,
                text=t("crypto.unlock.wrong_master"),
                secondary_text=(
                    f"Tentativi rimasti: {rimanenti}" if rimanenti > 0
                    else "Troppi tentativi errati: l'applicazione verrà chiusa."
                )
            )
            err.run()
            err.destroy()

        self.get_application().quit()

    # ------------------------------------------------------------------
    # Costruzione UI
    # ------------------------------------------------------------------

    def _avvia_auto_lock(self):
        minuti = self._settings.get("general", {}).get("auto_lock_minutes", 15)
        if minuti <= 0:
            return
        if self._auto_lock_timer:
            GLib.source_remove(self._auto_lock_timer)
        self._auto_lock_timer = GLib.timeout_add_seconds(
            minuti * 60, self._lock_now
        )

    def _reset_auto_lock(self):
        if hasattr(self, "_auto_lock_timer") and self._auto_lock_timer:
            GLib.source_remove(self._auto_lock_timer)
        self._avvia_auto_lock()

    def _lock_now(self):
        import crypto_manager
        if crypto_manager.is_enabled() and crypto_manager.is_unlocked():
            crypto_manager.lock()
            _log.info("Cifratura bloccata per inattività")
        self._auto_lock_timer = 0
        return GLib.SOURCE_REMOVE

    def _build_ui(self):
        # Layout radice: headerbar + contenuto
        self._build_headerbar()

        # Paned principale: sidebar | area lavoro
        self._paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        self._paned.set_position(240)
        self.add(self._paned)

        # --- Sidebar ---
        self._pannello = SessionPanel()
        self._paned.pack1(self._pannello, False, False)

        # --- Area lavoro destra: paned orizzontale [terminali | pannello info] ---
        self._paned_right = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        self._paned.pack2(self._paned_right, True, True)

        right_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
        self._paned_right.pack1(right_box, True, True)

        self._info_panel = InfoPanelWidget()
        self._info_panel.set_no_show_all(True)
        # shrink=True: l'utente può trascinare il Paned per restringere il pannello
        self._paned_right.pack2(self._info_panel, False, True)

        # Paned terminali: supporta split verticale/orizzontale
        self._paned_term = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        self._paned_term.set_wide_handle(True)
        self._paned_term.set_position(99999)  # handle fuori schermo in single mode
        right_box.pack_start(self._paned_term, True, True, 0)

        # Notebook primario (sempre visibile)
        self._notebook = Gtk.Notebook()
        self._notebook.set_scrollable(True)
        self._notebook.set_show_border(False)
        self._notebook.connect("switch-page", self._on_switch_tab)
        self._notebook.connect("button-press-event", self._on_nb_button_press)
        self._paned_term.pack1(self._notebook, True, True)

        # Notebook secondario (split — inizialmente nascosto)
        self._notebook2 = Gtk.Notebook()
        self._notebook2.set_scrollable(True)
        self._notebook2.set_show_border(False)
        self._notebook2.set_no_show_all(True)
        self._notebook2.connect("button-press-event", self._on_nb2_button_press)
        self._notebook2.connect("switch-page", self._on_switch_tab)
        self._paned_term.pack2(self._notebook2, True, True)

        # Quale notebook è attivo (aggiornato da switch-page di entrambi)
        self._notebook_attivo = self._notebook

        # page_widget → Gtk.Label dentro la box del tab (per leggere/scrivere il nome)
        self._tab_labels: dict = {}

        # page_widget → Gtk.Notebook (lookup O(1) per _trova_in_notebook)
        self._widget_nb_map: dict = {}

        # Barra inferiore: toast notifications + statusbar
        bottom_bar = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=0)
        bottom_bar.get_style_context().add_class("bottom-bar")

        self._toast_revealer = Gtk.Revealer()
        self._toast_revealer.set_transition_type(Gtk.RevealerTransitionType.SLIDE_UP)
        self._toast_revealer.set_transition_duration(250)
        self._toast_label = Gtk.Label()
        self._toast_label.set_xalign(0.0)
        self._toast_label.set_margin_start(12)
        self._toast_label.set_margin_end(12)
        self._toast_label.set_margin_top(4)
        self._toast_label.set_margin_bottom(4)
        self._toast_close_btn = Gtk.Button()
        self._toast_close_btn.set_relief(Gtk.ReliefStyle.NONE)
        self._toast_close_btn.add(Gtk.Image.new_from_icon_name("window-close-symbolic", Gtk.IconSize.MENU))
        self._toast_close_btn.connect("clicked", lambda b: self._nascondi_toast())
        self._toast_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        self._toast_box.pack_start(self._toast_label, True, True, 0)
        self._toast_box.pack_start(self._toast_close_btn, False, False, 0)
        self._toast_revealer.add(self._toast_box)
        self._toast_timer = 0

        self._statusbar = Gtk.Statusbar()
        self._statusbar_ctx = self._statusbar.get_context_id("main")
        self._statusbar.set_hexpand(True)
        bottom_bar.pack_start(self._statusbar, True, True, 0)

        right_box.pack_start(bottom_bar, False, False, 0)
        bottom_bar.pack_start(self._toast_revealer, True, True, 0)

        # Schermata benvenuto (prima tab)
        self._mostra_benvenuto()

    def _build_headerbar(self):
        hb = Gtk.HeaderBar()
        hb.set_show_close_button(True)
        hb.set_title(t("app.title"))
        self.set_titlebar(hb)

        # Pulsante nuova sessione
        btn_new = Gtk.Button()
        btn_new.set_tooltip_text(t("toolbar.session.tooltip"))
        btn_new.add(Gtk.Image.new_from_icon_name("list-add-symbolic", Gtk.IconSize.BUTTON))
        btn_new.connect("clicked", lambda b: self._on_nuova_sessione())
        hb.pack_start(btn_new)

        # Pulsante terminale locale
        btn_term = Gtk.Button()
        btn_term.set_tooltip_text(t("toolbar.local.tooltip"))
        btn_term.add(Gtk.Image.new_from_icon_name("utilities-terminal-symbolic", Gtk.IconSize.BUTTON))
        btn_term.connect("clicked", lambda b: self._on_terminale_locale())
        hb.pack_start(btn_term)

        # Pulsante quick connect
        btn_qc = Gtk.Button()
        btn_qc.set_tooltip_text(t("toolbar.quickconn.tooltip"))
        btn_qc.add(Gtk.Image.new_from_icon_name("go-jump-symbolic", Gtk.IconSize.BUTTON))
        btn_qc.connect("clicked", lambda b: self._on_quick_connect())
        hb.pack_start(btn_qc)

        # Pulsante cluster
        btn_cl = Gtk.Button()
        btn_cl.set_tooltip_text(t("toolbar.cluster.tooltip"))
        btn_cl.add(Gtk.Image.new_from_icon_name("network-workgroup-symbolic", Gtk.IconSize.BUTTON))
        btn_cl.connect("clicked", lambda b: self._on_cluster_from_toolbar())
        hb.pack_start(btn_cl)

        # Bottone tunnel unificato: indicatore stato + accesso al gestore
        self._btn_tun_ind = Gtk.MenuButton()
        _tun_box = Gtk.Box(spacing=2)
        self._img_tun = Gtk.Image.new_from_icon_name("network-vpn-symbolic", Gtk.IconSize.BUTTON)
        _tun_box.pack_start(self._img_tun, False, False, 0)
        self._lbl_tun_count = Gtk.Label(label="")
        _tun_box.pack_start(self._lbl_tun_count, False, False, 0)
        self._btn_tun_ind.add(_tun_box)
        self._btn_tun_ind.set_tooltip_text(t("tunnel.indicator_tooltip"))

        self._tun_pop = Gtk.Popover()
        self._tun_pop_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self._tun_pop_box.set_margin_start(8)
        self._tun_pop_box.set_margin_end(8)
        self._tun_pop_box.set_margin_top(8)
        self._tun_pop_box.set_margin_bottom(8)
        self._tun_pop.add(self._tun_pop_box)
        self._tun_pop.connect("show", self._on_tun_pop_show)
        self._btn_tun_ind.set_popover(self._tun_pop)
        hb.pack_start(self._btn_tun_ind)

        self._timer_tun_ind = GLib.timeout_add(3000, self._aggiorna_tun_indicator)
        self._aggiorna_tun_indicator()

        # Pulsante split
        btn_split = Gtk.MenuButton()
        btn_split.set_tooltip_text(t("toolbar.split.tooltip"))
        self._split_img = Gtk.Image.new_from_icon_name("view-dual-symbolic", Gtk.IconSize.BUTTON)
        btn_split.add(self._split_img)
        split_menu = Gtk.Menu()
        self._split_menu_items = []
        for label, cb, mode in [
            (f"□  {t('toolbar.split.single')}",     self._split_singolo, "single"),
            (f"◫  {t('toolbar.split.vertical')}",   self._split_verticale, "vertical"),
            (f"⬒  {t('toolbar.split.horizontal')}", self._split_orizzontale, "horizontal"),
        ]:
            mi = Gtk.CheckMenuItem(label=label)
            mi.connect("activate", lambda _, c=cb, m=mode: (c(), self._aggiorna_split_indicator(mode)))
            split_menu.append(mi)
            self._split_menu_items.append((mi, mode))
        split_menu.show_all()
        btn_split.set_popup(split_menu)
        hb.pack_start(btn_split)

        # Menu applicazione (⋮ tre puntini verticali)
        self._menu_btn = Gtk.MenuButton()
        self._menu_btn.set_direction(Gtk.ArrowType.DOWN)
        self._menu_btn.set_tooltip_text(t("toolbar.menu.tooltip"))
        self._menu_btn.add(Gtk.Image.new_from_icon_name("view-more-symbolic", Gtk.IconSize.BUTTON))
        self._menu_btn.set_popup(self._build_menu())
        hb.pack_end(self._menu_btn)

        # Impostazioni (rotella ⚙)
        btn_set = Gtk.Button()
        btn_set.set_tooltip_text(t("toolbar.settings.tooltip"))
        btn_set.add(Gtk.Image.new_from_icon_name("preferences-system-symbolic", Gtk.IconSize.BUTTON))
        btn_set.connect("clicked", lambda b: self._on_impostazioni())
        hb.pack_end(btn_set)

    def _build_menu(self) -> Gtk.Menu:
        menu = Gtk.Menu()

        def _item(label, callback):
            mi = Gtk.MenuItem(label=label)
            mi.connect("activate", lambda _: callback())
            menu.append(mi)

        _item(t("menu.tools.tunnels"),     self._on_tunnel_manager)
        _item(t("menu.tools.broadcast"),   self._on_broadcast)
        _item(t("menu.tools.variables"),   self._on_variabili_globali)
        _item(t("menu.tools.ftp_server"),  self._on_ftp_server)
        _item(t("menu.tools.snippets"),    self._apri_snippet_dialog)
        _item(t("menu.tools.import_from"), self._on_importa_sessioni)
        _item(t("menu.tools.audit"),       self._on_audit_log)
        _item(t("menu.tools.keepass"),     self._on_keepass_settings)
        menu.append(Gtk.SeparatorMenuItem())
        for p_label, p_icon, p_callback in _plugin_menu_items():
            _item(p_label, p_callback)
        if _plugin_menu_items():
            menu.append(Gtk.SeparatorMenuItem())
        _item(t("menu.tools.crypto"),      self._on_gestione_crypto)
        _item(t("menu.tools.check_deps"),  self._on_check_deps)
        menu.append(Gtk.SeparatorMenuItem())
        _item(t("menu.help.guide"),        self._on_guida)
        _item(t("menu.help.about"),        self._on_about)
        menu.append(Gtk.SeparatorMenuItem())
        _item(t("menu.file.quit"),         self._on_esci)

        menu.show_all()
        return menu

    # ------------------------------------------------------------------
    # Segnali
    # ------------------------------------------------------------------

    def _connect_signals(self):
        self._pannello.connect("connetti", self._on_connetti)
        self._pannello.connect("nuova",    lambda p: self._on_nuova_sessione())
        self._pannello.connect("modifica", self._on_modifica_sessione)
        self._pannello.connect("elimina",  self._on_elimina_sessione)
        self._pannello.connect("duplica",  self._on_duplica_sessione)
        self._pannello.connect("apri-ft",      lambda _p, n, d: self._apri_ft_da_sessione(d))
        self._pannello.connect("ping",         self._on_ping_sessione)
        self._pannello.connect("apri-log",     lambda _p, n, d: self._apri_log_viewer(n, d))
        self._pannello.connect("apri-monitor", lambda _p, n, d: self._apri_sysmon(n, d))
        self._pannello.connect("apri-cron",    lambda _p, n, d: self._apri_cron(n, d))
        self._pannello.connect("apri-cluster", lambda _p, n, d: self._apri_cluster(n, d))
        self.connect("delete-event", self._on_close)

    def _accel_to_gtk(self, shortcut):
        parti = shortcut.rsplit("+", 1)
        if len(parti) != 2:
            return None
        mods_str, tasto = parti
        parti_mods = mods_str.split("+")
        gtk_mods = []
        for m in parti_mods:
            m = m.strip()
            if m in ("Ctrl", "Control"):
                gtk_mods.append("<Primary>")
            elif m == "Shift":
                gtk_mods.append("<Shift>")
            elif m == "Alt":
                gtk_mods.append("<Alt>")
            elif m in ("Super", "Meta"):
                gtk_mods.append("<Super>")
            else:
                return None
        acceleratore = "".join(gtk_mods) + tasto.strip()
        key, mod = Gtk.accelerator_parse(acceleratore)
        if key == 0 and mod == 0:
            return None
        return acceleratore, key, mod

    def _toggle_sidebar(self):
        visibile = self._pannello.get_visible()
        self._pannello.set_visible(not visibile)
        s = config_manager.load_settings()
        s.setdefault("display", {})["sidebar_visible"] = not visibile
        config_manager.save_settings(s)
        return True

    def _toggle_fullscreen(self):
        if hasattr(self, "_fullscreen_active") and self._fullscreen_active:
            self.unfullscreen()
            self._fullscreen_active = False
        else:
            self.fullscreen()
            self._fullscreen_active = True
        return True

    def _setup_accels(self):
        if hasattr(self, "_accel_group") and self._accel_group:
            self.remove_accel_group(self._accel_group)
        ag = Gtk.AccelGroup()
        self.add_accel_group(ag)
        self._accel_group = ag

        mappa_azioni = {
            "new_terminal":   self._on_terminale_locale,
            "new_session":    self._on_nuova_sessione,
            "close_tab":      self._chiudi_tab_corrente,
            "next_tab":       lambda: self._notebook_attivo.next_page() or True,
            "prev_tab":       lambda: self._notebook_attivo.prev_page() or True,
            "find":           self._attiva_ricerca_terminale,
            "toggle_sidebar": self._toggle_sidebar,
            "fullscreen":     self._toggle_fullscreen,
        }

        shortcuts = config_manager.load_settings().get("shortcuts", {})
        for nome, combinazione in shortcuts.items():
            azione = mappa_azioni.get(nome)
            if not azione:
                continue
            risultato = self._accel_to_gtk(combinazione)
            if risultato is None:
                continue
            _, key, mod = risultato
            ag.connect(key, mod, Gtk.AccelFlags.VISIBLE, lambda *a, cb=azione: cb())

        key_fissa, mod_fissa = Gtk.accelerator_parse("<Primary><Shift>G")
        if key_fissa:
            ag.connect(key_fissa, mod_fissa, Gtk.AccelFlags.VISIBLE,
                       lambda *_: self._on_variabili_globali() or True)

    def _attiva_ricerca_terminale(self):
        idx = self._notebook_attivo.get_current_page()
        if idx < 0:
            return True
        page = self._notebook_attivo.get_nth_page(idx)
        if hasattr(page, "mostra_cerca"):
            page.mostra_cerca()
        return True

    def _aggiorna_welcome_recenti(self):
        """Aggiorna la lista recenti nella schermata home dopo lo sblocco crypto."""
        idx = self._notebook.page_num(self._notebook.get_nth_page(0))
        welcome = self._notebook.get_nth_page(0)
        if hasattr(welcome, "aggiorna"):
            welcome.aggiorna()

    def _mostra_benvenuto(self):
        welcome = WelcomeWidget()
        welcome.connect("nuova-sessione",   lambda w: self._on_nuova_sessione())
        welcome.connect("terminale-locale", lambda w: self._on_terminale_locale())
        welcome.connect("apri-sessione",    lambda w, n, d: self._on_connetti(None, n, d))
        welcome.show_all()
        lbl = Gtk.Label(label=t("app.home_tab"))
        self._notebook.append_page(welcome, lbl)

    # ------------------------------------------------------------------
    # Apertura sessioni
    # ------------------------------------------------------------------

    def _on_connetti(self, panel, nome: str, dati: dict):
        proto = dati.get("protocol", "ssh")
        pre_cmd = dati.get("pre_cmd", "").strip()
        wol_mac = dati.get("wol_mac", "") if dati.get("wol_enabled") else ""

        if (dati.get("jump_host", "").strip() and
                proto not in ("ssh", "mosh") and
                not self._supports_ssh_gateway(dati)):
            self._warn(
                "SSH gateway supportato solo per SFTP, Telnet, RDP, VNC e SPICE; "
                "FTP/FTPS e i protocolli locali non possono usare un singolo port forwarding."
            )
            return

        config_manager.add_recent(nome, dati)
        self._pannello.aggiorna()
        self._aggiorna_welcome_recenti()

        use_gateway = self._needs_ssh_gateway(dati)

        if pre_cmd or wol_mac or use_gateway:
            def _bg():
                try:
                    dati_loc = dict(dati)
                    if pre_cmd:
                        timeout = dati_loc.get("pre_cmd_timeout", 15)
                        try:
                            import shlex as _shlex_pre
                            subprocess.run(_shlex_pre.split(pre_cmd), shell=False, timeout=timeout)
                        except Exception as e:
                            GLib.idle_add(self._warn, f"Pre-cmd fallito: {e}")
                            return
                    if wol_mac:
                        err = self._invia_wol(wol_mac, dati_loc.get("wol_wait", 20))
                        if err:
                            GLib.idle_add(self._warn, f"WoL fallito: {err}")
                            return
                    if use_gateway:
                        local_port, gw_proc = self._start_ssh_gateway(dati_loc)
                        if local_port is None:
                            GLib.idle_add(self._warn, "SSH gateway fallito: tunnel non stabilito")
                            return
                        dati_loc["_gateway_tunnel"] = gw_proc
                        dati_loc["_gateway_local_port"] = str(local_port)
                        dati_loc["_gateway_target_host"] = dati_loc.get("host", "")
                    GLib.idle_add(self._apri_protocollo, proto, nome, dati_loc)
                except Exception as exc:
                    _log.error("Errore nel thread di connessione (_bg): %s", exc, exc_info=True)
                    GLib.idle_add(self._warn, f"Errore di connessione: {exc}")
            threading.Thread(target=_bg, daemon=True).start()
            return

        self._apri_protocollo(proto, nome, dati)

    def _needs_ssh_gateway(self, dati: dict) -> bool:
        """Check if this connection needs an SSH gateway tunnel."""
        return bool(dati.get("jump_host", "").strip() and
                    self._supports_ssh_gateway(dati))

    @staticmethod
    def _supports_ssh_gateway(dati: dict) -> bool:
        """Return whether one local TCP forward can carry this protocol."""
        proto = dati.get("protocol", "")
        return (proto in ("sftp", "telnet", "rdp", "vnc", "spice") or
                (proto == "file_transfer" and
                 dati.get("ft_protocol", "SFTP").upper() == "SFTP"))

    @staticmethod
    def _apply_ssh_gateway(dati: dict) -> dict:
        """Route a gateway-backed connection through its local TCP forward."""
        local_port = dati.get("_gateway_local_port")
        if not local_port:
            return dati
        forwarded = dict(dati)
        forwarded["host"] = "127.0.0.1"
        forwarded["port"] = str(local_port)
        return forwarded

    def _start_ssh_gateway(self, dati: dict) -> tuple:
        """Start an SSH tunnel to the jump host for gateway access.
        Returns (local_port, process) or (None, None) on failure.
        """
        import socket as _sock
        import time

        jump_host = dati.get("jump_host", "").strip()
        jump_user = dati.get("jump_user", "").strip()
        jump_port = dati.get("jump_port", "22").strip()
        target_host = dati.get("host", "").strip()
        target_port = dati.get("port", "").strip()
        pkey = dati.get("private_key", "").strip()
        pwd = dati.get("password", "")

        local_port = self._find_free_port()
        if local_port is None:
            return None, None

        ssh_exe = shutil.which("ssh") or "ssh"
        strict_default = config_manager.load_settings().get("ssh", {}).get("strict_host_check", True)
        strict = "yes" if dati.get("strict_host", strict_default) else "accept-new"
        cmd = [
            ssh_exe, "-N", "-T",
            "-o", f"StrictHostKeyChecking={strict}",
            "-o", "ConnectTimeout=10",
            "-o", "ServerAliveInterval=15",
            "-o", "ExitOnForwardFailure=yes",
            "-p", jump_port,
        ]
        if pkey and os.path.exists(pkey):
            cmd.extend(["-i", pkey])

        target = f"{jump_user}@{jump_host}" if jump_user else jump_host
        cmd.extend(["-L", f"{local_port}:{target_host}:{target_port}", target])

        env = os.environ.copy()
        askpass = None
        if pwd and not pkey:
            askpass_dir = os.path.join(os.path.expanduser("~"), ".cache", "pcm")
            os.makedirs(askpass_dir, mode=0o700, exist_ok=True)
            if os.stat(askpass_dir).st_uid != os.getuid():
                _log.error("SSH gateway: directory SSH_ASKPASS non di proprieta dell'utente")
                return None, None
            fd, askpass = tempfile.mkstemp(prefix=".pcm_ask_", suffix=".sh", dir=askpass_dir, text=True)
            import shlex as _shlex
            with os.fdopen(fd, "w") as f:
                f.write(f"#!/bin/sh\nprintf '%s' {_shlex.quote(pwd)}\n")
            os.chmod(askpass, 0o700)
            env["SSH_ASKPASS"] = askpass
            env["SSH_ASKPASS_REQUIRE"] = "force"

        try:
            proc = subprocess.Popen(
                cmd, stdin=subprocess.DEVNULL,
                stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
                env=env,
            )

            if askpass:
                def _cleanup_askpass():
                    proc.wait()
                    with contextlib.suppress(OSError):
                        os.unlink(askpass)
                threading.Thread(target=_cleanup_askpass, daemon=True).start()

            for _ in range(60):
                time.sleep(0.1)
                try:
                    s = _sock.create_connection(("127.0.0.1", local_port), timeout=0.5)
                    s.close()
                    return local_port, proc
                except OSError:
                    if proc.poll() is not None:
                        return None, None
            proc.terminate()
            try:
                proc.wait(timeout=2)
            except subprocess.TimeoutExpired:
                proc.kill()
            return None, None
        except Exception:
            if askpass:
                with contextlib.suppress(OSError):
                    os.unlink(askpass)
            return None, None

    def apri_da_cli(self, uri: str):
        """Apre una connessione da URI passato via riga di comando.

        Formati supportati:
          ssh://nome_sessione          — cerca sessione salvata per nome o hostname
          ssh://user@host:port         — connessione ad-hoc
          rdp://host?mode=external     — forza client esterno
          sftp://host / ftp://host     — file transfer
          vnc://host / telnet://host   — altri protocolli

        Query string opzionali (solo connessioni ad-hoc):
          ?mode=external               — apre in terminale/client esterno
          ?terminal=xterm              — emulatore esterno specifico
        """
        _PROTO_MAP = {
            "ssh": "ssh", "telnet": "telnet", "mosh": "mosh", "serial": "serial",
            "rdp": "rdp", "vnc": "vnc",
            "sftp": "file_transfer", "ftp": "file_transfer", "ftps": "file_transfer",
        }
        _DEFAULT_PORTS = {
            "ssh": "22", "telnet": "23", "mosh": "60001", "rdp": "3389",
            "vnc": "5900", "file_transfer": "22", "ftp": "21", "ftps": "21",
        }
        _FT_PROTO = {"sftp": "SFTP", "ftp": "FTP", "ftps": "FTPS"}

        # Se crypto è abilitato ma non ancora sbloccato, rimanda dopo l'unlock
        try:
            import crypto_manager
            if crypto_manager.is_enabled() and not crypto_manager.is_unlocked():
                self._pending_cli_uri = uri
                return
        except ImportError:
            _log.warning("cryptography non installato — apertura URI sospesa")
            GLib.idle_add(self._warn, "cryptography non installato; impossibile aprire URI con credenziali cifrate.")

        parsed = urlparse(uri)
        scheme = (parsed.scheme or "ssh").lower()
        proto = _PROTO_MAP.get(scheme)
        if not proto:
            self._warn(f"Protocollo non supportato nella URI: {scheme}")
            return

        host = parsed.hostname or ""
        port = str(parsed.port) if parsed.port else ""
        user = parsed.username or ""
        password = parsed.password or ""

        # Opzioni da query string (solo per connessioni ad-hoc)
        from urllib.parse import parse_qs
        qs = parse_qs(parsed.query)
        mode_ext = qs.get("mode", [""])[0].lower() == "external"
        terminal_ext = qs.get("terminal", [""])[0]

        # --- Cerca sessione salvata ---
        profili = config_manager.load_profiles()
        nome_match = None
        dati_match = None

        # 1. Nome sessione == host nella URI (case-insensitive)
        for nome_s, dati_s in profili.items():
            if nome_s.lower() == host.lower():
                nome_match, dati_match = nome_s, dati_s
                break

        # 2. Hostname + stesso protocollo
        if not dati_match:
            for nome_s, dati_s in profili.items():
                if (dati_s.get("host", "").lower() == host.lower()
                        and dati_s.get("protocol") == proto):
                    nome_match, dati_match = nome_s, dati_s
                    break

        # 3. Hostname qualsiasi protocollo
        if not dati_match:
            for nome_s, dati_s in profili.items():
                if dati_s.get("host", "").lower() == host.lower():
                    nome_match, dati_match = nome_s, dati_s
                    break

        if dati_match:
            dati = dict(dati_match)
            if user:
                dati["user"] = user
            if port:
                dati["port"] = port
            self._on_connetti(None, nome_match, dati)
            return

        # --- Connessione ad-hoc ---
        dati = {
            "protocol": proto,
            "host": host,
            "port": port or _DEFAULT_PORTS.get(proto, ""),
            "user": user,
            "password": password,
        }
        if scheme in _FT_PROTO:
            dati["ft_protocol"] = _FT_PROTO[scheme]
            dati["ftp_tls"] = scheme == "ftps"

        # Modalità apertura per protocollo
        mode = qs.get("mode", [""])[0].lower()   # "external" | "internal" | ""
        if proto in ("ssh", "telnet", "mosh", "serial"):
            if mode in ("external", "internal"):
                dati["ssh_open_mode"] = mode
            if terminal_ext:
                dati["terminal_type"] = terminal_ext
        elif proto == "rdp":
            # default RDP è già "external"; accetta esplicito "internal"
            if mode in ("external", "internal"):
                dati["rdp_open_mode"] = mode
        elif proto == "vnc":
            # vnc_internal=True → viewer embedded, False → client esterno
            if mode == "internal":
                dati["vnc_internal"] = True
            elif mode == "external":
                dati["vnc_internal"] = False

        nome_display = f"{scheme}://{host}"
        self._on_connetti(None, nome_display, dati)

    def _apri_protocollo(self, proto: str, nome: str, dati: dict):
        from datetime import datetime
        _ts_start = datetime.now()
        _status = "ok"
        try:
            dati = self._apply_ssh_gateway(dati)
            # Plugin-based protocols
            if pcm_has_protocol(proto):
                self._apri_protocollo_plugin(proto, nome, dati)
            elif proto in ("ssh", "telnet", "mosh", "serial", "exec"):
                self._apri_terminale(nome, dati)
            elif proto == "sftp" or (proto == "file_transfer" and dati.get("ft_protocol", "SFTP") == "SFTP"):
                self._apri_sftp(nome, dati)
            elif proto in ("ftp", "file_transfer"):
                self._apri_ftp(nome, dati)
            elif proto == "rdp":
                self._apri_rdp(nome, dati)
            elif proto == "vnc":
                self._apri_vnc(nome, dati)
            self._status(t("status.connected", name=nome))
        except Exception as e:
            _status = "error"
            self._warn(str(e))
        finally:
            _dur = int((datetime.now() - _ts_start).total_seconds())
            config_manager.audit_append({
                "ts":       _ts_start.strftime("%Y-%m-%d %H:%M:%S"),
                "session":  nome,
                "host":     dati.get("_gateway_target_host", dati.get("host", "")),
                "proto":    proto,
                "duration": _dur,
                "status":   _status,
            })

    def _apri_terminale(self, nome: str, dati: dict):
        self._resolve_credentials(dati)
        log_dir = dati.get("log_dir", "") if dati.get("log_output") else ""

        cmd, modalita = build_command(dati)

        # Gestione password: feed_child (primario) + SSH_ASKPASS (fallback)
        # feed_child digita la password quando compare il prompt nel VTE (imposta_auto_password).
        # SSH_ASKPASS gestisce il caso in cui SSH non mostra il prompt nel VTE:
        #   OpenSSH ≥ 8.4 + SSH_ASKPASS_REQUIRE=force → auth silenziosa senza prompt visibile.
        #   Old SSH → SSH_ASKPASS ignorato (TTY presente) → feed_child gestisce tutto.
        import shlex as _shlex
        env_extra = {}
        pwd  = dati.get("password", "")
        pkey = dati.get("private_key", "").strip()
        if pwd and not pkey:
            # SSH_ASKPASS: script temp in directory privata (non /tmp), password embedded nel file
            _askpass_dir = os.path.join(os.path.expanduser("~"), ".cache", "pcm")
            os.makedirs(_askpass_dir, mode=0o700, exist_ok=True)
            # Verifica che la directory sia di proprietà dell'utente corrente
            if os.stat(_askpass_dir).st_uid != os.getuid():
                self._warn("Attenzione: ~/.cache/pcm non è di proprietà dell'utente corrente. SSH_ASKPASS disabilitato.")
            else:
                _fd, _askpass = tempfile.mkstemp(prefix=".pcm_ask_", suffix=".sh", dir=_askpass_dir, text=True)
                with os.fdopen(_fd, "w") as _f:
                    _f.write(f"#!/bin/sh\nprintf '%s' {_shlex.quote(pwd)}\n")
                os.chmod(_askpass, 0o700)
                env_extra["SSH_ASKPASS"] = _askpass
                env_extra["SSH_ASKPASS_REQUIRE"] = "force"   # OpenSSH ≥ 8.4
                def _cleanup_askpass(path=_askpass):
                    with contextlib.suppress(Exception):
                        os.unlink(path)
                    return False
                GLib.timeout_add(5000, _cleanup_askpass)    # pulizia dopo 5 s

        # Modalità terminale ESTERNO: lancia nel terminal emulator scelto
        if modalita and modalita.endswith("_term_ext"):
            term = dati.get("terminal_type", "Terminale Interno")
            if term and term != "Terminale Interno":
                import shlex
                _press_enter_msg = t("term_ext.press_enter")
                inner = cmd + f"; echo ''; read -rp '{_press_enter_msg}' _x"
                inner_q = shlex.quote(inner)
                term_lower = term.lower()
                if "xfce4-terminal" in term_lower:
                    args = [term, f"--command=bash -c {inner_q}"]
                elif "gnome-terminal" in term_lower or "mate-terminal" in term_lower:
                    args = [term, "--", "bash", "-c", inner]
                elif "konsole" in term_lower:
                    args = [term, "-e", "bash", "-c", inner]
                elif "tilix" in term_lower:
                    args = [term, "-e", f"bash -c {inner_q}"]
                elif "alacritty" in term_lower:
                    args = [term, "-e", "bash", "-c", inner]
                elif "kitty" in term_lower or "foot" in term_lower:
                    args = [term, "bash", "-c", inner]
                else:
                    # xterm e generici: -e bash -c CMD
                    args = [term, "-e", "bash", "-c", inner]
                proc_env = None
                if env_extra:
                    proc_env = os.environ.copy()
                    proc_env.update(env_extra)
                try:
                    subprocess.Popen(args,
                                     stdout=subprocess.DEVNULL,
                                     stderr=subprocess.DEVNULL,
                                     env=proc_env)
                except FileNotFoundError:
                    self._warn(t("term_ext.not_found", term=term))
                self._status(t("status.connected_ext", name=nome))
                return

        # Modalità INTERNA: usa TerminalWidget VTE
        widget = TerminalWidget.da_profilo(dati, log_dir=log_dir)
        widget.comando_display   = nome
        widget.comando_originale = cmd
        widget._tipo_sessione    = dati.get("protocol", "ssh")

        # SFTP browser laterale: SSH e Mosh usano direttamente la porta di sessione
        if dati.get("sftp_browser") and dati.get("protocol") in ("ssh", "mosh"):
            paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
            sftp = SftpBrowserWidget(
                dati,
                on_apri_editor=lambda sftp_c, path, n=nome: self._apri_sftp_editor(sftp_c, path, n),
            )
            paned.pack1(widget, True, True)
            paned.pack2(sftp, False, False)
            paned.set_position(700)
            container = paned
        else:
            container = widget

        container._pcm_dati = dati
        container.show_all()
        self._append_tab(container, nome)
        GLib.idle_add(widget.grab_focus)

        # Primario: feed_child digita la password quando il VTE mostra un prompt
        if pwd and not pkey:
            widget.imposta_auto_password(pwd)

        # TOTP / 2FA: feed_child digita il codice OTP dopo la password
        totp_secret = dati.get("totp_secret", "").strip()
        if totp_secret:
            try:
                from totp_manager import generate_totp, render_uri_to_secret
                secret = render_uri_to_secret(totp_secret)
                otp_code = generate_totp(secret)
                if otp_code:
                    widget.imposta_auto_password(otp_code)
            except Exception as e:
                _log.debug("TOTP fallito per '%s': %s", nome, e)

        expect_rules = dati.get("expect_rules", [])
        if expect_rules:
            widget.imposta_expect(expect_rules)

        widget.avvia(cmd, env_extra=env_extra)
        widget.connect("processo-terminato",
                       lambda w: self._on_processo_terminato(w))

        if dati.get("auto_reconnect"):
            delay = max(1, int(dati.get("reconnect_delay", 5)))
            _pcm = self
            _cmd, _pwd, _pkey = cmd, pwd, pkey
            _nome = nome
            _has_env_askpass = bool(env_extra.get("SSH_ASKPASS"))

            def _do_reconnect(w=widget):
                for nb in (_pcm._notebook, _pcm._notebook2):
                    _, page = _pcm._trova_in_notebook(nb, w)
                    if page is not None:
                        _pcm._set_tab_nome(page, _nome)
                        break
                _reconnect_env = {}
                if _pwd and not _pkey and _has_env_askpass:
                    _askpass_dir = os.path.join(os.path.expanduser("~"), ".cache", "pcm")
                    os.makedirs(_askpass_dir, mode=0o700, exist_ok=True)
                    _fd, _askpass = tempfile.mkstemp(prefix=".pcm_ask_", suffix=".sh", dir=_askpass_dir, text=True)
                    import shlex as _shlex_r
                    with os.fdopen(_fd, "w") as _f:
                        _f.write(f"#!/bin/sh\nprintf '%s' {_shlex_r.quote(_pwd)}\n")
                    os.chmod(_askpass, 0o700)
                    _reconnect_env["SSH_ASKPASS"] = _askpass
                    _reconnect_env["SSH_ASKPASS_REQUIRE"] = "force"
                    def _cleanup_askpass(path=_askpass):
                        with contextlib.suppress(Exception):
                            os.unlink(path)
                        return False
                    GLib.timeout_add(5000, _cleanup_askpass)
                w.avvia(_cmd, env_extra=_reconnect_env)
                if _pwd and not _pkey:
                    w.imposta_auto_password(_pwd)
                if _erules:
                    w.imposta_expect(_erules)
                return False

            widget._pcm_reconnect = _do_reconnect
            widget._pcm_reconnect_delay = delay
            _erules = expect_rules

    def _apri_protocollo_plugin(self, proto: str, nome: str, dati: dict):
        """Open a connection for a plugin-provided protocol."""
        self._resolve_credentials(dati)

        widget = pcm_create_widget(proto, dati, self)
        if widget is not None:
            widget._pcm_dati = dati
            container = self._sftp_browser_paned(widget, dati)
            container.show_all()
            self._append_tab(container, nome, lambda: self._chiudi_tab(container))
            return

        cmd, modalita = pcm_build_command(proto, dati)
        log_dir = dati.get("log_dir", "") if dati.get("log_output") else ""

        if modalita == "embedded":
            widget = TerminalWidget.da_profilo(dati, log_dir=log_dir)
            widget.comando_display = nome
            widget.comando_originale = cmd
            widget._tipo_sessione = proto
            widget.show_all()
            container = self._sftp_browser_paned(widget, dati)
            container._pcm_dati = dati
            container.show_all()
            self._append_tab(container, nome)
            GLib.idle_add(widget.grab_focus)

            pwd = dati.get("password", "")
            pkey = dati.get("private_key", "").strip()
            if pwd and not pkey:
                widget.imposta_auto_password(pwd)
            widget.avvia(cmd)
            widget.connect("processo-terminato",
                           lambda w: self._on_processo_terminato(w))
        elif modalita == "none":
            self._warn(f"Protocollo '{proto}' non ha comando associato.")
        else:
            self._warn(f"Modalità '{modalita}' non supportata per il protocollo '{proto}'.")

    def _apri_sftp(self, nome: str, dati: dict):
        widget = WinScpWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, nome, lambda: self._chiudi_tab(widget))

    def _apri_ftp(self, nome: str, dati: dict):
        widget = FtpWinScpWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, nome, lambda: self._chiudi_tab(widget))

    def _apri_log_viewer(self, nome: str, dati: dict):
        widget = LogViewerWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, f"Log: {nome}", lambda: self._chiudi_tab(widget))

    def _apri_sysmon(self, nome: str, dati: dict):
        widget = SysMonitorWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, f"Mon: {nome}", lambda: self._chiudi_tab(widget))

    def _apri_cron(self, nome: str, dati: dict):
        widget = CronWidget(dati)
        widget._pcm_dati = dati
        widget.show_all()
        self._append_tab(widget, f"Cron: {nome}", lambda: self._chiudi_tab(widget))

    def _apri_sftp_editor(self, sftp, remote_path: str, session_nome: str = ""):
        fname  = remote_path.rsplit("/", 1)[-1] or remote_path
        label  = f"Edit: {fname}"
        widget = SftpEditorWidget(sftp, remote_path)
        widget.show_all()
        self._append_tab(widget, label, lambda: self._chiudi_tab(widget))

    def _apri_snippet_dialog(self):
        """Apre la libreria snippet; invia al terminale attivo se è un TerminalWidget."""
        nb  = self._notebook_attivo
        idx = nb.get_current_page()
        page = nb.get_nth_page(idx)
        terminal = None
        if isinstance(page, TerminalWidget):
            terminal = page
        elif hasattr(page, "get_child1"):
            c1 = page.get_child1()
            if isinstance(c1, TerminalWidget):
                terminal = c1

        on_invia = None
        if terminal:
            on_invia = lambda cmd: terminal.invia_testo(cmd, sorgente="snippet")

        dlg = SnippetsDialog(parent=self, on_invia=on_invia)
        dlg.run()
        dlg.destroy()

    def _apri_ft_da_sessione(self, dati_ssh: dict):
        dlg = _DialogApriFileTransfer(parent=self, dati_ssh=dati_ssh)
        resp = dlg.run()
        if resp == Gtk.ResponseType.OK:
            dati_ft = dlg.get_dati()
            host = dati_ft.get("host", "")
            ft_proto = dati_ft.get("ft_protocol", "SFTP")
            nome_tab = f"{ft_proto}: {host}"
            if ft_proto == "SFTP":
                self._apri_sftp(nome_tab, dati_ft)
            else:
                self._apri_ftp(nome_tab, dati_ft)
        dlg.destroy()

    def _on_cluster_from_toolbar(self):
        profili = config_manager.load_profiles()
        if not profili:
            self._warn(t("cluster.no_sessions"))
            return
        dlg = _SessionPickerDialog(parent=self, profili=profili)
        resp = dlg.run()
        if resp != Gtk.ResponseType.OK:
            dlg.destroy()
            return
        selected = dlg.get_selected()
        dlg.destroy()
        if not selected:
            return
        self._apri_cluster_multi(selected, profili)

    def _apri_cluster(self, nome: str, dati: dict):
        profili = config_manager.load_profiles()
        self._apri_cluster_multi([nome], profili)

    def _apri_cluster_multi(self, nomi: list[str], profili: dict):
        from cluster_dialog import ClusterDialog
        sessions = {}
        for n in nomi:
            if n in profili:
                sessions[n] = profili[n]
        if not sessions:
            return
        dlg = ClusterDialog(parent=self, sessions=sessions)
        resp = dlg.run()
        if resp != Gtk.ResponseType.OK:
            dlg.destroy()
            return
        cluster_plan = dlg.get_cluster_plan()
        enable_bc = dlg.enable_broadcast()
        delay = dlg.get_delay()
        dlg.destroy()
        self._connect_to_cluster_plan(cluster_plan, delay, enable_bc)

    def _connect_to_cluster_plan(self, plan: dict, delay: float, enable_bc: bool):
        import time
        connected = 0
        for nome_sessione, hosts_info in plan.items():
            dati = hosts_info.get("dati", {})
            keep_user = hosts_info.get("keep_user", True)
            keep_port = hosts_info.get("keep_port", True)
            for host in hosts_info.get("hosts", []):
                d = dict(dati)
                d["host"] = host
                if not keep_user:
                    d["user"] = ""
                if not keep_port:
                    d["port"] = ""
                label = f"{nome_sessione} [{host}]"
                if connected > 0 and delay > 0:
                    time.sleep(delay)
                GLib.idle_add(lambda dd=d, l=label: self._on_connetti(None, l, dd))
                connected += 1
        if enable_bc and connected > 0:
            GLib.idle_add(self._on_broadcast)

    def _save_cluster(self, name: str, session_names: list[str]):
        s = config_manager.load_settings()
        clusters = s.get("saved_clusters", {})
        clusters[name] = {"sessions": session_names}
        s["saved_clusters"] = clusters
        config_manager.save_settings(s)

    def _load_clusters(self) -> dict:
        return config_manager.load_settings().get("saved_clusters", {})

    def _resolve_credentials(self, dati: dict):
        """Inject user/password/domain from a named credential profile into dati."""
        profile_name = dati.get("credential_profile", "")
        if not profile_name or profile_name == "ask":
            return
        for p in config_manager.load_credential_profiles():
            if p.get("name") == profile_name:
                if p.get("user"):
                    dati["user"] = p["user"]
                if p.get("password"):
                    dati["password"] = p["password"]
                if p.get("domain"):
                    dati["rdp_domain"] = p["domain"]
                return

    def _chiedi_credenziali_rdp(self, nome: str, dati: dict) -> bool:
        """Mostra un dialogo per user/password mancanti. Aggiorna dati in-place.
        Ritorna False se l'utente annulla."""
        user   = dati.get("user", "").strip()
        domain = dati.get("rdp_domain", "").strip()
        pwd    = dati.get("password", "")
        if user and pwd:
            return True  # già tutto presente, nessun dialogo

        host = dati.get("host", "")
        dlg = Gtk.Dialog(
            title=f"Credenziali RDP — {host}",
            transient_for=self,
            modal=True,
            destroy_with_parent=True,
        )
        dlg.add_buttons(
            Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL,
            Gtk.STOCK_OK,     Gtk.ResponseType.OK,
        )
        dlg.set_default_response(Gtk.ResponseType.OK)
        dlg.set_default_size(340, -1)

        warn = Gtk.Label()
        warn.set_markup(
            "<small><i>⚠  Credenziali non complete nel profilo sessione.\n"
            "Completarle qui per accesso diretto, oppure salvarle nella sessione.</i></small>"
        )
        warn.set_xalign(0.0)
        warn.set_line_wrap(True)
        warn.set_margin_start(12)
        warn.set_margin_end(12)
        warn.set_margin_top(10)
        warn.set_margin_bottom(4)
        dlg.get_content_area().add(warn)

        grid = Gtk.Grid(column_spacing=8, row_spacing=6,
                        margin_start=12, margin_end=12,
                        margin_top=4, margin_bottom=8)
        row = 0

        def _row(label_text, widget):
            nonlocal row
            lbl = Gtk.Label(label=label_text, xalign=1.0)
            grid.attach(lbl,    0, row, 1, 1)
            grid.attach(widget, 1, row, 1, 1)
            widget.set_hexpand(True)
            row += 1

        e_user = Gtk.Entry(text=user)
        e_user.set_activates_default(True)
        _row(t("sd.user") + ":", e_user)

        e_domain = Gtk.Entry(text=domain)
        e_domain.set_activates_default(True)
        _row("Domain:", e_domain)

        e_pwd = Gtk.Entry(text=pwd, visibility=False)
        e_pwd.set_activates_default(True)
        _row(t("sd.password") + ":", e_pwd)

        chk_salva = Gtk.CheckButton(label="Salva nel profilo sessione")
        chk_salva.set_margin_start(12)
        chk_salva.set_margin_bottom(8)

        dlg.get_content_area().add(grid)
        dlg.get_content_area().add(chk_salva)
        dlg.show_all()
        resp = dlg.run()
        if resp == Gtk.ResponseType.OK:
            new_user   = e_user.get_text().strip()
            new_domain = e_domain.get_text().strip()
            new_pwd    = e_pwd.get_text()
            dati["user"]       = new_user
            dati["rdp_domain"] = new_domain
            dati["password"]   = new_pwd
            if chk_salva.get_active():
                self._salva_credenziali_sessione(
                    nome, {"user": new_user, "rdp_domain": new_domain, "password": new_pwd}
                )
        dlg.destroy()
        return resp == Gtk.ResponseType.OK

    def _salva_credenziali_sessione(self, nome: str, credenziali: dict):
        try:
            profili = config_manager.load_profiles()
            if nome in profili:
                profili[nome].update(credenziali)
                config_manager.save_profiles(profili)
        except Exception as e:
            self._warn(f"Errore salvataggio credenziali: {e}")

    def _sftp_browser_paned(self, widget, dati: dict):
        """Avvolge widget in Paned con SFTP browser se sftp_browser è attivo.
        Per VNC/RDP usa mon_ssh_port invece della porta di sessione."""
        if not dati.get("sftp_browser"):
            return widget
        sftp_dati = dati
        if dati.get("protocol") in ("vnc", "rdp"):
            sftp_dati = dict(dati)
            sftp_dati["port"] = dati.get("mon_ssh_port", 22)
        paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
        sftp = SftpBrowserWidget(
            sftp_dati,
            on_apri_editor=lambda sftp_c, path: self._apri_sftp_editor(sftp_c, path),
        )
        paned.pack1(widget, True, True)
        paned.pack2(sftp, False, False)
        paned.set_position(700)
        return paned

    def _find_free_port(self) -> int | None:
        """Find a free TCP port for SSH port forwarding."""
        import socket as _sock
        try:
            s = _sock.socket(_sock.AF_INET, _sock.SOCK_STREAM)
            s.bind(("127.0.0.1", 0))
            port = s.getsockname()[1]
            s.close()
            return port
        except Exception:
            return None

    def _apri_rdp(self, nome: str, dati: dict):
        self._resolve_credentials(dati)
        if not self._chiedi_credenziali_rdp(nome, dati):
            return
        open_mode = dati.get("rdp_open_mode", "external")
        if open_mode == "internal":
            widget = RdpEmbedWidget(dati, open_mode="internal")
            container = self._sftp_browser_paned(widget, dati)
            container._pcm_dati = dati
            container.show_all()
            self._append_tab(container, nome, lambda: self._chiudi_tab(container))
            widget.avvia()
        else:
            # Apre xfreerdp in finestra esterna con output visibile nel tab VTE
            import shlex as _shlex
            from rdp_widget import _build_freerdp_cmd
            cmd_parts = _build_freerdp_cmd(dati)
            cmd_shell  = " ".join(_shlex.quote(p) for p in cmd_parts)
            cmd_display = " ".join(
                p if not p.startswith("/p:") else "/p:****" for p in cmd_parts
            )
            _press = t("term_ext.press_enter")
            pwd = dati.get("password", "")
            env_extra = {}
            if pwd and cmd_parts[0] != "rdesktop":
                import shlex as _shlex_rdp
                cmd_shell = f"printf '%s\\n' {_shlex_rdp.quote(pwd)} | {cmd_shell}"
            full_cmd = f'{cmd_shell}; echo; read -rp "{_press}" _x'
            widget = TerminalWidget.da_profilo(dati)
            widget.comando_display = cmd_display
            container = self._sftp_browser_paned(widget, dati)
            container._pcm_dati = dati
            container.show_all()
            self._append_tab(container, nome)
            GLib.idle_add(widget.grab_focus)
            widget.avvia(full_cmd, env_extra=env_extra)
            widget.connect("processo-terminato",
                           lambda w: self._on_processo_terminato(w))

    def _apri_vnc(self, nome: str, dati: dict):
        self._resolve_credentials(dati)
        sftp_enabled = dati.get("sftp_browser", False)

        if dati.get("vnc_internal", False):
            # Viewer integrato
            def _salva_password_vnc(pwd: str):
                """Callback chiamato da VncWebWidget se l'utente sceglie 'salva'."""
                try:
                    profili = config_manager.load_profiles()
                    for gruppo in profili.values():
                        if isinstance(gruppo, dict) and nome in gruppo:
                            gruppo[nome]["password"] = pwd
                            if not config_manager.save_profiles(profili):
                                self._warn(t("sd.save_vnc_password_failed"))
                            return
                    if nome in profili:
                        profili[nome]["password"] = pwd
                        if not config_manager.save_profiles(profili):
                            self._warn(t("sd.save_vnc_password_failed"))
                except Exception as exc:
                    _log.error("Impossibile salvare password VNC: %s", exc)
                    GLib.idle_add(self._warn, t("sd.save_vnc_password_failed"))

            if sftp_enabled:
                # Pannello SFTP differito: aperto solo dopo che VNC è connesso
                # e solo se la porta SSH risponde.
                ssh_host = dati.get("host", "")
                ssh_port = int(dati.get("mon_ssh_port", 22))
                sftp_dati = dict(dati)
                sftp_dati["port"] = ssh_port

                ph_lbl = Gtk.Label(label="In attesa della connessione VNC…")
                ph_lbl.set_valign(Gtk.Align.CENTER)
                ph_lbl.set_halign(Gtk.Align.CENTER)
                ph_lbl.set_line_wrap(True)
                ph_lbl.set_margin_start(8)
                ph_lbl.set_margin_end(8)
                placeholder = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
                placeholder.set_size_request(220, -1)
                placeholder.pack_start(ph_lbl, True, True, 0)

                paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)

                def _on_vnc_ready():
                    import socket as _sock
                    ph_lbl.set_text(f"Verifica SSH {ssh_host}:{ssh_port}…")

                    def _probe():
                        try:
                            s = _sock.create_connection((ssh_host, ssh_port), timeout=3)
                            s.close()
                            GLib.idle_add(_ssh_aperta)
                        except OSError:
                            GLib.idle_add(_ssh_chiusa)

                    def _ssh_aperta():
                        sftp = SftpBrowserWidget(
                            sftp_dati,
                            on_apri_editor=lambda c, p: self._apri_sftp_editor(c, p),
                        )
                        paned.remove(placeholder)
                        paned.pack2(sftp, False, False)
                        sftp.show_all()

                    def _ssh_chiusa():
                        ph_lbl.set_markup(
                            f"<small>Porta SSH {ssh_port}\nnon raggiungibile\nsu {ssh_host}</small>"
                        )

                    threading.Thread(target=_probe, daemon=True).start()

                widget = VncWebWidget(
                    host=dati.get("host", ""),
                    port=dati.get("port", "5900"),
                    password=dati.get("password", ""),
                    color_depth=dati.get("vnc_color", 0),
                    quality=dati.get("vnc_quality", 2),
                    on_save_password=_salva_password_vnc,
                    on_vnc_ready=_on_vnc_ready,
                )
                widget.show_all()
                paned.pack1(widget, True, True)
                paned.pack2(placeholder, False, True)
                paned.set_position(700)
                paned.show_all()
                container = paned
            else:
                widget = VncWebWidget(
                    host=dati.get("host", ""),
                    port=dati.get("port", "5900"),
                    password=dati.get("password", ""),
                    color_depth=dati.get("vnc_color", 0),
                    quality=dati.get("vnc_quality", 2),
                    on_save_password=_salva_password_vnc,
                )
                widget.show_all()
                container = widget

            container._pcm_dati = dati
            self._append_tab(container, nome, lambda: self._chiudi_tab(container))
        else:
            # Client VNC esterno con output visibile nel tab VTE
            cmd, _ = build_command(dati)
            if not cmd:
                self._warn(t("vnc.unavailable", log=""))
                return
            import shlex as _shlex
            _press = t("term_ext.press_enter")
            full_cmd = f'{cmd}; echo; read -rp "{_press}" _x'
            widget = TerminalWidget.da_profilo(dati)
            widget.comando_display = nome
            widget.show_all()

            if sftp_enabled:
                # Pannello SFTP differito: probe SSH in background senza attendere VNC
                ssh_host = dati.get("host", "")
                ssh_port = int(dati.get("mon_ssh_port", 22))
                sftp_dati = dict(dati)
                sftp_dati["port"] = ssh_port

                ph_lbl = Gtk.Label(label=f"Verifica SSH {ssh_host}:{ssh_port}…")
                ph_lbl.set_valign(Gtk.Align.CENTER)
                ph_lbl.set_halign(Gtk.Align.CENTER)
                ph_lbl.set_line_wrap(True)
                ph_lbl.set_margin_start(8)
                ph_lbl.set_margin_end(8)
                placeholder = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
                placeholder.set_size_request(220, -1)
                placeholder.pack_start(ph_lbl, True, True, 0)

                paned = Gtk.Paned(orientation=Gtk.Orientation.HORIZONTAL)
                paned.pack1(widget, True, True)
                paned.pack2(placeholder, False, True)
                paned.set_position(700)
                paned.show_all()
                container = paned

                def _ssh_aperta_ext():
                    sftp = SftpBrowserWidget(
                        sftp_dati,
                        on_apri_editor=lambda c, p: self._apri_sftp_editor(c, p),
                    )
                    paned.remove(placeholder)
                    paned.pack2(sftp, False, False)
                    sftp.show_all()

                def _ssh_chiusa_ext():
                    ph_lbl.set_markup(
                        f"<small>Porta SSH {ssh_port}\nnon raggiungibile\nsu {ssh_host}</small>"
                    )

                def _probe_ext():
                    import socket as _sock
                    try:
                        s = _sock.create_connection((ssh_host, ssh_port), timeout=3)
                        s.close()
                        GLib.idle_add(_ssh_aperta_ext)
                    except OSError:
                        GLib.idle_add(_ssh_chiusa_ext)

                threading.Thread(target=_probe_ext, daemon=True).start()
            else:
                container = widget

            container._pcm_dati = dati
            self._append_tab(container, nome)
            GLib.idle_add(widget.grab_focus)
            widget.avvia(full_cmd)
            widget.connect("processo-terminato",
                           lambda w: self._on_processo_terminato(w))

    # ------------------------------------------------------------------
    # Tab label con pulsante chiudi
    # ------------------------------------------------------------------

    # ------------------------------------------------------------------
    # Helper label tab
    # ------------------------------------------------------------------

    def _make_tab_label(self, nome: str, on_close) -> "tuple[Gtk.Box, Gtk.Label]":
        """Crea la box label di un tab con nome + pulsante X."""
        box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        lbl = Gtk.Label(label=nome)
        btn = Gtk.Button()
        btn.set_relief(Gtk.ReliefStyle.NONE)
        btn.set_focus_on_click(False)
        btn.set_tooltip_text(t("tab.close_session_tooltip"))
        img = Gtk.Image.new_from_icon_name("window-close-symbolic", Gtk.IconSize.MENU)
        btn.add(img)
        btn.connect("clicked", lambda _b: on_close())
        box.pack_start(lbl, True, True, 0)
        box.pack_start(btn, False, False, 0)
        box.show_all()
        return box, lbl

    def _get_tab_nome(self, widget) -> str:
        """Legge il nome del tab da _tab_labels (o stringa vuota per la Home)."""
        lbl = self._tab_labels.get(widget)
        return lbl.get_text() if lbl else ""

    def _set_tab_nome(self, widget, nome: str):
        """Aggiorna il testo del label nel tab."""
        lbl = self._tab_labels.get(widget)
        if lbl:
            lbl.set_text(nome)

    def _get_open_session_names(self) -> set:
        """Nomi delle sessioni con tab aperta e processo ancora vivo (no ✖)."""
        names = set()
        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                page = nb.get_nth_page(i)
                nome = self._get_tab_nome(page)
                if nome and not nome.startswith("✖"):
                    names.add(nome)
        return names

    def _append_tab(self, widget, nome: str, on_close=None):
        """Aggiunge un tab con label personalizzata (nome + pulsante X)."""
        cb = on_close or (lambda: self._chiudi_tab(widget))
        lbl_box, lbl = self._make_tab_label(nome, cb)
        self._tab_labels[widget] = lbl
        self._widget_nb_map[widget] = self._notebook
        self._notebook.append_page(widget, lbl_box)
        self._notebook.set_tab_reorderable(widget, True)
        self._notebook.set_current_page(self._notebook.get_n_pages() - 1)
        GLib.idle_add(widget.grab_focus)
        GLib.idle_add(lambda: self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names()))

    # ------------------------------------------------------------------
    # Split pannelli
    # ------------------------------------------------------------------

    def _split_singolo(self):
        while self._notebook2.get_n_pages() > 0:
            self._sposta_tab(self._notebook2, self._notebook, 0)
        self._notebook2.hide()
        self._paned_term.set_position(99999)

    def _split_verticale(self):
        self._paned_term.set_orientation(Gtk.Orientation.HORIZONTAL)
        self._notebook2.show()
        alloc = self._paned_term.get_allocation()
        self._paned_term.set_position(max(200, alloc.width // 2))

    def _split_orizzontale(self):
        self._paned_term.set_orientation(Gtk.Orientation.VERTICAL)
        self._notebook2.show()
        alloc = self._paned_term.get_allocation()
        self._paned_term.set_position(max(100, alloc.height // 2))

    def _aggiorna_split_indicator(self, mode: str = None):
        if not hasattr(self, "_split_menu_items"):
            return
        if mode is None:
            if not self._notebook2.get_visible():
                mode = "single"
            elif self._paned_term.get_orientation() == Gtk.Orientation.VERTICAL:
                mode = "horizontal"
            else:
                mode = "vertical"
        for mi, m in self._split_menu_items:
            mi.set_active(m == mode)
        icons = {"single": "view-dual-symbolic", "vertical": "view-dual-symbolic",
                 "horizontal": "view-dual-symbolic"}
        self._split_img.set_from_icon_name(icons.get(mode, "view-dual-symbolic"), Gtk.IconSize.BUTTON)

    def _sposta_tab(self, sorgente: Gtk.Notebook, destinazione: Gtk.Notebook, idx: int):
        """Sposta il tab idx da sorgente a destinazione."""
        if idx < 0 or idx >= sorgente.get_n_pages():
            return
        widget = sorgente.get_nth_page(idx)
        nome   = self._get_tab_nome(widget)
        sorgente.remove_page(idx)
        # Ricrea la label custom per il notebook di destinazione
        lbl_box, lbl = self._make_tab_label(nome, lambda: self._chiudi_tab(widget))
        self._tab_labels[widget] = lbl
        self._widget_nb_map[widget] = destinazione
        destinazione.append_page(widget, lbl_box)
        destinazione.set_tab_reorderable(widget, True)
        destinazione.set_current_page(destinazione.get_n_pages() - 1)
        if destinazione is self._notebook2:
            self._notebook2.show()
        if sorgente is self._notebook2 and sorgente.get_n_pages() == 0:
            self._notebook2.hide()

    def _menu_tab(self, notebook, idx, event):
        """Menu tasto destro su un tab."""
        if idx < 0:
            return
        menu = Gtk.Menu()
        altra = self._notebook2 if notebook is self._notebook else self._notebook

        mi_sposta = Gtk.MenuItem(label=t("tab.move_to_other"))
        mi_sposta.connect("activate", lambda _: self._sposta_tab(notebook, altra, idx))
        menu.append(mi_sposta)

        page = notebook.get_nth_page(idx)
        dati_tab = getattr(page, "_pcm_dati", None)
        if dati_tab and dati_tab.get("protocol") in ("ssh", "telnet", "mosh", "serial"):
            menu.append(Gtk.SeparatorMenuItem())
            mi_ft = Gtk.MenuItem(label=t("tab.open_ft_here"))
            mi_ft.connect("activate", lambda _b, d=dati_tab: self._apri_ft_da_sessione(d))
            menu.append(mi_ft)

        if dati_tab and dati_tab.get("protocol") == "ssh":
            nome_tab = self._get_tab_nome(page)
            mi_log = Gtk.MenuItem(label=t("panel.apri_log"))
            mi_log.connect("activate",
                           lambda _b, n=nome_tab, d=dati_tab: self._apri_log_viewer(n, d))
            menu.append(mi_log)
            mi_mon = Gtk.MenuItem(label=t("panel.apri_monitor"))
            mi_mon.connect("activate",
                           lambda _b, n=nome_tab, d=dati_tab: self._apri_sysmon(n, d))
            menu.append(mi_mon)
            mi_cron = Gtk.MenuItem(label=t("panel.apri_cron"))
            mi_cron.connect("activate",
                            lambda _b, n=nome_tab, d=dati_tab: self._apri_cron(n, d))
            menu.append(mi_cron)

        if dati_tab:
            nome_tab = self._get_tab_nome(page)
            menu.append(Gtk.SeparatorMenuItem())
            mi_dup = Gtk.MenuItem(label=t("tab.duplicate"))
            mi_dup.connect(
                "activate",
                lambda _b, d=dati_tab, n=nome_tab: self._apri_protocollo(d.get("protocol", "ssh"), n, dict(d)),
            )
            menu.append(mi_dup)

        menu.append(Gtk.SeparatorMenuItem())

        mi_chiudi = Gtk.MenuItem(label=t("tab.close"))
        mi_chiudi.connect("activate", lambda _: self._chiudi_tab(notebook.get_nth_page(idx)))
        menu.append(mi_chiudi)

        menu.show_all()
        menu.popup_at_pointer(event)

    def _on_nb_button_press(self, nb, event):
        if event.button != 3:
            return False
        # Trova su quale tab è il click
        for i in range(nb.get_n_pages()):
            page = nb.get_nth_page(i)
            lbl  = nb.get_tab_label(page)
            if lbl and lbl.get_window():
                alloc = lbl.get_allocation()
                x, y  = lbl.translate_coordinates(nb, 0, 0)
                if x <= event.x <= x + alloc.width and y <= event.y <= y + alloc.height:
                    if i > 0:  # non mostrare menu su Home
                        self._menu_tab(nb, i, event)
                    return True
        return False

    def _on_nb2_button_press(self, nb, event):
        if event.button != 3:
            return False
        for i in range(nb.get_n_pages()):
            page = nb.get_nth_page(i)
            lbl  = nb.get_tab_label(page)
            if lbl and lbl.get_window():
                alloc = lbl.get_allocation()
                x, y  = lbl.translate_coordinates(nb, 0, 0)
                if x <= event.x <= x + alloc.width and y <= event.y <= y + alloc.height:
                    self._menu_tab(nb, i, event)
                    return True
        return False

    def _trova_in_notebook(self, nb: "Gtk.Notebook", widget) -> "tuple[int, object]":
        """Cerca widget (o il Paned che lo contiene) in nb.
        Usa _widget_nb_map per lookup O(1); fallback su iterazione per compatibilità.
        Ritorna (idx, page_widget) se trovato, (-1, widget) altrimenti."""
        mapped_nb = self._widget_nb_map.get(widget)
        if mapped_nb is not None and mapped_nb is nb:
            idx = nb.page_num(widget)
            if idx >= 0:
                return idx, widget
        for i in range(nb.get_n_pages()):
            page = nb.get_nth_page(i)
            if page is widget:
                return i, widget
            if hasattr(page, "get_child1"):
                if page.get_child1() is widget or page.get_child2() is widget:
                    return i, page
        return -1, widget

    def _chiudi_tab_corrente(self):
        """Chiude la tab corrente nel notebook attivo (primo o secondo pannello)."""
        nb  = self._notebook_attivo
        idx = nb.get_current_page()
        # Non chiudere la Home (sempre idx 0 nel notebook primario)
        if nb is self._notebook and idx <= 0:
            return
        widget = nb.get_nth_page(idx)
        if widget:
            self._chiudi_tab(widget)

    def _chiudi_tab(self, widget):
        """Chiude la tab che contiene widget (cerca in entrambi i notebook)."""
        nb = None
        idx = -1
        for candidate in (self._notebook, self._notebook2):
            idx, widget = self._trova_in_notebook(candidate, widget)
            if idx >= 0:
                nb = candidate
                break
        if idx < 0 or nb is None:
            return

        # --- Conferma chiusura se processo attivo ---
        # Trova il TerminalWidget (direttamente o dentro un Paned)
        _term_widget = None
        if hasattr(widget, "_pid"):
            _term_widget = widget
        elif hasattr(widget, "get_child1"):
            for _child in [widget.get_child1(), widget.get_child2()]:
                if _child and hasattr(_child, "_pid"):
                    _term_widget = _child
                    break

        if _term_widget is not None and getattr(_term_widget, "_pid", -1) > 0:
            # Legge l'impostazione dal profilo della sessione
            _dati = getattr(widget, "_pcm_dati", None) or getattr(_term_widget, "_pcm_dati", None)
            _confirm = True  # default: chiedi conferma
            if _dati is not None:
                _confirm = _dati.get("term_confirm_close", True)
            if _confirm:
                _nome_tab = self._get_tab_nome(widget)
                dlg = Gtk.MessageDialog(
                    transient_for=self,
                    modal=True,
                    message_type=Gtk.MessageType.QUESTION,
                    buttons=Gtk.ButtonsType.YES_NO,
                    text=t("tab.close_confirm_title"),
                )
                dlg.format_secondary_text(
                    t("tab.close_confirm_msg", name=_nome_tab) if _nome_tab
                    else t("tab.close_confirm_msg", name="?")
                )
                resp = dlg.run()
                dlg.destroy()
                if resp != Gtk.ResponseType.YES:
                    return  # l'utente ha annullato

        # Cleanup processo gateway SSH (tunnel per RDP/VNC tramite jump host)
        _dati = getattr(widget, "_pcm_dati", None)
        if _dati and _dati.get("_gateway_tunnel"):
            try:
                _dati["_gateway_tunnel"].terminate()
            except Exception as e:
                _log.debug("Terminazione gateway tunnel fallita: %s", e)

        # Cleanup processi
        if hasattr(widget, "chiudi_processo"):
            widget.chiudi_processo()
        elif hasattr(widget, "get_child1"):
            for child in [widget.get_child1(), widget.get_child2()]:
                if child and hasattr(child, "chiudi_processo"):
                    child.chiudi_processo()
        # Cleanup timer di riconnessione
        if hasattr(widget, "_pcm_reconnect_timer"):
            try:
                GLib.source_remove(widget._pcm_reconnect_timer)
            except Exception as e:
                _log.debug("Rimozione timer riconnessione fallita: %s", e)
        nb.remove_page(idx)
        self._tab_labels.pop(widget, None)
        self._widget_nb_map.pop(widget, None)
        if nb is self._notebook2 and nb.get_n_pages() == 0:
            self._notebook2.hide()
        self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names())

    def _on_processo_terminato(self, widget, tab_label=None):
        """Marca la tab come terminata. Se auto_reconnect, programma riconnessione."""
        for nb in (self._notebook, self._notebook2):
            idx, page = self._trova_in_notebook(nb, widget)
            if idx >= 0:
                nome = self._get_tab_nome(page)
                reconnect = getattr(widget, "_pcm_reconnect", None)
                if reconnect:
                    delay = getattr(widget, "_pcm_reconnect_delay", 5)
                    nome_clean = nome.lstrip("↻✖ ") if nome else ""
                    self._set_tab_nome(page, f"↻ {nome_clean} ({delay}s)")
                    widget._pcm_reconnect_timer = GLib.timeout_add(delay * 1000, reconnect)
                else:
                    if nome and not nome.startswith("✖"):
                        self._set_tab_nome(page, f"✖ {nome}")
                self._pannello.aggiorna_sessioni_aperte(self._get_open_session_names())
                return

    # ------------------------------------------------------------------
    # Azioni menu / toolbar
    # ------------------------------------------------------------------

    def _on_nuova_sessione(self):
        dlg = SessionDialog(parent=self)
        resp = dlg.run()
        if resp == Gtk.ResponseType.CANCEL:
            dlg.destroy()
            return
        nome, dati = dlg.get_data()
        profili = config_manager.load_profiles()
        profili[nome] = dati
        config_manager.save_profiles(profili)
        self._pannello.aggiorna(profili)
        dlg.destroy()
        if resp in (100, 101):
            from session_panel import SessionPanel
            self._on_connetti(None, nome, dati)

    def _on_terminale_locale(self):
        s = config_manager.load_settings().get("terminal", {})
        paste_right = s.get("paste_on_right_click", False)
        widget = TerminalWidget(paste_on_right_click=paste_right)
        widget.show_all()
        self._append_tab(widget, "Locale", lambda: self._chiudi_tab(widget))
        widget.avvia_locale()

    def _on_modifica_sessione(self, panel, nome: str, dati: dict):
        dlg = SessionDialog(parent=self, nome=nome, dati=dati)
        resp = dlg.run()
        if resp == Gtk.ResponseType.CANCEL:
            dlg.destroy()
            return
        nuovo_nome, nuovi_dati = dlg.get_data()
        profili = config_manager.load_profiles()
        if nome != nuovo_nome and nome in profili:
            del profili[nome]
        profili[nuovo_nome] = nuovi_dati
        config_manager.save_profiles(profili)
        self._pannello.aggiorna(profili)
        dlg.destroy()
        if resp in (100, 101):
            self._on_connetti(None, nuovo_nome, nuovi_dati)

    def _on_elimina_sessione(self, panel, nome: str):
        profili = config_manager.load_profiles()
        if nome in profili:
            del profili[nome]
            config_manager.save_profiles(profili)
            self._pannello.aggiorna(profili)
        else:
            self._pannello.aggiorna()

    def _on_duplica_sessione(self, panel, nome: str):
        profili = config_manager.load_profiles()
        if nome in profili:
            nuovo_nome = f"{nome} (copia)"
            profili[nuovo_nome] = dict(profili[nome])
            config_manager.save_profiles(profili)
            self._pannello.aggiorna(profili)
        else:
            self._pannello.aggiorna()

    def _on_tunnel_manager(self):
        dlg = TunnelManagerDialog(parent=self)
        dlg.run()
        dlg.destroy()

    # ------------------------------------------------------------------
    # Indicatore tunnel attivi nella toolbar
    # ------------------------------------------------------------------

    def _notifica_tunnel_avvio(self) -> bool:
        """Chiamato 1s dopo l'avvio: riagganicia i tunnel con PID persistito e mostra notifica."""
        reattach_tunnels()  # popola _active_procs dai PID salvati nella config
        attivi = get_active_tunnels()
        if attivi:
            nomi = ", ".join(tun.get("nome", "?") for tun in attivi)
            self._status(t("tunnel.startup_found").format(n=len(attivi)) + f": {nomi}")
        return False  # esegui una volta sola

    def _aggiorna_tun_indicator(self) -> bool:
        attivi = get_active_tunnels()
        n = len(attivi)
        self._lbl_tun_count.set_text(str(n) if n > 0 else "")
        if n > 0:
            tip_key = "tunnel.indicator_tooltip_active1" if n == 1 else "tunnel.indicator_tooltip_activeN"
            self._btn_tun_ind.set_tooltip_text(t(tip_key).format(n=n))
            self._img_tun.get_style_context().add_class("tunnel-active")
            self._lbl_tun_count.get_style_context().add_class("tunnel-active")
        else:
            self._btn_tun_ind.set_tooltip_text(t("tunnel.indicator_tooltip"))
            self._img_tun.get_style_context().remove_class("tunnel-active")
            self._lbl_tun_count.get_style_context().remove_class("tunnel-active")
        return True  # mantieni il timer

    def _on_tun_pop_show(self, popover):
        for w in self._tun_pop_box.get_children():
            w.destroy()

        attivi = get_active_tunnels()

        hdr = Gtk.Label()
        hdr.set_markup(f"<b>{t('tunnel.indicator_header')}</b>")
        hdr.set_halign(Gtk.Align.START)
        self._tun_pop_box.pack_start(hdr, False, False, 0)
        self._tun_pop_box.pack_start(Gtk.Separator(), False, False, 0)

        if not attivi:
            self._tun_pop_box.pack_start(
                Gtk.Label(label=t("tunnel.none_active")), False, False, 0
            )
        else:
            for tun in attivi:
                row = Gtk.Box(spacing=8)
                nome = tun.get("nome", "?")
                tipo = tun.get("tipo", "")
                lport = str(tun.get("local_port", ""))
                lbl = Gtk.Label(label=f"{nome}  ({tipo} :{lport})")
                lbl.set_halign(Gtk.Align.START)
                lbl.set_hexpand(True)
                btn_stop = Gtk.Button(label=t("tunnel.btn_stop"))
                idx = tun["_idx"]
                btn_stop.connect("clicked", lambda b, i=idx: self._ferma_da_ind(i))
                row.pack_start(lbl, True, True, 0)
                row.pack_start(btn_stop, False, False, 0)
                self._tun_pop_box.pack_start(row, False, False, 0)

        self._tun_pop_box.pack_start(Gtk.Separator(), False, False, 0)
        btn_mgr = Gtk.Button(label=t("tunnel.open_manager"))
        btn_mgr.connect("clicked", lambda b: (self._tun_pop.popdown(), self._on_tunnel_manager()))
        self._tun_pop_box.pack_start(btn_mgr, False, False, 0)

        self._tun_pop_box.show_all()

    def _ferma_da_ind(self, idx: int):
        stop_tunnel(idx)
        self._tun_pop.popdown()
        self._aggiorna_tun_indicator()

    def _on_impostazioni(self):
        dlg = SettingsDialog(parent=self)
        resp = dlg.run()
        dlg.destroy()
        if resp == Gtk.ResponseType.OK:
            self._settings = config_manager.load_settings()
            self._riapplica_accels()
            _tr.init_from_settings()
            if hasattr(self, "_menu_btn") and self._menu_btn is not None:
                self._menu_btn.set_popup(self._build_menu())

    def _riapplica_accels(self):
        """Riapplica gli acceleratori dopo un salvataggio impostazioni."""
        if hasattr(self, "_accel_group") and self._accel_group:
            self._setup_accels()

    def _on_importa_sessioni(self):
        """Dialog di importazione sessioni da sorgenti esterne."""
        dlg = Gtk.Dialog(
            title=t("import.title"),
            transient_for=self,
            modal=True,
            destroy_with_parent=True
        )
        dlg.set_default_size(480, 0)
        area = dlg.get_content_area()
        area.set_spacing(10)
        area.set_margin_start(16); area.set_margin_end(16)
        area.set_margin_top(16);  area.set_margin_bottom(8)

        lbl = Gtk.Label()
        lbl.set_markup(f"<b>{t('import.label')}</b>")
        area.pack_start(lbl, False, False, 0)

        # Sorgenti: 0=Remmina, 1=RDM, 2=PuTTY, 3=SSH Config, 4=MobaXterm
        # (indici usati in _esegui e _on_src_changed)
        SORGENTI = [
            t("import.source_remmina"),
            t("import.source_rdm"),
            t("importer.putty_title"),
            t("importer.ssh_cfg_title"),
            t("importer.moba_title"),
        ]

        sorgente_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        lbl_src = Gtk.Label(label=t("import.source_lbl"))
        lbl_src.set_xalign(0.0)
        combo_src = Gtk.ComboBoxText()
        for s in SORGENTI:
            combo_src.append_text(s)
        combo_src.set_active(0)
        combo_src.set_hexpand(True)
        sorgente_box.pack_start(lbl_src, False, False, 0)
        sorgente_box.pack_start(combo_src, True, True, 0)
        area.pack_start(sorgente_box, False, False, 0)

        # Selettore file (solo per sorgenti file: Remmina e RDM)
        fc = Gtk.FileChooserButton(title=t("import.file_chooser"),
                                   action=Gtk.FileChooserAction.OPEN)
        fc.set_hexpand(True)
        area.pack_start(fc, False, False, 0)

        _filters_remmina = [("Remmina", "*.remmina"), (t("import.filter_all"), "*")]
        _filters_rdm     = [(t("import.filter_rdmxml"), "*.rdm"), (t("import.filter_rdmjson"), "*.json"), (t("import.filter_all"), "*")]
        _filters_moba    = [("MobaXterm sessions", "*.mxtsessions"), ("MobaXterm config", "*.mobaconf"), (t("import.filter_all"), "*")]

        def _set_filters(filtri):
            for old in fc.list_filters():
                fc.remove_filter(old)
            for nome_f, pattern in filtri:
                f = Gtk.FileFilter(); f.set_name(nome_f); f.add_pattern(pattern)
                fc.add_filter(f)

        _set_filters(_filters_remmina)

        def _on_src_changed(_combo):
            src = combo_src.get_active()
            file_based = src in (0, 1, 4)
            fc.set_sensitive(file_based)
            if src == 0:
                _set_filters(_filters_remmina)
            elif src == 1:
                _set_filters(_filters_rdm)
            elif src == 4:
                _set_filters(_filters_moba)

        combo_src.connect("changed", _on_src_changed)

        chk_sost = Gtk.CheckButton(label=t("import.overwrite"))
        area.pack_start(chk_sost, False, False, 0)

        lbl_result = Gtk.Label(label="")
        lbl_result.set_xalign(0.0); lbl_result.set_line_wrap(True)
        area.pack_start(lbl_result, False, False, 0)

        btn_import = dlg.add_button(t("import.btn"), Gtk.ResponseType.APPLY)
        btn_import.get_style_context().add_class("suggested-action")
        dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)

        def _esegui(b):
            import importer as _imp
            src = combo_src.get_active()
            try:
                _moba_warn = False
                if src == 0:  # Remmina
                    percorso = fc.get_filename()
                    if not percorso:
                        lbl_result.set_markup(f"<span foreground='red'>{t('import.no_file')}</span>")
                        return
                    nuovi = _imp.importa_remmina(percorso)
                elif src == 1:  # RDM
                    percorso = fc.get_filename()
                    if not percorso:
                        lbl_result.set_markup(f"<span foreground='red'>{t('import.no_file')}</span>")
                        return
                    nuovi = _imp.importa_rdm(percorso)
                elif src == 2:  # PuTTY
                    nuovi = _imp.importa_putty()
                    if not nuovi:
                        lbl_result.set_markup(f"<span foreground='orange'>{t('importer.putty_none')}</span>")
                        return
                elif src == 3:  # SSH Config
                    nuovi = _imp.importa_ssh_config()
                    if not nuovi:
                        lbl_result.set_markup(f"<span foreground='orange'>{t('importer.ssh_cfg_none')}</span>")
                        return
                else:  # MobaXterm
                    percorso = fc.get_filename()
                    if not percorso:
                        lbl_result.set_markup(f"<span foreground='red'>{t('import.no_file')}</span>")
                        return
                    nuovi = _imp.importa_mobaxterm(percorso)
                    if not nuovi:
                        lbl_result.set_markup(f"<span foreground='orange'>{t('importer.moba_none')}</span>")
                        return
                    _moba_warn = True

                aggiunti, saltati = _imp.unisci_in_pcm(nuovi, chk_sost.get_active())
                _skipped_str = t("import.skipped", n=saltati) if saltati else ""
                _res = t("import.result", n=aggiunti, skipped=_skipped_str)
                if _moba_warn:
                    _res += f"\n{t('importer.moba_warn')}"
                lbl_result.set_markup(
                    f"<span foreground='green'>{_res}</span>"
                )
                self._pannello.aggiorna()
            except Exception as e:
                lbl_result.set_markup(f"<span foreground='red'>{t('import.error', e=e)}</span>")

        btn_import.connect("clicked", _esegui)
        dlg.show_all()
        dlg.run()
        dlg.destroy()

    def _on_ftp_server(self):
        from ftp_server_dialog import FtpServerDialog
        dlg = FtpServerDialog(parent=self)
        dlg.run()
        dlg.destroy()

    # ------------------------------------------------------------------
    # Quick connect
    # ------------------------------------------------------------------

    def _on_quick_connect(self):
        """Dialog connessione rapida senza salvare la sessione."""
        result = QuickConnectDialog(parent=self).run_and_get()
        if result:
            proto, nome_tab, dati = result
            self._apri_protocollo(proto, nome_tab, dati)

    # ------------------------------------------------------------------
    # Connectivity test / ping
    # ------------------------------------------------------------------

    def _on_ping_sessione(self, _panel, nome: str, dati: dict):
        host = dati.get("host", "")
        try:
            port = int(dati.get("port", 22))
        except (ValueError, TypeError):
            port = 22

        dlg = Gtk.MessageDialog(
            transient_for=self,
            modal=True,
            message_type=Gtk.MessageType.INFO,
            buttons=Gtk.ButtonsType.CLOSE,
            text=f"Ping: {nome}",
        )
        dlg.format_secondary_text(t("ping.testing"))
        dlg.show_all()

        def _cb(ms):
            if ms >= 0:
                dlg.format_secondary_markup(
                    f"<span foreground='green'>{t('ping.ok', ms=ms)}</span>"
                )
            else:
                dlg.format_secondary_markup(
                    f"<span foreground='red'>{t('ping.fail', port=port)}</span>"
                )

        self._test_connettivita(host, port, _cb)
        dlg.run()
        dlg.destroy()

    def _test_connettivita(self, host: str, port: int, callback):
        """Verifica TCP raggiungibilità in thread. Chiama callback(ms) o callback(-1)."""
        import socket, time
        def _check():
            try:
                t0 = time.monotonic()
                with socket.create_connection((host, port), timeout=5):
                    ms = int((time.monotonic() - t0) * 1000)
                GLib.idle_add(callback, ms)
            except Exception:
                GLib.idle_add(callback, -1)
        threading.Thread(target=_check, daemon=True).start()

    # ------------------------------------------------------------------
    # Broadcast terminali
    # ------------------------------------------------------------------

    def _raccoglie_terminal_widgets(self) -> list:
        """Restituisce lista di (nome_tab, TerminalWidget) attivi."""
        result = []
        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                page = nb.get_nth_page(i)
                tw = None
                if isinstance(page, TerminalWidget):
                    tw = page
                elif hasattr(page, "get_child1"):
                    c1 = page.get_child1()
                    if isinstance(c1, TerminalWidget):
                        tw = c1
                if tw and not getattr(tw, "_stato_terminato", True):
                    nome = self._get_tab_nome(page) or f"Tab {i}"
                    result.append((nome, tw))
        return result

    def _on_broadcast(self):
        """Dialog broadcast: invia testo a più terminali selezionati."""
        terminali = self._raccoglie_terminal_widgets()

        dlg = Gtk.Dialog(
            title=t("broadcast.title"), transient_for=self,
            modal=True, destroy_with_parent=True
        )
        dlg.set_default_size(500, 380)
        area = dlg.get_content_area()
        area.set_spacing(8)
        area.set_margin_start(16); area.set_margin_end(16)
        area.set_margin_top(12);  area.set_margin_bottom(8)

        if not terminali:
            lbl_no = Gtk.Label(label=t("broadcast.no_terminals"))
            area.pack_start(lbl_no, True, True, 0)
            dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)
            dlg.show_all(); dlg.run(); dlg.destroy()
            return

        lbl = Gtk.Label(label=t("broadcast.label"))
        lbl.set_xalign(0.0)
        area.pack_start(lbl, False, False, 0)

        # Lista terminali con checkbox
        scroll_t = Gtk.ScrolledWindow()
        scroll_t.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
        scroll_t.set_min_content_height(120)
        chk_list = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=2)
        scroll_t.add(chk_list)
        checks = []
        for nome_tab, tw in terminali:
            chk = Gtk.CheckButton(label=nome_tab)
            chk.set_active(True)
            chk.set_tooltip_text(getattr(tw, "_stato_testo", ""))
            chk_list.pack_start(chk, False, False, 0)
            checks.append((chk, tw))
        area.pack_start(scroll_t, True, True, 0)

        # Pulsanti seleziona/deseleziona
        btn_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
        btn_all = Gtk.Button(label=t("broadcast.select_all"))
        btn_all.connect("clicked", lambda _: [c.set_active(True) for c, _ in checks])
        btn_none = Gtk.Button(label=t("broadcast.deselect_all"))
        btn_none.connect("clicked", lambda _: [c.set_active(False) for c, _ in checks])
        btn_row.pack_start(btn_all, False, False, 0)
        btn_row.pack_start(btn_none, False, False, 0)
        area.pack_start(btn_row, False, False, 0)

        # Area testo
        lbl2 = Gtk.Label(label=t("broadcast.label"))
        lbl2.set_xalign(0.0)
        area.pack_start(lbl2, False, False, 0)

        sw_txt = Gtk.ScrolledWindow()
        sw_txt.set_min_content_height(80)
        tv = Gtk.TextView()
        tv.set_monospace(True)
        sw_txt.add(tv)
        area.pack_start(sw_txt, True, True, 0)

        chk_newline = Gtk.CheckButton(label=t("broadcast.add_enter"))
        chk_newline.set_active(True)
        area.pack_start(chk_newline, False, False, 0)

        lbl_result = Gtk.Label(label="")
        lbl_result.set_xalign(0.0)
        area.pack_start(lbl_result, False, False, 0)

        btn_send = dlg.add_button(t("broadcast.send"), Gtk.ResponseType.APPLY)
        btn_send.get_style_context().add_class("suggested-action")
        dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)

        def _invia(b):
            buf = tv.get_buffer()
            testo = buf.get_text(buf.get_start_iter(), buf.get_end_iter(), True)
            if not testo:
                return
            add_nl = chk_newline.get_active()
            payload = (testo + "\n").encode("utf-8") if add_nl else testo.encode("utf-8")
            n_inviati = 0
            for chk, tw in checks:
                if chk.get_active():
                    try:
                        tw._vte.feed_child(payload)
                        n_inviati += 1
                    except Exception as e:
                        _log.debug("Broadcast feed_child fallito: %s", e)
            lbl_result.set_markup(f"<span foreground='green'>{t('broadcast.sent', n=n_inviati)}</span>")

        btn_send.connect("clicked", _invia)
        dlg.show_all()
        while True:
            resp = dlg.run()
            if resp != Gtk.ResponseType.APPLY:
                break
        dlg.destroy()

    # ------------------------------------------------------------------
    # Audit log viewer
    # ------------------------------------------------------------------

    def _on_audit_log(self):
        """Dialog visualizzazione registro audit connessioni."""
        dlg = Gtk.Dialog(
            title=t("audit.title"), transient_for=self,
            modal=True, destroy_with_parent=True
        )
        dlg.set_default_size(820, 480)
        area = dlg.get_content_area()
        area.set_margin_start(12); area.set_margin_end(12)
        area.set_margin_top(8);   area.set_margin_bottom(8)

        # TreeView
        store = Gtk.ListStore(str, str, str, str, str, str)
        tv = Gtk.TreeView(model=store)
        for i, col_title in enumerate([
            t("audit.col_time"), t("audit.col_session"), t("audit.col_host"),
            t("audit.col_proto"), t("audit.col_duration"), t("audit.col_status")
        ]):
            cell = Gtk.CellRendererText()
            col = Gtk.TreeViewColumn(col_title, cell, text=i)
            col.set_resizable(True)
            tv.append_column(col)

        def _ricarica():
            store.clear()
            log = config_manager.audit_load()
            if not log:
                store.append(["", t("audit.no_entries"), "", "", "", ""])
                return
            for e in reversed(log):
                dur = e.get("duration", 0)
                dur_str = f"{dur}s" if dur < 60 else f"{dur//60}m{dur%60:02d}s"
                stato = t("audit.status_ok") if e.get("status") == "ok" else t("audit.status_err")
                store.append([
                    e.get("ts", ""), e.get("session", ""), e.get("host", ""),
                    e.get("proto", ""), dur_str, stato
                ])

        _ricarica()

        sw = Gtk.ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
        sw.add(tv)
        area.pack_start(sw, True, True, 0)

        btn_row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        btn_row.set_margin_top(6)
        btn_clear = Gtk.Button(label=t("audit.clear"))
        btn_clear.get_style_context().add_class("destructive-action")
        def _cancella(_b):
            config_manager.audit_clear()
            _ricarica()
        btn_clear.connect("clicked", _cancella)

        btn_csv = Gtk.Button(label=t("audit.export_csv"))
        def _esporta_csv(_b):
            import csv, io
            fc = Gtk.FileChooserDialog(
                title=t("audit.csv_title"), transient_for=dlg,
                action=Gtk.FileChooserAction.SAVE
            )
            fc.add_button(t("audit.csv_cancel"), Gtk.ResponseType.CANCEL)
            fc.add_button(t("audit.csv_save"),   Gtk.ResponseType.OK)
            fc.set_current_name("pcm_audit.csv")
            if fc.run() == Gtk.ResponseType.OK:
                path = fc.get_filename()
                log  = config_manager.audit_load()
                with open(path, "w", newline="", encoding="utf-8") as f:
                    w = csv.DictWriter(f, fieldnames=["ts","session","host","proto","duration","status"])
                    w.writeheader(); w.writerows(log)
            fc.destroy()
        btn_csv.connect("clicked", _esporta_csv)

        btn_row.pack_start(btn_clear, False, False, 0)
        btn_row.pack_end(btn_csv, False, False, 0)
        area.pack_start(btn_row, False, False, 0)

        dlg.add_button(t("dialog.close"), Gtk.ResponseType.CLOSE)
        dlg.show_all()
        dlg.run()
        dlg.destroy()

    # ------------------------------------------------------------------
    # KeePassXC settings (placeholder — configurazione associazione)
    # ------------------------------------------------------------------

    def _on_keepass_settings(self):
        """Apre il dialog impostazioni KeePassXC."""
        try:
            from keepassxc_manager import KeePassXCSettingsDialog
            dlg = KeePassXCSettingsDialog(parent=self)
            dlg.run()
            dlg.destroy()
        except ImportError:
            self._warn(t("keepass.missing"))

    def _on_variabili_globali(self):
        """Dialog variabili globali (variabili {VAR} usabili nei comandi)."""
        from variables_dialog import VariablesDialog
        dlg = VariablesDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _on_gestione_crypto(self):
        """Dialog gestione password master / cifratura credenziali."""
        from crypto_manager_dialog import CryptoManagerDialog
        dlg = CryptoManagerDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _on_check_deps(self):
        """Apre il pannello di configurazione dei percorsi eseguibili."""
        from deps_dialog import DepsConfigDialog
        dlg = DepsConfigDialog(parent=self)
        dlg.run()
        dlg.destroy()

    def _on_guida(self):
        """Apre la guida HTML nella lingua corrente (fallback inglese)."""
        import os
        from translations import get_lang
        here = os.path.dirname(os.path.abspath(__file__))
        lang = get_lang()
        # Cerca prima il file specifico per la lingua, poi cade sull'inglese
        html_path = os.path.join(here, f"pcm_help_{lang}.html")
        if not os.path.exists(html_path):
            html_path = os.path.join(here, "pcm_help_en.html")
        if not os.path.exists(html_path):
            dlg = Gtk.MessageDialog(
                transient_for=self,
                modal=True,
                message_type=Gtk.MessageType.WARNING,
                buttons=Gtk.ButtonsType.CLOSE,
                text=t("guide.file_missing"),
            )
            dlg.run()
            dlg.destroy()
            return
        import subprocess
        subprocess.Popen(["xdg-open", html_path])

    def _on_about(self):
        """Dialog Informazioni su PCM."""
        dlg = Gtk.Dialog(
            title="PCM — Python Connection Manager",
            transient_for=self,
            modal=True,
        )  # titolo app: non tradotto intenzionalmente
        dlg.set_default_size(400, -1)
        dlg.add_button("OK", Gtk.ResponseType.OK)

        box = dlg.get_content_area()
        box.set_spacing(12)
        box.set_margin_start(20)
        box.set_margin_end(20)
        box.set_margin_top(16)
        box.set_margin_bottom(12)

        lbl_title = Gtk.Label()
        lbl_title.set_markup("<b>PCM — Python Connection Manager</b>")
        lbl_title.set_xalign(0.0)
        box.pack_start(lbl_title, False, False, 0)

        lbl_desc = Gtk.Label(label=t("about.dev_label"))
        lbl_desc.set_xalign(0.0)
        box.pack_start(lbl_desc, False, False, 0)

        lbl_proto = Gtk.Label()
        lbl_proto.set_markup(t("about.proto_label"))
        lbl_proto.set_xalign(0.0)
        lbl_proto.set_line_wrap(True)
        box.pack_start(lbl_proto, False, False, 0)

        lbl_author = Gtk.Label()
        lbl_author.set_markup(
            "<b>Autore:</b> Andres Zanzani - "
            "<a href=\"mailto:azanzani@gmail.com\">azanzani@gmail.com</a>"
        )
        lbl_author.set_xalign(0.0)
        box.pack_start(lbl_author, False, False, 0)

        lbl_gh = Gtk.Label()
        lbl_gh.set_markup(
            "<b>GitHub:</b> "
            "<a href=\"https://github.com/buzzqw/Python_Connection_Manager\">"
            "github.com/buzzqw/Python_Connection_Manager</a>"
        )
        lbl_gh.set_xalign(0.0)
        box.pack_start(lbl_gh, False, False, 0)

        lbl_lic = Gtk.Label()
        lbl_lic.set_markup(t("about.license_label"))
        lbl_lic.set_xalign(0.0)
        box.pack_start(lbl_lic, False, False, 0)

        box.show_all()
        dlg.run()
        dlg.destroy()

    def _on_esci(self):
        self.get_application().quit()

    # ------------------------------------------------------------------
    # Chiusura finestra
    # ------------------------------------------------------------------

    def _on_close(self, window, event):
        settings = config_manager.load_settings()
        if settings.get("general", {}).get("confirm_on_exit", True):
            # Conta tab aperte (escludi la tab benvenuto)
            n_tabs = self._notebook.get_n_pages() - 1
            if n_tabs > 0:
                dlg = Gtk.MessageDialog(
                    transient_for=self,
                    modal=True,
                    message_type=Gtk.MessageType.QUESTION,
                    buttons=Gtk.ButtonsType.YES_NO,
                    text=t("close.title"),
                )
                dlg.format_secondary_text(t("close.confirm_msg"))
                resp = dlg.run()
                dlg.destroy()
                if resp != Gtk.ResponseType.YES:
                    return True  # blocca la chiusura
        # Controlla tunnel SSH attivi
        tunnel_attivi = get_active_tunnels()
        if tunnel_attivi:
            nomi = "\n".join(f"  • {tun.get('nome', '?')}" for tun in tunnel_attivi)
            dlg = Gtk.Dialog(
                title=t("tunnel.close_warning_title"),
                transient_for=self,
                modal=True,
                destroy_with_parent=True,
            )
            dlg.set_default_size(400, 0)
            area = dlg.get_content_area()
            area.set_spacing(8)
            area.set_margin_start(16); area.set_margin_end(16)
            area.set_margin_top(16);  area.set_margin_bottom(8)
            lbl = Gtk.Label()
            msg = t("tunnel.close_warning_msg").replace("<b>", "").replace("</b>", "").format(
                n=len(tunnel_attivi), names=nomi
            )
            lbl.set_text(msg)
            lbl.set_line_wrap(True)
            lbl.set_xalign(0.0)
            area.pack_start(lbl, False, False, 0)
            area.show_all()
            # Pulsanti: Annulla | Lascia attivi | Ferma tunnel
            _RESP_CANCEL = 0
            _RESP_KEEP   = 1
            _RESP_STOP   = 2
            dlg.add_button(t("tunnel.close_cancel"), _RESP_CANCEL)
            dlg.add_button(t("tunnel.close_keep"),   _RESP_KEEP)
            dlg.add_button(t("tunnel.close_stop"),   _RESP_STOP)
            resp = dlg.run()
            dlg.destroy()
            if resp == _RESP_CANCEL:
                return True  # blocca la chiusura
            if resp == _RESP_STOP:
                for tun in tunnel_attivi:
                    stop_tunnel(tun["_idx"])
            # _RESP_KEEP: lascia i tunnel attivi, si chiude normalmente
        # Salva sessioni aperte per il ripristino al prossimo avvio
        s_r = config_manager.load_settings()
        if s_r.get("general", {}).get("restore_sessions_on_start", False):
            restore_list = []
            for nb in (self._notebook, self._notebook2):
                for i in range(nb.get_n_pages()):
                    pg = nb.get_nth_page(i)
                    if pg and hasattr(pg, "_pcm_dati"):
                        d = pg._pcm_dati
                        restore_list.append({
                            "host":        d.get("host", ""),
                            "protocol":    d.get("protocol", "ssh"),
                            "port":        d.get("port", "22"),
                            "user":        d.get("user", ""),
                            "ft_protocol": d.get("ft_protocol", ""),
                        })
            s_r["_restore_sessions"] = restore_list
        else:
            s_r.pop("_restore_sessions", None)
        config_manager.save_settings(s_r)

        # Chiudi tutti i processi aperti
        def _chiudi_ricorsivo(widget):
            if hasattr(widget, "chiudi_processo"):
                try:
                    widget.chiudi_processo()
                except Exception as e:
                    _log.debug("chiudi_processo fallito: %s", e)
            elif hasattr(widget, "get_child1"):
                for child in (widget.get_child1(), widget.get_child2()):
                    if child:
                        _chiudi_ricorsivo(child)
            _dati = getattr(widget, "_pcm_dati", None)
            if _dati and _dati.get("_gateway_tunnel"):
                try:
                    _dati["_gateway_tunnel"].terminate()
                except Exception as e:
                    _log.debug("Terminazione gateway tunnel fallita: %s", e)

        for nb in (self._notebook, self._notebook2):
            for i in range(nb.get_n_pages()):
                page = nb.get_nth_page(i)
                if page is None:
                    continue
                _chiudi_ricorsivo(page)
        if self._auto_lock_timer:
            GLib.source_remove(self._auto_lock_timer)
        if hasattr(self, "_timer_stato_live") and self._timer_stato_live:
            GLib.source_remove(self._timer_stato_live)
        if hasattr(self, "_timer_tun_ind") and self._timer_tun_ind:
            GLib.source_remove(self._timer_tun_ind)
        return False  # permetti chiusura

    # ------------------------------------------------------------------
    # Session restore
    # ------------------------------------------------------------------

    def _ripristina_sessioni(self) -> bool:
        s       = config_manager.load_settings()
        refs    = s.pop("_restore_sessions", [])
        if not refs:
            return False
        config_manager.save_settings(s)

        profili = config_manager.load_profiles()

        lookup = {}
        for gruppo in profili.values():
            if not isinstance(gruppo, dict):
                continue
            for nome, dati in gruppo.items():
                key = (dati.get("host"), dati.get("protocol", "ssh"),
                       str(dati.get("port", "22")), dati.get("user", ""),
                       dati.get("ft_protocol", ""))
                lookup[key] = (nome, dati)

        for ref in refs:
            key = (ref.get("host", ""), ref.get("protocol", "ssh"),
                   str(ref.get("port", "22")), ref.get("user", ""),
                   ref.get("ft_protocol", ""))
            found = lookup.get(key)
            if found:
                self._apri_protocollo(found[1].get("protocol", "ssh"), found[0], dict(found[1]))

        return False  # one-shot GLib.timeout_add

    # ------------------------------------------------------------------
    # Utility
    # ------------------------------------------------------------------

    def _on_switch_tab(self, notebook, page, page_num):
        """Aggiorna statusbar e pannello info al cambio tab."""
        self._notebook_attivo = notebook
        is_home = page not in self._tab_labels
        if is_home:
            self._status(t("status.ready"))
            self._info_panel.nascondi()
        else:
            nome_pulito = self._get_tab_nome(page).lstrip("✖ ")
            self._status(t("status.connected", name=nome_pulito))
            dati = getattr(page, "_pcm_dati", None)
            if dati and dati.get("protocol") in ("ssh", "mosh", "vnc", "rdp"):
                self._info_panel.aggiorna_per_sessione(dati)
            else:
                self._info_panel.nascondi()

    def _aggiorna_stato_live(self) -> bool:
        """Timer ogni 3s: aggiorna la statusbar con le stat live del terminale attivo."""
        idx = self._notebook.get_current_page()
        if idx <= 0:
            return True
        page = self._notebook.get_nth_page(idx)
        if page is None:
            return True
        # Cerca il TerminalWidget (può essere direttamente la page o figlio di Paned)
        tw = None
        if hasattr(page, "get_stato"):
            tw = page
        elif hasattr(page, "get_child1"):
            child = page.get_child1()
            if child and hasattr(child, "get_stato"):
                tw = child
        if tw is None:
            return True
        stato, terminato = tw.get_stato()
        if not stato:
            return True
        nome_pulito = self._get_tab_nome(page).lstrip("✖ ")
        if terminato:
            self._status(t("status.terminated", name=nome_pulito, state=stato))
        else:
            self._status(t("status.active", name=nome_pulito, state=stato))
        return True  # continua il timer

    def _status(self, msg: str):
        self._statusbar.pop(self._statusbar_ctx)
        self._statusbar.push(self._statusbar_ctx, msg)

    def _warn(self, msg: str):
        self._mostra_toast(msg, "warning")

    def _mostra_toast(self, msg: str, css_class: str = ""):
        self._toast_label.set_text(msg)
        if css_class:
            css_name = f"toast-{css_class}"
            self._toast_box.get_style_context().add_class(css_name)
        self._toast_revealer.set_reveal_child(True)
        if self._toast_timer:
            GLib.source_remove(self._toast_timer)
        self._toast_timer = GLib.timeout_add(5000, self._nascondi_toast)

    def _nascondi_toast(self):
        self._toast_revealer.set_reveal_child(False)
        self._toast_box.get_style_context().remove_class("toast-warning")
        self._toast_box.get_style_context().remove_class("toast-error")
        self._toast_box.get_style_context().remove_class("toast-info")
        self._toast_timer = 0
        return False

    def _invia_wol(self, mac: str, attesa: int) -> str:
        """Invia magic packet WoL e attende. Restituisce stringa errore o "" se OK.
        Thread-safe: non tocca la UI."""
        import socket, time
        try:
            mac_clean = mac.replace(":", "").replace("-", "")
            payload = bytes.fromhex("FF" * 6 + mac_clean * 16)
            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
                s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
                s.sendto(payload, ("<broadcast>", 9))
            time.sleep(attesa)
            return ""
        except Exception as e:
            return str(e)


# ===========================================================================
# Applicazione GTK
# ===========================================================================


# ---------------------------------------------------------------------------
# Dialog "Apri SFTP/FTP da sessione esistente"
# ---------------------------------------------------------------------------

class _SessionPickerDialog(Gtk.Dialog):
    """Dialog multi-selezione sessioni per cluster, con salvataggio/caricamento."""

    def __init__(self, parent, profili: dict):
        super().__init__(
            title=t("cluster.pick_session"),
            transient_for=parent, modal=True, destroy_with_parent=True,
        )
        self.set_default_size(500, 500)
        self._selected: list[str] = []
        self._profili = profili
        self._saved_clusters = config_manager.load_settings().get("saved_clusters", {})

        area = self.get_content_area()
        area.set_spacing(6)
        area.set_margin_start(12); area.set_margin_end(12)
        area.set_margin_top(10); area.set_margin_bottom(6)

        title_lbl = Gtk.Label()
        title_lbl.set_markup(f"<b>{t('cluster.pick_session')}</b>")
        title_lbl.set_xalign(0.0); title_lbl.set_margin_bottom(2)
        area.pack_start(title_lbl, False, False, 0)

        # ── Sezione cluster salvati ──────────────────────────────
        if self._saved_clusters:
            saved_frame = Gtk.Frame(label=f"  {t('cluster.saved_title')}  ")
            saved_frame.set_label_align(0.02, 0.5)
            saved_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
            saved_box.set_margin_start(8); saved_box.set_margin_end(8)
            saved_box.set_margin_top(6); saved_box.set_margin_bottom(8)

            for cname, cdata in sorted(self._saved_clusters.items()):
                row = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
                sessions_list = ", ".join(cdata.get("sessions", [])[:5])
                if len(cdata.get("sessions", [])) > 5:
                    sessions_list += f" +{len(cdata['sessions']) - 5}"
                lbl = Gtk.Label(label=f"{cname}")
                lbl.set_xalign(0.0); lbl.set_hexpand(True)
                row.pack_start(lbl, True, True, 0)
                detail = Gtk.Label(label=f"({sessions_list})")
                detail.set_xalign(0.0)
                detail.get_style_context().add_class("dim-label")
                row.pack_start(detail, False, False, 0)
                btn_load = Gtk.Button(label=t("cluster.load"))
                btn_load.set_relief(Gtk.ReliefStyle.NONE)
                btn_load.connect("clicked", lambda b, cn=cname: self._load_cluster(cn))
                row.pack_start(btn_load, False, False, 0)
                btn_del = Gtk.Button()
                btn_del.set_relief(Gtk.ReliefStyle.NONE)
                btn_del.add(Gtk.Image.new_from_icon_name("edit-delete-symbolic", Gtk.IconSize.BUTTON))
                btn_del.connect("clicked", lambda b, cn=cname: self._delete_cluster(cn))
                row.pack_start(btn_del, False, False, 0)
                saved_box.pack_start(row, False, False, 0)

            saved_frame.add(saved_box)
            area.pack_start(saved_frame, False, False, 0)

        # ── Descrizione ──────────────────────────────────────────
        desc = Gtk.Label()
        desc.set_markup(f"<small>{t('cluster.pick_multi_desc')}</small>")
        desc.set_xalign(0.0); desc.set_line_wrap(True)
        desc.set_margin_top(4)
        area.pack_start(desc, False, False, 0)

        # ── Ricerca ──────────────────────────────────────────────
        search = Gtk.SearchEntry()
        search.set_placeholder_text(t("sidebar.search_placeholder"))
        search.set_margin_top(4)
        area.pack_start(search, False, False, 0)

        # ── Lista sessioni ───────────────────────────────────────
        sw = Gtk.ScrolledWindow()
        sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)

        store = Gtk.ListStore(bool, str, str, str, int)
        self._store = store
        self._tree = Gtk.TreeView(model=store)
        self._tree.set_headers_visible(True)

        col_sel = Gtk.TreeViewColumn("")
        cell_toggle = Gtk.CellRendererToggle()
        cell_toggle.connect("toggled", self._on_toggle, store)
        col_sel.pack_start(cell_toggle, False)
        col_sel.add_attribute(cell_toggle, "active", 0)
        self._tree.append_column(col_sel)

        for title, idx, expand in [(t("sd.session_name"), 1, True),
                                    (t("sd.protocol"), 2, False),
                                    (t("sd.host"), 3, True)]:
            cell = Gtk.CellRendererText()
            col = Gtk.TreeViewColumn(title, cell, text=idx)
            col.set_expand(expand)
            self._tree.append_column(col)

        self._all_items: list[dict] = []
        for nome, dati in sorted(profili.items()):
            proto = protocols.PROTO_LABEL.get(dati.get("protocol", ""), dati.get("protocol", ""))
            host = dati.get("host", "")
            self._all_items.append({"nome": nome, "proto": proto, "host": host, "idx": len(self._all_items)})

        self._lbl_count = Gtk.Label()

        self._rebuild = lambda f="": self._do_rebuild(f)
        self._rebuild()
        search.connect("search-changed", lambda e: self._rebuild(e.get_text()))

        self._tree.connect("row-activated", self._on_row_activated)
        sw.add(self._tree)
        area.pack_start(sw, True, True, 0)

        # ── Barra inferiore: contatore + Salva ──────────────────
        bottom = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=8)
        bottom.set_margin_top(4)

        bottom.pack_start(self._lbl_count, True, True, 0)
        self._update_count()

        btn_save = Gtk.Button(label=t("cluster.save_btn"))
        btn_save.set_tooltip_text(t("cluster.save_btn_tt"))
        btn_save.connect("clicked", lambda b: self._save_current_cluster())
        bottom.pack_start(btn_save, False, False, 0)

        area.pack_start(bottom, False, False, 0)

        self.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        self.add_button(t("sd.ok"), Gtk.ResponseType.OK)

    def _on_toggle(self, cell, path, store):
        store[path][0] = not store[path][0]
        self._update_count()

    def _on_row_activated(self, tree, path, column):
        if column is not None:
            self.response(Gtk.ResponseType.OK)

    def _do_rebuild(self, filtro: str):
        self._store.clear()
        f = filtro.strip().lower()
        for item in self._all_items:
            if f and f not in item["nome"].lower() and f not in item["host"].lower():
                continue
            self._store.append([False, item["nome"], item["proto"], item["host"], item["idx"]])
        self._update_count()

    def _update_count(self):
        n = sum(1 for row in self._store if row[0])
        if n == 0:
            self._lbl_count.set_markup(
                f"<small><span foreground='#888'>{t('cluster.sel_none')}</span></small>")
        else:
            self._lbl_count.set_markup(
                f"<small><b>{t('cluster.sel_count', n=n)}</b></small>  "
                f"<small><span foreground='#888'>{t('cluster.sel_hint')}</span></small>")

    def get_selected(self) -> list[str]:
        return [row[1] for row in self._store if row[0]]

    def _load_cluster(self, cname: str):
        cdata = self._saved_clusters.get(cname, {})
        sessions = cdata.get("sessions", [])
        for row in self._store:
            if row[1] in sessions:
                row[0] = True
        self._update_count()

    def _delete_cluster(self, cname: str):
        dlg = Gtk.MessageDialog(
            transient_for=self, modal=True,
            message_type=Gtk.MessageType.QUESTION,
            buttons=Gtk.ButtonsType.YES_NO,
            text=t("cluster.delete_confirm", name=cname))
        resp = dlg.run()
        dlg.destroy()
        if resp == Gtk.ResponseType.YES:
            s = config_manager.load_settings()
            s.get("saved_clusters", {}).pop(cname, None)
            config_manager.save_settings(s)
            self._saved_clusters.pop(cname, None)
            self._warn_info(t("cluster.deleted", name=cname))

    def _save_current_cluster(self):
        selected = self.get_selected()
        if not selected:
            self._warn_info(t("cluster.save_no_sel"))
            return
        dlg = Gtk.Dialog(
            title=t("cluster.save_title"),
            transient_for=self, modal=True, destroy_with_parent=True,
        )
        dlg.set_default_size(350, -1)
        area = dlg.get_content_area()
        area.set_spacing(6); area.set_margin_start(12); area.set_margin_end(12)
        area.set_margin_top(10); area.set_margin_bottom(6)
        lbl = Gtk.Label(label=t("cluster.save_name_lbl"))
        lbl.set_xalign(0.0)
        area.pack_start(lbl, False, False, 0)
        entry = Gtk.Entry()
        entry.set_placeholder_text(t("cluster.save_ph"))
        entry.set_activates_default(True)
        area.pack_start(entry, False, False, 0)
        area.show_all()
        dlg.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        dlg.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        dlg.set_default_response(Gtk.ResponseType.OK)
        resp = dlg.run()
        nome = entry.get_text().strip()
        dlg.destroy()
        if resp == Gtk.ResponseType.OK and nome:
            s = config_manager.load_settings()
            clusters = s.get("saved_clusters", {})
            clusters[nome] = {"sessions": selected}
            s["saved_clusters"] = clusters
            config_manager.save_settings(s)
            self._saved_clusters = clusters
            self._warn_info(t("cluster.saved_ok", name=nome))

    def _warn_info(self, msg: str):
        dlg = Gtk.MessageDialog(
            transient_for=self, modal=True,
            message_type=Gtk.MessageType.INFO,
            buttons=Gtk.ButtonsType.OK, text=msg)
        dlg.run(); dlg.destroy()

    def run(self):
        self.show_all()
        return super().run()


class _DialogApriFileTransfer(Gtk.Dialog):
    """Dialog che pre-compila host/credenziali da una sessione SSH e chiede il protocollo FT."""

    _PORT_DEFAULT = {"SFTP": "22", "FTP": "21", "FTPS": "21"}

    def __init__(self, parent, dati_ssh: dict):
        super().__init__(
            title=t("dlg_ft.title"),
            transient_for=parent,
            modal=True,
            destroy_with_parent=True,
        )
        self.set_default_size(420, 0)
        self._dati_ssh = dati_ssh
        self._init_ui()
        self.show_all()
        self._on_proto_changed(self._combo_proto)

    def _init_ui(self):
        area = self.get_content_area()
        area.set_spacing(6)
        area.set_margin_start(16)
        area.set_margin_end(16)
        area.set_margin_top(12)
        area.set_margin_bottom(8)

        grid = Gtk.Grid(row_spacing=6, column_spacing=8)
        area.pack_start(grid, False, False, 0)

        def _row(row, label_key, widget):
            lbl = Gtk.Label(label=t(label_key))
            lbl.set_xalign(1.0)
            grid.attach(lbl, 0, row, 1, 1)
            grid.attach(widget, 1, row, 1, 1)
            widget.set_hexpand(True)

        # Protocollo
        self._combo_proto = Gtk.ComboBoxText()
        for p in ("SFTP", "FTP", "FTPS"):
            self._combo_proto.append_text(p)
        self._combo_proto.set_active(0)
        self._combo_proto.connect("changed", self._on_proto_changed)
        _row(0, "dlg_ft.protocol", self._combo_proto)

        # Host
        self._entry_host = Gtk.Entry()
        self._entry_host.set_text(self._dati_ssh.get("host", ""))
        _row(1, "dlg_ft.host", self._entry_host)

        # Porta
        self._entry_port = Gtk.Entry()
        self._entry_port.set_text(self._dati_ssh.get("port", "22") or "22")
        _row(2, "dlg_ft.port", self._entry_port)

        # Utente
        self._entry_user = Gtk.Entry()
        self._entry_user.set_text(self._dati_ssh.get("user", ""))
        _row(3, "dlg_ft.user", self._entry_user)

        # Password
        self._entry_pwd = Gtk.Entry()
        self._entry_pwd.set_visibility(False)
        self._entry_pwd.set_text(self._dati_ssh.get("password", ""))
        _row(4, "dlg_ft.password", self._entry_pwd)

        # Chiave privata (solo SFTP)
        self._pkey_box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=4)
        self._entry_pkey = Gtk.Entry()
        self._entry_pkey.set_text(self._dati_ssh.get("private_key", ""))
        self._entry_pkey.set_hexpand(True)
        btn_pkey = Gtk.Button(label=t("dlg_ft.pkey_browse"))
        btn_pkey.connect("clicked", self._on_browse_pkey)
        self._pkey_box.pack_start(self._entry_pkey, True, True, 0)
        self._pkey_box.pack_start(btn_pkey, False, False, 0)
        self._lbl_pkey = Gtk.Label(label=t("dlg_ft.pkey"))
        self._lbl_pkey.set_xalign(1.0)
        grid.attach(self._lbl_pkey, 0, 5, 1, 1)
        grid.attach(self._pkey_box, 1, 5, 1, 1)
        self._pkey_box.set_hexpand(True)

        self.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        ok = self.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        ok.get_style_context().add_class("suggested-action")
        self.set_default_response(Gtk.ResponseType.OK)
        self._entry_host.connect("activate", lambda _: self.response(Gtk.ResponseType.OK))

    def _on_proto_changed(self, combo):
        proto = combo.get_active_text() or "SFTP"
        is_sftp = proto == "SFTP"
        self._lbl_pkey.set_visible(is_sftp)
        self._pkey_box.set_visible(is_sftp)
        # Aggiorna porta solo se invariata rispetto ai default
        current_port = self._entry_port.get_text().strip()
        for p, default in self._PORT_DEFAULT.items():
            if current_port == default:
                self._entry_port.set_text(self._PORT_DEFAULT[proto])
                break

    def _on_browse_pkey(self, _btn):
        dlg = Gtk.FileChooserDialog(
            title=t("dlg_ft.pkey"),
            transient_for=self,
            action=Gtk.FileChooserAction.OPEN,
        )
        dlg.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        dlg.add_button(t("sd.ok"), Gtk.ResponseType.OK)
        if dlg.run() == Gtk.ResponseType.OK:
            self._entry_pkey.set_text(dlg.get_filename() or "")
        dlg.destroy()

    def get_dati(self) -> dict:
        proto = self._combo_proto.get_active_text() or "SFTP"
        return {
            "protocol":    "file_transfer",
            "ft_protocol": proto,
            "host":        self._entry_host.get_text().strip(),
            "port":        self._entry_port.get_text().strip(),
            "user":        self._entry_user.get_text().strip(),
            "password":    self._entry_pwd.get_text(),
            "private_key": self._entry_pkey.get_text().strip() if proto == "SFTP" else "",
            "ftp_tls":     proto == "FTPS",
            "ftp_passive": True,
        }


# ---------------------------------------------------------------------------
# Dialog sblocco password master (cifratura credenziali)
# ---------------------------------------------------------------------------

class _CryptoUnlockDialog(Gtk.Dialog):
    """Dialog modale per inserire la password master al primo avvio con crypto."""

    def __init__(self, parent=None):
        super().__init__(
            title=t("crypto.unlock.title"),
            transient_for=parent,
            modal=True,
            destroy_with_parent=True
        )
        self.set_default_size(360, 0)
        self._pwd = ""
        self._init_ui()
        self.show_all()

    def _init_ui(self):
        area = self.get_content_area()
        area.set_spacing(10)
        area.set_margin_start(16)
        area.set_margin_end(16)
        area.set_margin_top(16)
        area.set_margin_bottom(8)

        lbl = Gtk.Label()
        lbl.set_markup(f"<b>🔒 {t('crypto.unlock.title')}</b>\n"
                       f"<small>{t('crypto.unlock.prompt')}</small>")
        lbl.set_xalign(0.0)
        lbl.set_line_wrap(True)
        area.pack_start(lbl, False, False, 0)

        self._entry = Gtk.Entry()
        self._entry.set_visibility(False)
        self._entry.set_placeholder_text(t("crypto.password_label"))
        self._entry.connect("activate", lambda e: self.response(Gtk.ResponseType.OK))
        area.pack_start(self._entry, False, False, 0)

        self.add_button(t("sd.cancel"), Gtk.ResponseType.CANCEL)
        ok = self.add_button(t("crypto.unlock.btn_ok"), Gtk.ResponseType.OK)
        ok.get_style_context().add_class("suggested-action")

    def get_password(self) -> str:
        return self._entry.get_text()

class PCMApp(Gtk.Application):

    def __init__(self):
        super().__init__(
            application_id="it.pcm.connectionmanager",
            flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE,
        )
        self.connect("activate", self._on_activate)
        self.connect("command-line", self._on_command_line)

    def _on_activate(self, app):
        apply_css()
        win = MainWindow(app)
        win.show_all()

    def _on_command_line(self, app, cmdline):
        args = cmdline.get_arguments()   # args[0] = nome programma
        uri = args[1] if len(args) > 1 else None

        # Porta la finestra principale in primo piano (o la crea)
        wins = self.get_windows()
        if not wins:
            self.activate()
            wins = self.get_windows()

        if wins:
            wins[0].present()
            if uri:
                GLib.idle_add(wins[0].apri_da_cli, uri)

        return 0


def main():
    _tr.init_from_settings()
    app = PCMApp()
    sys.exit(app.run(sys.argv))


if __name__ == "__main__":
    main()