main_window.cpp

Go to the documentation of this file.

#include "main_window.hpp"
#include "i18n.hpp"
 
#include <gtk/gtk.h>
#include <algorithm>
#include <map>
#include <unordered_set>
#include <iomanip>
#include <fstream>
#include <filesystem>
#include <iostream>
#include <sstream>
#include <unistd.h>
#include <pangomm.h>
#include <glibmm/ustring.h>
 
#include "Resource.hpp"
#include "privilege_utils.hpp"
 
namespace {
    std::string format_elapsed(std::chrono::steady_clock::duration elapsed) {
        const auto total_seconds = std::chrono::duration_cast<std::chrono::seconds>(elapsed).count();
        const auto hours = total_seconds / 3600;
        const auto minutes = (total_seconds % 3600) / 60;
        const auto seconds = total_seconds % 60;
 
        std::ostringstream oss;
        oss << std::setfill('0');
        if (hours > 0) oss << std::setw(2) << hours << ':';
        oss << std::setw(2) << minutes << ':' << std::setw(2) << seconds;
        return oss.str();
    }
 
    void set_button_with_svg_icon(Gtk::Button& button,
                                  const std::string& svg_path,
                                  const Glib::ustring& text) {
        auto* box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 10);
        box->set_halign(Gtk::Align::START);
 
        bool icon_loaded = false;
        try {
            auto texture = Gdk::Texture::create_from_filename(svg_path);
            auto* image = Gtk::make_managed<Gtk::Image>();
            image->set(texture);
            image->set_pixel_size(20);
            image->set_halign(Gtk::Align::START);
            box->append(*image);
            icon_loaded = true;
        } catch (const Glib::Error&) {
        } catch (...) {
        }
 
        if (!icon_loaded) {
            auto* fallback = Gtk::make_managed<Gtk::Label>("•");
            fallback->set_halign(Gtk::Align::START);
            fallback->add_css_class("small-label");
            box->append(*fallback);
        }
 
        auto* label = Gtk::make_managed<Gtk::Label>(text);
        label->set_halign(Gtk::Align::START);
        label->set_hexpand(true);
        label->set_xalign(0.0f);
        box->append(*label);
 
        button.set_child(*box);
                                  }
 
    std::string read_text_file(const std::string& path) {
        std::ifstream input(path, std::ios::binary);
        if (!input.is_open()) return {};
 
        std::ostringstream content;
        content << input.rdbuf();
        return content.str();
    }
 
    std::string load_license_text() {
        std::string text = read_text_file(resource("LICENSE.txt"));
        if (text.empty()) text = read_text_file("data/LICENSE.txt");
        if (text.empty()) text = read_text_file("../data/LICENSE.txt");
        if (text.empty()) text = read_text_file("LICENSE");
        if (text.empty()) text = read_text_file("../LICENSE");
 
        if (text.empty()) {
            text =
                "BastionGuard™ Recovery Data\n"
                "\n"
                "Copyright (C) 2025–2026 Calogero Scarnà.\n"
                "\n"
                "This program is free software: you can redistribute it and/or modify "
                "it under the terms of the GNU General Public License as published by "
                "the Free Software Foundation, either version 3 of the License, or "
                "(at your option) any later version.\n"
                "\n"
                "See the LICENSE file for the complete GNU GPLv3 text.\n"
                "BastionGuard™ is a trademark of Calogero Scarnà.\n";
        }
 
        return text;
    }
 
} // namespace
 
MainWindow::MainWindow()
: brand_label_("BastionGuard™"),
btn_dashboard_(tr("Dashboard")),
btn_recovery_(tr("Recovery wizard")),
btn_about_(tr("About")),
btn_refresh_(tr("Refresh devices")),
btn_theme_dark_("🌙"),
btn_theme_light_("☀"),
recovery_title_(tr("Recovery wizard")),
recovery_subtitle_(tr("Choose a source, set a destination, scan read-only, then export recovered data.")),
btn_wizard_back_(tr("Back")),
btn_wizard_next_(tr("Next")),
source_step_label_(tr("Select a physical disk or image file. Physical disks require read access; use the pkexec button when needed.")),
btn_open_image_(tr("Open image")),
btn_use_selected_device_(tr("Use selected disk")),
btn_launch_elevated_(tr("Relaunch with pkexec")),
destination_step_label_(tr("Choose a destination folder on a different disk or mount point than the source.")),
btn_choose_destination_(tr("Choose destination")),
scan_step_label_(tr("Run a read-only scan before exporting recovered data.")),
btn_scan_now_(tr("Start scan")),
recover_step_label_(tr("Export detected volumes, filesystem-level recoveries, and carved files.")),
btn_results_select_all_(tr("Select all")),
btn_results_clear_(tr("Clear selection")),
btn_recover_now_(tr("Start recovery")) {
    set_title("");
    set_resizable(true);
    set_default_size(800, 600);
    set_size_request(1100, 700);
 
    build_headerbar();
    build_sidebar();
    build_dashboard();
    build_recovery_page();
    build_about_page();
 
    page_stack_.add(dashboard_page_, "dashboard", tr("Dashboard"));
    page_stack_.add(recovery_page_, "recovery", tr("Recovery wizard"));
    page_stack_.add(about_page_, "about", tr("About"));
    page_stack_.set_visible_child(dashboard_page_);
    page_stack_.set_hexpand(true);
    page_stack_.set_vexpand(true);
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
    page_stack_.set_transition_duration(220);
    page_stack_.add_css_class("content");
 
    main_box_.append(sidebar_);
    main_box_.append(page_stack_);
    set_child(main_box_);
 
    log_buffer_ = Gtk::TextBuffer::create();
    log_view_.set_buffer(log_buffer_);
    log_view_.set_editable(false);
    log_view_.set_monospace(true);
 
    recovery_devices_list_.set_selection_mode(Gtk::SelectionMode::SINGLE);
    devices_list_.set_selection_mode(Gtk::SelectionMode::SINGLE);
 
    {
        const std::string saved_theme = read_theme();
        current_theme_ = (saved_theme == "light") ? ThemeMode::Light : ThemeMode::Dark;
    }
    apply_theme(current_theme_);
 
    refresh_devices();
    activate_sidebar_button(dashboard_button_);
    update_source_state();
    update_wizard_step();
 
    btn_dashboard_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_sidebar_dashboard));
    btn_recovery_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_sidebar_recovery));
    btn_about_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_sidebar_about));
    btn_refresh_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_refresh_devices));
    btn_theme_dark_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_theme_dark));
    btn_theme_light_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_theme_light));
    btn_open_image_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_open_image));
    btn_choose_destination_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_choose_destination));
    btn_use_selected_device_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_use_selected_device));
    btn_launch_elevated_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_launch_elevated));
    btn_wizard_back_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_wizard_back));
    btn_wizard_next_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_wizard_next));
    btn_scan_now_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_scan_now));
    btn_recover_now_.signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::on_recover_now));
    btn_results_select_all_.signal_clicked().connect([this]() { set_all_results_selected(true); });
    btn_results_clear_.signal_clicked().connect([this]() { set_all_results_selected(false); });
 
    devices_list_.signal_row_activated().connect(sigc::mem_fun(*this, &MainWindow::on_dashboard_device_activated));
    recovery_devices_list_.signal_row_activated().connect(sigc::mem_fun(*this, &MainWindow::on_recovery_device_activated));
}
 
MainWindow::~MainWindow() = default;
 
void MainWindow::build_headerbar() {
    auto* header = Gtk::make_managed<Gtk::HeaderBar>();
    header->set_show_title_buttons(false);
    header->set_decoration_layout("");
    header->add_css_class("custom-headerbar");
 
    auto* header_left = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    header_left->set_hexpand(false);
    header_left->add_css_class("header-left");
    header->pack_start(*header_left);
 
    auto* spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer->set_hexpand(true);
    header->pack_start(*spacer);
 
    auto* header_right = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
    header_right->add_css_class("header-right");
 
    try {
        auto pix_min = Gdk::Pixbuf::create_from_file(resource("icon-minimize.png"), 24, 24, true);
        auto* btn_min = Gtk::make_managed<Gtk::Button>();
        btn_min->set_child(*Gtk::make_managed<Gtk::Image>(pix_min));
        btn_min->add_css_class("header-button");
        btn_min->set_tooltip_text(tr("Minimize"));
        btn_min->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::minimize_window));
        header_right->append(*btn_min);
    } catch (const Glib::Error& ex) {
        std::cerr << "Errore caricamento icon-minimize.png: " << ex.what() << std::endl;
 
        auto* btn_min_fallback = Gtk::make_managed<Gtk::Button>("—");
        btn_min_fallback->add_css_class("header-button");
        btn_min_fallback->set_tooltip_text(tr("Minimize"));
        btn_min_fallback->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::minimize_window));
        header_right->append(*btn_min_fallback);
    }
 
    try {
        auto pix_close = Gdk::Pixbuf::create_from_file(resource("icon-close.png"), 24, 24, true);
        auto* btn_close = Gtk::make_managed<Gtk::Button>();
        btn_close->set_child(*Gtk::make_managed<Gtk::Image>(pix_close));
        btn_close->add_css_class("header-button");
        btn_close->set_tooltip_text(tr("Close"));
        btn_close->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::hide_window));
        header_right->append(*btn_close);
    } catch (const Glib::Error& ex) {
        std::cerr << "Errore caricamento icon-close.png: " << ex.what() << std::endl;
 
        auto* btn_close_fallback = Gtk::make_managed<Gtk::Button>("✕");
        btn_close_fallback->add_css_class("header-button");
        btn_close_fallback->set_tooltip_text(tr("Close"));
        btn_close_fallback->signal_clicked().connect(sigc::mem_fun(*this, &MainWindow::hide_window));
        header_right->append(*btn_close_fallback);
    }
 
    header->pack_end(*header_right);
    set_titlebar(*header);
}
 
void MainWindow::build_sidebar() {
    sidebar_.set_size_request(240, -1);
    sidebar_.add_css_class("sidebar");
 
    auto* hdr = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 8);
    hdr->add_css_class("sidebar-header");
 
    auto* logo_img = Gtk::make_managed<Gtk::Image>();
    try {
        auto texture = Gdk::Texture::create_from_filename(resource("logo-sidebar.png"));
        logo_img->set(texture);
        logo_img->set_pixel_size(48);
    } catch (...) {}
    logo_img->set_halign(Gtk::Align::START);
    logo_img->set_margin_bottom(4);
    hdr->append(*logo_img);
 
    brand_label_.set_text(tr("BastionGuard™\nRecovery Data"));
    brand_label_.set_halign(Gtk::Align::START);
    brand_label_.add_css_class("sidebar-title");
    hdr->append(brand_label_);
 
    sidebar_.append(*hdr);
 
    btn_dashboard_.add_css_class("sidebar-button");
    btn_recovery_.add_css_class("sidebar-button");
    btn_about_.add_css_class("sidebar-button");
    btn_refresh_.add_css_class("sidebar-button");
 
    btn_dashboard_.set_halign(Gtk::Align::FILL);
    btn_recovery_.set_halign(Gtk::Align::FILL);
    btn_about_.set_halign(Gtk::Align::FILL);
    btn_refresh_.set_halign(Gtk::Align::FILL);
 
    set_button_with_svg_icon(btn_dashboard_, resource("icons/icon-dashboard.svg"), tr("Dashboard"));
    set_button_with_svg_icon(btn_recovery_, resource("icons/icon-recovery.svg"), tr("Recovery wizard"));
    set_button_with_svg_icon(btn_refresh_, resource("icons/icon-refresh.svg"), tr("Refresh devices"));
    set_button_with_svg_icon(btn_about_, resource("icons/icon-about.svg"), tr("About"));
 
    dashboard_button_ = &btn_dashboard_;
    recovery_button_ = &btn_recovery_;
    about_button_ = &btn_about_;
 
    sidebar_buttons_.push_back(&btn_dashboard_);
    sidebar_buttons_.push_back(&btn_recovery_);
    sidebar_buttons_.push_back(&btn_about_);
 
    sidebar_.append(btn_dashboard_);
    sidebar_.append(btn_recovery_);
    sidebar_.append(btn_refresh_);
 
    auto* sep1 = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
    sep1->add_css_class("sidebar-separator");
    sidebar_.append(*sep1);
 
    auto* theme_title = Gtk::make_managed<Gtk::Label>(tr("Theme"));
    theme_title->set_halign(Gtk::Align::START);
    theme_title->add_css_class("sidebar-group-label");
    sidebar_.append(*theme_title);
 
    auto* theme_row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 10);
    theme_row->add_css_class("sidebar-theme-row");
    theme_row->set_halign(Gtk::Align::FILL);
    theme_row->set_hexpand(true);
 
    btn_theme_dark_.add_css_class("theme-btn");
    btn_theme_light_.add_css_class("theme-btn");
 
    btn_theme_dark_.set_hexpand(true);
    btn_theme_light_.set_hexpand(true);
    btn_theme_dark_.set_halign(Gtk::Align::FILL);
    btn_theme_light_.set_halign(Gtk::Align::FILL);
 
    theme_row->append(btn_theme_dark_);
    theme_row->append(btn_theme_light_);
    sidebar_.append(*theme_row);
 
    auto* sep2 = Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL);
    sep2->add_css_class("sidebar-separator");
    sidebar_.append(*sep2);
 
    auto* lang_title = Gtk::make_managed<Gtk::Label>(tr("Language"));
    lang_title->set_halign(Gtk::Align::START);
    lang_title->add_css_class("sidebar-group-label");
    sidebar_.append(*lang_title);
 
    lang_combo_.add_css_class("sidebar-lang-combo");
    lang_combo_.set_hexpand(true);
    lang_combo_.set_halign(Gtk::Align::FILL);
    auto lang_model = Gtk::StringList::create({
        "English",
        "Italiano",
        "Deutsch",
        "Español",
        "Français",
        "日本語",
        "Nederlands",
        "Polski",
        "Português",
        "Русский",
        "العربية"
    });
    lang_combo_.set_model(lang_model);
 
    {
        const std::string saved = read_language();
 
        if      (saved == "it") lang_combo_.set_selected(1);
        else if (saved == "de") lang_combo_.set_selected(2);
        else if (saved == "es") lang_combo_.set_selected(3);
        else if (saved == "fr") lang_combo_.set_selected(4);
        else if (saved == "ja") lang_combo_.set_selected(5);
        else if (saved == "nl") lang_combo_.set_selected(6);
        else if (saved == "pl") lang_combo_.set_selected(7);
        else if (saved == "pt") lang_combo_.set_selected(8);
        else if (saved == "ru") lang_combo_.set_selected(9);
        else if (saved == "ar") lang_combo_.set_selected(10);
        else                    lang_combo_.set_selected(0);
    }
 
    lang_combo_.property_selected().signal_changed().connect(
        sigc::mem_fun(*this, &MainWindow::on_language_changed));
 
    sidebar_.append(lang_combo_);
 
    auto* spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL);
    spacer->set_vexpand(true);
    sidebar_.append(*spacer);
 
    sidebar_.append(btn_about_);
 
    auto* info = Gtk::make_managed<Gtk::Label>(tr("Read-only forensic mode"));
    info->set_halign(Gtk::Align::START);
    info->add_css_class("small-label");
    sidebar_.append(*info);
}
 
void MainWindow::build_dashboard() {
    dashboard_page_.set_hexpand(true);
    dashboard_page_.set_vexpand(true);
    dashboard_page_.set_margin_top(24);
    dashboard_page_.set_margin_bottom(24);
    dashboard_page_.set_margin_start(24);
    dashboard_page_.set_margin_end(24);
 
    cards_grid_.set_column_spacing(16);
    cards_grid_.set_row_spacing(16);
 
    card_status_.set_child(status_card_label_);
    card_source_.set_child(source_card_label_);
    card_update_.set_child(update_card_label_);
 
    card_status_.add_css_class("card");
    card_source_.add_css_class("card");
    card_update_.add_css_class("card");
 
    status_card_label_.set_text(tr("Core engine: Ready\nRead-only mode: Active"));
    source_card_label_.set_text(tr("No source selected"));
    update_card_label_.set_text(tr("Device inventory available"));
 
    status_card_label_.set_wrap(true);
    source_card_label_.set_wrap(true);
    update_card_label_.set_wrap(true);
 
    status_card_label_.set_margin_top(20);
    status_card_label_.set_margin_bottom(20);
    status_card_label_.set_margin_start(20);
    status_card_label_.set_margin_end(20);
 
    source_card_label_.set_margin_top(20);
    source_card_label_.set_margin_bottom(20);
    source_card_label_.set_margin_start(20);
    source_card_label_.set_margin_end(20);
 
    update_card_label_.set_margin_top(20);
    update_card_label_.set_margin_bottom(20);
    update_card_label_.set_margin_start(20);
    update_card_label_.set_margin_end(20);
 
    cards_grid_.attach(card_status_, 0, 0, 1, 1);
    cards_grid_.attach(card_source_, 1, 0, 1, 1);
    cards_grid_.attach(card_update_, 2, 0, 1, 1);
 
    devices_frame_.set_label(tr("Available disks"));
    devices_frame_.add_css_class("card");
 
    devices_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    devices_scroller_.set_vexpand(true);
    devices_scroller_.set_child(devices_list_);
 
    devices_list_.add_css_class("scan-file-list");
 
    devices_frame_.set_child(devices_scroller_);
 
    dashboard_page_.append(cards_grid_);
    dashboard_page_.append(devices_frame_);
}
 
void MainWindow::build_wizard() {
    wizard_frame_.add_css_class("card");
    wizard_root_.set_margin_top(14);
    wizard_root_.set_margin_bottom(14);
    wizard_root_.set_margin_start(14);
    wizard_root_.set_margin_end(14);
 
    source_step_label_.set_wrap(true);
    source_step_label_.set_xalign(0.0f);
    source_button_row_.append(btn_open_image_);
    source_button_row_.append(btn_use_selected_device_);
    source_button_row_.append(btn_launch_elevated_);
    recovery_devices_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    recovery_devices_scroller_.set_vexpand(true);
    recovery_devices_scroller_.set_child(recovery_devices_list_);
    source_step_box_.append(source_step_label_);
    source_step_box_.append(source_button_row_);
    source_step_box_.append(recovery_devices_scroller_);
 
    destination_step_label_.set_wrap(true);
    destination_step_label_.set_xalign(0.0f);
    entry_output_.set_hexpand(true);
    entry_output_.set_editable(false);
    destination_button_row_.append(entry_output_);
    destination_button_row_.append(btn_choose_destination_);
    destination_step_box_.append(destination_step_label_);
    destination_step_box_.append(destination_button_row_);
 
    wizard_notice_label_.set_wrap(true);
    wizard_notice_label_.set_xalign(0.0f);
    wizard_notice_label_.add_css_class("alert-danger");
    wizard_notice_label_.set_text(tr("Avviso: non si garantisce il recupero totale dei file. La quantità e l'integrità dei dati recuperati dipendono da danni al filesystem, sovrascritture, frammentazione, cifratura, compressione e stato del dispositivo."));
 
    scan_step_label_.set_wrap(true);
    scan_step_label_.set_xalign(0.0f);
    scan_progress_bar_.set_show_text(true);
    scan_progress_bar_.set_fraction(0.0);
    scan_progress_bar_.set_hexpand(true);
    scan_status_label_.set_xalign(0.0f);
    scan_status_label_.add_css_class("small-label");
    scan_timer_label_.set_xalign(0.0f);
    scan_timer_label_.add_css_class("small-label");
    scan_timer_label_.set_text(tr("Elapsed: 00:00"));
    scan_step_box_.append(scan_step_label_);
    scan_step_box_.append(scan_progress_bar_);
    scan_step_box_.append(scan_status_label_);
    scan_step_box_.append(scan_timer_label_);
    scan_step_box_.append(btn_scan_now_);
 
    recover_step_label_.set_wrap(true);
    recover_step_label_.set_xalign(0.0f);
 
    results_count_label_.set_halign(Gtk::Align::START);
    results_count_label_.set_xalign(0.0f);
    results_count_label_.add_css_class("small-label");
    results_count_label_.set_margin_bottom(2);
 
    results_selected_label_.set_halign(Gtk::Align::START);
    results_selected_label_.set_xalign(0.0f);
    results_selected_label_.add_css_class("small-label");
    results_selected_label_.set_margin_bottom(6);
 
    btn_results_select_all_.add_css_class("sidebar-button");
    btn_results_clear_.add_css_class("sidebar-button");
    results_actions_row_.append(btn_results_select_all_);
    results_actions_row_.append(btn_results_clear_);
 
    results_tree_box_.add_css_class("scan-file-list");
 
    results_scroller_.set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    results_scroller_.set_vexpand(true);
    results_scroller_.set_child(results_tree_box_);
 
    results_frame_.set_label(tr("Detected items"));
    results_frame_.add_css_class("card");
    results_frame_.set_vexpand(true);
 
    auto* results_inner = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    results_inner->set_margin_top(10);
    results_inner->set_margin_bottom(10);
    results_inner->set_margin_start(10);
    results_inner->set_margin_end(10);
    results_inner->append(results_count_label_);
    results_inner->append(results_selected_label_);
    results_inner->append(results_actions_row_);
    results_inner->append(results_scroller_);
    results_frame_.set_child(*results_inner);
 
    btn_recover_now_.add_css_class("btn-primary");
    btn_recover_now_.set_halign(Gtk::Align::END);
 
    recover_step_box_.append(recover_step_label_);
    recover_step_box_.append(results_frame_);
    recover_step_box_.append(btn_recover_now_);
 
    wizard_stack_.add(source_step_box_, "wizard-source", tr("Source"));
    wizard_stack_.add(destination_step_box_, "wizard-destination", tr("Destination"));
    wizard_stack_.add(scan_step_box_, "wizard-scan", tr("Scan"));
    wizard_stack_.add(recover_step_box_, "wizard-recover", tr("Recover"));
    wizard_stack_.set_visible_child(source_step_box_);
    wizard_stack_.set_hexpand(true);
    wizard_stack_.set_vexpand(true);
 
    btn_wizard_back_.add_css_class("sidebar-button");
    btn_wizard_next_.add_css_class("btn-primary");
    wizard_nav_.append(btn_wizard_back_);
    auto* spacer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL);
    spacer->set_hexpand(true);
    wizard_nav_.append(*spacer);
    wizard_nav_.append(btn_wizard_next_);
 
    wizard_root_.append(wizard_notice_label_);
    wizard_root_.append(wizard_stack_);
    wizard_root_.append(wizard_nav_);
    wizard_frame_.set_child(wizard_root_);
}
 
void MainWindow::build_recovery_page() {
    recovery_page_.set_hexpand(true);
    recovery_page_.set_vexpand(true);
    recovery_page_.set_margin_top(24);
    recovery_page_.set_margin_bottom(24);
    recovery_page_.set_margin_start(24);
    recovery_page_.set_margin_end(24);
 
    recovery_title_.add_css_class("page-title");
    recovery_subtitle_.add_css_class("small-label");
    recovery_subtitle_.set_wrap(true);
    recovery_subtitle_.set_xalign(0.0f);
    recovery_header_.append(recovery_title_);
    recovery_header_.append(recovery_subtitle_);
 
    build_wizard();
 
    log_scroller_.set_vexpand(true);
    log_scroller_.add_css_class("BastionGuard-scroller");
    log_scroller_.set_child(log_view_);
 
    recovery_page_.append(recovery_header_);
    recovery_page_.append(wizard_frame_);
    recovery_page_.append(log_scroller_);
}
 
void MainWindow::apply_theme(ThemeMode mode) {
    current_theme_ = mode;
 
    const std::string css_path =
    (mode == ThemeMode::Dark)
    ? resource("BastionGuard-dark.css")
    : resource("BastionGuard.css");
 
    if (!css_provider_) {
        css_provider_ = Gtk::CssProvider::create();
    }
 
    try {
        css_provider_->load_from_path(css_path);
    } catch (const Glib::Error& ex) {
        std::cerr << "Errore caricando CSS '" << css_path << "': " << ex.what() << std::endl;
        return;
    }
 
    auto display = Gdk::Display::get_default();
    if (display) {
        gtk_style_context_add_provider_for_display(
            display->gobj(),
                                                   GTK_STYLE_PROVIDER(css_provider_->gobj()),
                                                   GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
        );
    }
 
    update_theme_buttons();
}
 
void MainWindow::update_theme_buttons() {
    btn_theme_dark_.remove_css_class("theme-btn-active");
    btn_theme_light_.remove_css_class("theme-btn-active");
 
    if (current_theme_ == ThemeMode::Dark)
        btn_theme_dark_.add_css_class("theme-btn-active");
    else
        btn_theme_light_.add_css_class("theme-btn-active");
}
 
void MainWindow::activate_sidebar_button(Gtk::Button* button) {
    for (auto* b : sidebar_buttons_) b->remove_css_class("active-sidebar-button");
    if (button) button->add_css_class("active-sidebar-button");
}
 
void MainWindow::refresh_devices() {
    devices_ = DeviceEnumerator::enumerate_linux_block_devices();
    populate_device_lists();
 
    std::ostringstream ss;
    ss << trs("Detected devices: ") << devices_.size();
    update_card_label_.set_text(ss.str());
}
 
void MainWindow::populate_device_lists() {
    while (auto* child = devices_list_.get_first_child()) devices_list_.remove(*child);
    while (auto* child = recovery_devices_list_.get_first_child()) recovery_devices_list_.remove(*child);
 
    int selected_index = -1;
 
    for (size_t i = 0; i < devices_.size(); ++i) {
        const auto& d = devices_[i];
 
        auto make_row = [&](bool include_path_first) -> Gtk::ListBoxRow* {
            auto* row_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 4);
            row_box->set_margin_top(10);
            row_box->set_margin_bottom(10);
            row_box->set_margin_start(12);
            row_box->set_margin_end(12);
 
            std::ostringstream title;
            if (include_path_first)
                title << d.path << "  •  " << human_size(d.size_bytes);
            else
                title << d.name << "  •  " << human_size(d.size_bytes);
 
            std::ostringstream subtitle;
            subtitle << (d.model.empty() ? tr("Disk") : d.model) << "  •  "
            << (d.transport.empty() ? tr("Block") : d.transport);
 
            if (d.removable) subtitle << trs("  •  removable");
            if (!PrivilegeUtils::can_read_source(d.path) && !PrivilegeUtils::is_running_as_root())
                subtitle << trs("  •  needs elevation");
 
            auto* lbl1 = Gtk::make_managed<Gtk::Label>(title.str());
            auto* lbl2 = Gtk::make_managed<Gtk::Label>(subtitle.str());
            lbl1->set_halign(Gtk::Align::START);
            lbl2->set_halign(Gtk::Align::START);
            lbl1->set_xalign(0.0f);
            lbl2->set_xalign(0.0f);
            lbl1->add_css_class("subtitle");
            lbl2->add_css_class("small-label");
            row_box->append(*lbl1);
            row_box->append(*lbl2);
 
            auto* row = Gtk::make_managed<Gtk::ListBoxRow>();
            row->set_child(*row_box);
            return row;
        };
 
        devices_list_.append(*make_row(true));
        recovery_devices_list_.append(*make_row(true));
 
        if (!selected_source_path_.empty() && d.path == selected_source_path_) {
            selected_index = static_cast<int>(i);
        }
    }
 
    devices_list_.unselect_all();
    recovery_devices_list_.unselect_all();
 
    if (selected_index >= 0) {
        if (auto* row = devices_list_.get_row_at_index(selected_index))
            devices_list_.select_row(*row);
        if (auto* row = recovery_devices_list_.get_row_at_index(selected_index))
            recovery_devices_list_.select_row(*row);
    }
}
 
void MainWindow::select_source(const std::string& path, const std::string& label) {
    selected_source_path_ = path;
    selected_source_label_ = label;
    last_report_ = {};
 
    int selected_index = -1;
    for (size_t i = 0; i < devices_.size(); ++i) {
        if (devices_[i].path == path) {
            selected_index = static_cast<int>(i);
            break;
        }
    }
 
    devices_list_.unselect_all();
    recovery_devices_list_.unselect_all();
 
    if (selected_index >= 0) {
        if (auto* dashboard_row = devices_list_.get_row_at_index(selected_index))
            devices_list_.select_row(*dashboard_row);
 
        if (auto* wizard_row = recovery_devices_list_.get_row_at_index(selected_index))
            recovery_devices_list_.select_row(*wizard_row);
    }
 
    update_source_state();
    append_log(trs("Selected source: ") + label);
}
 
void MainWindow::update_source_state() {
    if (selected_source_path_.empty()) {
        source_card_label_.set_text(tr("No source selected"));
        scan_step_label_.set_text(tr("Run a read-only scan before exporting recovered data. Non si garantisce il recupero totale dei file."));
        recover_step_label_.set_text(tr("Export detected volumes, filesystem-level recoveries, and carved files. Non si garantisce il recupero totale dei file."));
        update_action_controls();
        return;
    }
 
    std::ostringstream ss;
    ss << trs("Source selected:\n") << selected_source_label_ << "\nPath: " << selected_source_path_;
 
    if (!PrivilegeUtils::can_read_source(selected_source_path_) && !PrivilegeUtils::is_running_as_root())
        ss << trs("\nAccess: needs elevation");
    else
        ss << trs("\nAccess: ready");
 
    source_card_label_.set_text(ss.str());
 
    std::ostringstream scan_msg;
    scan_msg << trs("Current source:\n") << selected_source_label_
    << trs("\n\nRun a read-only scan before continuing.");
    scan_step_label_.set_text(scan_msg.str());
 
    std::ostringstream rec_msg;
    rec_msg << trs("Destination: ")
            << (output_dir_.empty() ? std::string(trs("not selected")) : output_dir_)
            << trs("\nSource: ") << selected_source_label_
            << trs("\n\nBrowse the recovery tree, keep all items selected or choose only the branches you want, then click \"Start recovery\".");
    recover_step_label_.set_text(rec_msg.str());
    update_action_controls();
}
 
void MainWindow::update_wizard_step() {
    btn_wizard_back_.set_sensitive(current_step_ != WizardStep::Source);
 
    switch (current_step_) {
        case WizardStep::Source:
            wizard_stack_.set_visible_child(source_step_box_);
            btn_wizard_next_.set_sensitive(!selected_source_path_.empty());
            break;
        case WizardStep::Destination:
            wizard_stack_.set_visible_child(destination_step_box_);
            btn_wizard_next_.set_sensitive(!output_dir_.empty());
            break;
        case WizardStep::Scan:
            wizard_stack_.set_visible_child(scan_step_box_);
            btn_wizard_next_.set_sensitive(!last_report_.results.empty());
            break;
        case WizardStep::Recover:
            wizard_stack_.set_visible_child(recover_step_box_);
            btn_wizard_next_.set_sensitive(false);
            break;
    }
}
 
void MainWindow::append_log(const std::string& line) {
    if (!log_buffer_) return;
    auto iter = log_buffer_->end();
    log_buffer_->insert(iter, line + "\n");
}
 
void MainWindow::on_sidebar_dashboard() {
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_RIGHT);
    page_stack_.set_visible_child(dashboard_page_);
    activate_sidebar_button(dashboard_button_);
}
 
void MainWindow::on_sidebar_recovery() {
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
    page_stack_.set_visible_child(recovery_page_);
    activate_sidebar_button(recovery_button_);
}
 
void MainWindow::on_refresh_devices() {
    refresh_devices();
    append_log(trs("Device list refreshed."));
}
 
void MainWindow::on_open_image() {
    file_dialog_ = Gtk::FileDialog::create();
    file_dialog_->set_title(tr("Select image file"));
 
    file_dialog_->open(*this, [this](const Glib::RefPtr<Gio::AsyncResult>& result) {
        try {
            if (!file_dialog_) return;
            auto file = file_dialog_->open_finish(result);
            if (!file) return;
 
            const auto path = file->get_path();
            select_source(path, path);
            on_sidebar_recovery();
            file_dialog_.reset();
        } catch (const Glib::Error&) {
            file_dialog_.reset();
        }
 
        update_wizard_step();
    });
}
 
void MainWindow::on_choose_destination() {
    folder_dialog_ = Gtk::FileDialog::create();
    folder_dialog_->set_title(tr("Select destination folder"));
 
    folder_dialog_->select_folder(*this, [this](const Glib::RefPtr<Gio::AsyncResult>& result) {
        try {
            if (!folder_dialog_) return;
            auto folder = folder_dialog_->select_folder_finish(result);
            if (!folder) return;
 
            output_dir_ = folder->get_path();
            entry_output_.set_text(output_dir_);
            append_log(trs("Recovery destination: ") + output_dir_);
            update_source_state();
            update_wizard_step();
            folder_dialog_.reset();
        } catch (const Glib::Error&) {
            folder_dialog_.reset();
        }
    });
}
 
void MainWindow::on_use_selected_device() {
    auto* row = recovery_devices_list_.get_selected_row();
    if (!row) {
        append_log(trs("No device selected."));
        return;
    }
 
    const int idx = row->get_index();
    if (idx < 0 || static_cast<size_t>(idx) >= devices_.size()) return;
 
    const auto& d = devices_[static_cast<size_t>(idx)];
    select_source(d.path, d.path + " • " + human_size(d.size_bytes));
    update_wizard_step();
}
 
void MainWindow::on_dashboard_device_activated(Gtk::ListBoxRow* row) {
    if (!row) return;
 
    const int idx = row->get_index();
    if (idx < 0 || static_cast<size_t>(idx) >= devices_.size()) return;
 
    const auto& d = devices_[static_cast<size_t>(idx)];
    select_source(d.path, d.path + " • " + human_size(d.size_bytes));
    current_step_ = WizardStep::Source;
    update_wizard_step();
    on_sidebar_recovery();
}
 
void MainWindow::on_recovery_device_activated(Gtk::ListBoxRow* row) {
    if (!row) return;
    recovery_devices_list_.select_row(*row);
    on_use_selected_device();
}
 
void MainWindow::on_theme_dark() {
    current_theme_ = ThemeMode::Dark;
    save_theme("dark");
    apply_theme(current_theme_);
}
 
void MainWindow::on_theme_light() {
    current_theme_ = ThemeMode::Light;
    save_theme("light");
    apply_theme(current_theme_);
}
 
void MainWindow::on_wizard_back() {
    switch (current_step_) {
        case WizardStep::Source: break;
        case WizardStep::Destination: current_step_ = WizardStep::Source; break;
        case WizardStep::Scan: current_step_ = WizardStep::Destination; break;
        case WizardStep::Recover: current_step_ = WizardStep::Scan; break;
    }
    update_wizard_step();
}
 
void MainWindow::on_wizard_next() {
    switch (current_step_) {
        case WizardStep::Source:
            if (!selected_source_path_.empty()) current_step_ = WizardStep::Destination;
            break;
        case WizardStep::Destination:
            if (!output_dir_.empty()) current_step_ = WizardStep::Scan;
            break;
        case WizardStep::Scan:
            if (!last_report_.results.empty())
                current_step_ = WizardStep::Recover;
            break;
        case WizardStep::Recover:
            break;
    }
    update_wizard_step();
}
 
void MainWindow::on_scan_now() {
    if (selected_source_path_.empty()) {
        append_log(trs("No source selected."));
        return;
    }
 
    if (scan_worker_.running()) {
        append_log(trs("A scan is already running."));
        return;
    }
 
    if (!PrivilegeUtils::can_read_source(selected_source_path_) && !PrivilegeUtils::is_running_as_root()) {
        append_log(trs("Source access denied. Relaunch with pkexec or adjust permissions."));
        return;
    }
 
    append_log(trs("Starting read-only scan on: ") + selected_source_path_);
    btn_scan_now_.set_sensitive(false);
    last_scan_progress_ = {};
    scan_started_at_ = std::chrono::steady_clock::now();
    scan_progress_bar_.set_fraction(0.0);
    scan_progress_bar_.set_text("0%");
    scan_status_label_.set_text(tr("Preparing scan..."));
    scan_timer_label_.set_text(tr("Elapsed: ") + std::string("00:00"));
 
    if (scan_timer_connection_.connected()) scan_timer_connection_.disconnect();
 
    scan_timer_connection_ = Glib::signal_timeout().connect([this]() {
        scan_timer_label_.set_text(
            tr("Elapsed: ") + format_elapsed(std::chrono::steady_clock::now() - scan_started_at_));
        return scan_worker_.running();
    }, 250);
 
    scan_worker_.start(
        selected_source_path_,
        [this](const ScanReport& report) {
            Glib::signal_idle().connect_once([this, report]() { on_scan_completed(report); });
        },
        [this](const ScanProgress& progress) {
            Glib::signal_idle().connect_once([this, progress]() { on_scan_progress(progress); });
        }
    );
}
 
void MainWindow::on_recover_now() {
    if (last_report_.results.empty()) {
        append_log(trs("No scan report available."));
        return;
    }
 
    if (output_dir_.empty()) {
        append_log(trs("No output directory selected."));
        return;
    }
 
    if (recovery_worker_.running()) {
        append_log(trs("A recovery task is already running."));
        return;
    }
 
    const auto selected = selected_result_indices();
    if (selected.empty()) {
        append_log(trs("No recoverable items selected."));
        return;
    }
 
    append_log(trs("Starting recovery to: ") + output_dir_);
    append_log(trs("Selected items for recovery: ") + std::to_string(selected.size()));
    btn_recover_now_.set_sensitive(false);
 
    recovery_worker_.start(last_report_, output_dir_, selected, [this](const RecoveryResult& result) {
        Glib::signal_idle().connect_once([this, result]() { on_recovery_completed(result); });
    });
}
 
void MainWindow::on_launch_elevated() {
    std::string error;
 
    if (PrivilegeUtils::is_running_as_root()) {
        append_log(trs("Already running with elevated privileges."));
        return;
    }
 
    if (!PrivilegeUtils::launch_pkexec_relaunch(error)) {
        append_log(trs("Failed to launch pkexec: ") + error);
        return;
    }
 
    append_log(trs("Requested pkexec relaunch."));
}
 
void MainWindow::on_scan_progress(const ScanProgress& progress) {
    last_scan_progress_ = progress;
 
    double fraction = progress.fraction;
    if (fraction < 0.0) fraction = 0.0;
    if (fraction > 1.0) fraction = 1.0;
 
    scan_progress_bar_.set_fraction(fraction);
 
    std::ostringstream pct;
    pct << static_cast<int>(fraction * 100.0) << '%';
    scan_progress_bar_.set_text(pct.str());
 
    std::string status = progress.stage;
    if (!progress.detail.empty()) {
        if (!status.empty()) status += " • ";
        status += progress.detail;
    }
 
    scan_status_label_.set_text(status.empty() ? tr("Scanning...") : status);
}
 
void MainWindow::on_scan_completed(const ScanReport& report) {
    if (scan_timer_connection_.connected())
        scan_timer_connection_.disconnect();
 
    scan_progress_bar_.set_fraction(1.0);
    scan_progress_bar_.set_text("100%");
    scan_status_label_.set_text(trs("Completed • Scan finished"));
 
    scan_timer_label_.set_text(
        tr("Elapsed: ") + format_elapsed(std::chrono::steady_clock::now() - scan_started_at_)
    );
 
    last_report_ = report;
 
    for (const auto& line : report.logs)
        append_log(line);
 
    std::ostringstream ss;
    ss << trs("Scan completed. Results: ") << report.results.size();
    append_log(ss.str());
 
    populate_scan_results(report);
 
    btn_scan_now_.set_label(trs("Repeat scan"));
    update_action_controls();
 
    if (!report.results.empty())
        current_step_ = WizardStep::Recover;
 
    update_wizard_step();
}
 
std::string MainWindow::result_group_label(const ScanResult& result) {
    if (result.type.find("NTFS") != std::string::npos) return "NTFS";
    if (result.type.find("ext4") != std::string::npos || result.type.find("EXT4") != std::string::npos) return "ext4";
    if (result.type.find("Btrfs") != std::string::npos || result.type.find("BTRFS") != std::string::npos) return "Btrfs";
    if (result.type.find("exFAT") != std::string::npos) return "exFAT";
    if (result.type.find("FAT32") != std::string::npos) return "FAT32";
    if (result.kind == ResultKind::Partition || result.kind == ResultKind::LostPartitionCandidate) return "Partitions";
    return "Other detected items";
}
 
std::string MainWindow::result_subgroup_label(const ScanResult& result) {
    switch (result.kind) {
        case ResultKind::Partition: return "Partitions";
        case ResultKind::LostPartitionCandidate: return "Lost partitions";
        case ResultKind::FilesystemCandidate: return "Filesystem candidates";
        case ResultKind::FilesystemVolume:
        case ResultKind::NtfsVolume: return "Volumes";
        case ResultKind::NtfsMetadata: return "Metadata";
        default: break;
    }
    if (result.type.find("$MFT") != std::string::npos) return "Metadata";
    return "Items";
}
 
void MainWindow::populate_scan_results(const ScanReport& report) {
    while (auto* child = results_tree_box_.get_first_child())
        results_tree_box_.remove(*child);
 
    result_selection_.assign(report.results.size(), false);
    result_check_buttons_.assign(report.results.size(), nullptr);
 
    std::map<std::string, std::vector<size_t>> subgroups;
    size_t count = 0;
 
    for (size_t report_index = 0; report_index < report.results.size(); ++report_index) {
        const auto& r = report.results[report_index];
        if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error)
            continue;
        ++count;
        result_selection_[report_index] = true;
        subgroups[result_subgroup_label(r)].push_back(report_index);
    }
 
    const std::string scan_root_name = !selected_source_label_.empty()
        ? selected_source_label_
        : (!report.input_path.empty() ? report.input_path : std::string(trs("Scanned source")));
 
    auto* root_expander = Gtk::make_managed<Gtk::Expander>();
    root_expander->set_label(scan_root_name + " (" + std::to_string(count) + ")");
    root_expander->set_expanded(true);
 
    auto* root_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
    root_box->set_margin_top(6);
    root_box->set_margin_bottom(6);
    root_box->set_margin_start(6);
    root_box->set_margin_end(6);
 
    if (count == 0) {
        auto* empty = Gtk::make_managed<Gtk::Label>(trs("No recoverable items found in this scan result."));
        empty->set_halign(Gtk::Align::START);
        empty->set_xalign(0.0f);
        empty->add_css_class("small-label");
        root_box->append(*empty);
    }
 
    for (const auto& subgroup_entry : subgroups) {
        const auto& subgroup_name = subgroup_entry.first;
        const auto& indices = subgroup_entry.second;
 
        auto* sub_expander = Gtk::make_managed<Gtk::Expander>();
        sub_expander->set_label(subgroup_name + " (" + std::to_string(indices.size()) + ")");
        sub_expander->set_expanded(true);
 
        auto* subgroup_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 4);
        subgroup_box->set_margin_top(4);
        subgroup_box->set_margin_bottom(4);
        subgroup_box->set_margin_start(8);
        subgroup_box->set_margin_end(4);
 
        for (size_t report_index : indices) {
            const auto& r = report.results[report_index];
 
            auto* row_layout = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 10);
            row_layout->set_margin_top(6);
            row_layout->set_margin_bottom(6);
            row_layout->set_margin_start(10);
            row_layout->set_margin_end(10);
 
            auto* check = Gtk::make_managed<Gtk::CheckButton>();
            check->set_active(true);
            check->set_valign(Gtk::Align::START);
            check->signal_toggled().connect([this, report_index, check]() {
                if (report_index < result_selection_.size()) {
                    result_selection_[report_index] = check->get_active();
                    update_selected_results_state();
                }
            });
            if (report_index < result_check_buttons_.size()) result_check_buttons_[report_index] = check;
            row_layout->append(*check);
 
            auto* row_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 3);
            row_box->set_hexpand(true);
 
            std::ostringstream title;
            title << r.type;
            if (r.size_bytes > 0)
                title << "  •  " << human_size(r.size_bytes);
 
            std::ostringstream sub;
            sub << trs("Offset: ") << r.offset_bytes
                << " (0x" << std::hex << std::uppercase << r.offset_bytes << std::dec << ")";
            if (r.confidence > 0.0) {
                std::ostringstream conf;
                conf << std::fixed << std::setprecision(0) << (r.confidence * 100.0) << "%";
                sub << trs("  •  Confidence: ") << conf.str();
            }
            if (!r.source.empty())
                sub << "  •  " << r.source;
 
            auto* lbl_title = Gtk::make_managed<Gtk::Label>(title.str());
            lbl_title->set_halign(Gtk::Align::START);
            lbl_title->set_xalign(0.0f);
            lbl_title->add_css_class("subtitle");
 
            auto* lbl_sub = Gtk::make_managed<Gtk::Label>(sub.str());
            lbl_sub->set_halign(Gtk::Align::START);
            lbl_sub->set_xalign(0.0f);
            lbl_sub->add_css_class("small-label");
            lbl_sub->set_ellipsize(Pango::EllipsizeMode::END);
 
            row_box->append(*lbl_title);
            row_box->append(*lbl_sub);
 
            if (!r.detail.empty()) {
                auto* lbl_detail = Gtk::make_managed<Gtk::Label>(r.detail);
                lbl_detail->set_halign(Gtk::Align::START);
                lbl_detail->set_xalign(0.0f);
                lbl_detail->add_css_class("small-label");
                lbl_detail->set_wrap(true);
                lbl_detail->set_wrap_mode(Pango::WrapMode::WORD_CHAR);
                row_box->append(*lbl_detail);
            }
 
            row_layout->append(*row_box);
            subgroup_box->append(*row_layout);
        }
 
        sub_expander->set_child(*subgroup_box);
        root_box->append(*sub_expander);
    }
 
    root_expander->set_child(*root_box);
    results_tree_box_.append(*root_expander);
 
    std::ostringstream cnt;
    if (count == 0) {
        cnt << trs("No recoverable items found.");
    } else if (count == 1) {
        cnt << count << trs(" recoverable item detected in this scan.");
    } else {
        cnt << count << trs(" recoverable items detected in this scan.");
    }
    results_count_label_.set_text(cnt.str());
 
    std::ostringstream rec_msg;
    rec_msg << trs("Destination: ")
    << (output_dir_.empty() ? std::string(trs("not selected")) : output_dir_)
    << "\n"
    << trs("Scan result: ") << scan_root_name
    << "\n"
    << trs("This tree belongs to the current scan result. Select all items or only the entries you want to recover, then click \"Start recovery\".");
 
    recover_step_label_.set_text(rec_msg.str());
    update_selected_results_state();
}
 
void MainWindow::update_selected_results_state() {
    const auto selected = selected_result_indices().size();
    size_t total = 0;
    for (const auto& r : last_report_.results) {
        if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error) continue;
        ++total;
    }
    std::ostringstream ss;
    ss << trs("Selected items: ") << selected;
    if (total > 0) ss << " / " << total;
    results_selected_label_.set_text(ss.str());
    btn_recover_now_.set_sensitive(!selected_source_path_.empty() && !output_dir_.empty() && !last_report_.results.empty() && selected > 0 && !recovery_worker_.running());
}
 
std::vector<size_t> MainWindow::selected_result_indices() const {
    std::vector<size_t> out;
    for (size_t i = 0; i < result_selection_.size(); ++i) {
        if (result_selection_[i]) {
            const auto& r = last_report_.results[i];
            if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error) continue;
            out.push_back(i);
        }
    }
    return out;
}
 
void MainWindow::set_all_results_selected(bool selected) {
    for (size_t i = 0; i < last_report_.results.size(); ++i) {
        const auto& r = last_report_.results[i];
        if (r.kind == ResultKind::Info || r.kind == ResultKind::Warning || r.kind == ResultKind::Error) continue;
        if (i < result_selection_.size()) result_selection_[i] = selected;
        if (i < result_check_buttons_.size() && result_check_buttons_[i]) {
            result_check_buttons_[i]->set_active(selected);
        }
    }
    update_selected_results_state();
}
 
void MainWindow::on_recovery_completed(const RecoveryResult& result) {
    for (const auto& line : result.logs) append_log(line);
 
    if (result.ok) {
        append_log(trs("Recovery completed."));
        append_log(trs("Exported images: ") + std::to_string(result.summary.exported_images.size()));
        append_log(trs("Recovered files: ") + std::to_string(result.summary.recovered_files.size()));
    } else {
        append_log(trs("Recovery failed: ") + result.error);
    }
 
    update_selected_results_state();
}
 
void MainWindow::minimize_window() {
    #if GTKMM_CHECK_VERSION(4,10,0)
    minimize();
    #else
    set_visible(false);
    #endif
}
 
void MainWindow::hide_window() {
    set_visible(false);
}
 
void MainWindow::build_about_page() {
    about_page_.set_hexpand(true);
    about_page_.set_vexpand(true);
    about_page_.set_margin_top(32);
    about_page_.set_margin_bottom(32);
    about_page_.set_margin_start(48);
    about_page_.set_margin_end(48);
    about_page_.set_halign(Gtk::Align::CENTER);
    about_page_.set_valign(Gtk::Align::CENTER);
 
    try {
        auto* logo_img = Gtk::make_managed<Gtk::Image>();
        try {
            auto texture = Gdk::Texture::create_from_filename(resource("logo.svg"));
            logo_img->set(texture);
            logo_img->set_pixel_size(192);
        } catch (...) {}
        logo_img->set_margin_bottom(12);
        about_page_.append(*logo_img);
    } catch (...) {}
 
    auto* name_label = Gtk::make_managed<Gtk::Label>(tr("BastionGuard™ Recovery Data"));
    name_label->add_css_class("page-title");
    name_label->set_margin_bottom(4);
    about_page_.append(*name_label);
 
    std::string version_str = "unknown";
    {
        const std::string version_path = resource("version.bs");
        std::ifstream vf(version_path);
        if (vf.is_open()) {
            std::getline(vf, version_str);
            version_str.erase(version_str.find_last_not_of(" \t\r\n") + 1);
            version_str.erase(0, version_str.find_first_not_of(" \t\r\n"));
        }
    }
 
    auto* version_label = Gtk::make_managed<Gtk::Label>(trs("Version ") + version_str);
    version_label->add_css_class("small-label");
    version_label->set_margin_bottom(18);
    about_page_.append(*version_label);
 
    auto* about_notebook = Gtk::make_managed<Gtk::Notebook>();
    about_notebook->set_hexpand(true);
    about_notebook->set_vexpand(true);
    about_notebook->set_halign(Gtk::Align::FILL);
    about_notebook->set_valign(Gtk::Align::FILL);
    about_notebook->set_size_request(680, 360);
 
    auto* overview_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 18);
    overview_box->set_margin_top(24);
    overview_box->set_margin_bottom(24);
    overview_box->set_margin_start(24);
    overview_box->set_margin_end(24);
 
    auto* desc_label = Gtk::make_managed<Gtk::Label>(
        tr("A read-only forensic recovery tool supporting ext4, btrfs, NTFS, FAT32,exFAT, XFS and HFS+.\nScan physical disks or image files without writing a single byte to the source."));
    desc_label->set_wrap(true);
    desc_label->set_justify(Gtk::Justification::CENTER);
    overview_box->append(*desc_label);
 
    auto* fs_label = Gtk::make_managed<Gtk::Label>(
        tr("Supported filesystems:  ext4  •  Btrfs  •  NTFS  •  FAT32  •  exFAT  •  XFS  •  HFS+"));
    fs_label->add_css_class("subtitle");
    fs_label->set_wrap(true);
    fs_label->set_justify(Gtk::Justification::CENTER);
    overview_box->append(*fs_label);
 
    auto* license_summary = Gtk::make_managed<Gtk::Label>(
        tr("Released under GNU GPLv3 or later. BastionGuard™ is a trademark of Calogero Scarnà."));
    license_summary->add_css_class("small-label");
    license_summary->set_justify(Gtk::Justification::CENTER);
    license_summary->set_wrap(true);
    overview_box->append(*license_summary);
 
    auto* overview_tab = Gtk::make_managed<Gtk::Label>(tr("Overview"));
    about_notebook->append_page(*overview_box, *overview_tab);
 
    auto* license_scroller = Gtk::make_managed<Gtk::ScrolledWindow>();
    license_scroller->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
    license_scroller->set_min_content_width(640);
    license_scroller->set_min_content_height(300);
 
    auto* license_text = Gtk::make_managed<Gtk::TextView>();
    license_text->set_editable(false);
    license_text->set_cursor_visible(false);
    license_text->set_wrap_mode(Gtk::WrapMode::WORD);
    license_text->set_left_margin(14);
    license_text->set_right_margin(14);
    license_text->set_top_margin(14);
    license_text->set_bottom_margin(14);
 
    auto license_buffer = Gtk::TextBuffer::create();
    license_buffer->set_text(load_license_text());
    license_text->set_buffer(license_buffer);
    license_scroller->set_child(*license_text);
 
    auto* license_tab = Gtk::make_managed<Gtk::Label>(tr("License"));
    about_notebook->append_page(*license_scroller, *license_tab);
 
    about_page_.append(*about_notebook);
}
 
void MainWindow::update_action_controls() {
    btn_scan_now_.set_sensitive(!scan_worker_.running() && !selected_source_path_.empty());
    btn_results_select_all_.set_sensitive(!last_report_.results.empty());
    btn_results_clear_.set_sensitive(!last_report_.results.empty());
    update_selected_results_state();
}
 
void MainWindow::on_sidebar_about() {
    page_stack_.set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT);
    page_stack_.set_visible_child(about_page_);
    activate_sidebar_button(about_button_);
}
 
std::string MainWindow::read_language() {
    const std::string path =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data/lang.conf";
 
    std::ifstream f(path);
    if (!f.is_open()) return "en";
 
    std::string val;
    f >> val;
 
    static const std::unordered_set<std::string> supported = {
        "en", "it", "de", "es", "fr", "ja", "nl", "pl", "pt", "ru", "ar"
    };
 
    return supported.count(val) ? val : "en";
}
 
void MainWindow::save_language(const std::string& lang_code) {
    const std::string dir =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data";
 
    std::filesystem::create_directories(dir);
    std::ofstream f(dir + "/lang.conf");
    if (f.is_open()) f << lang_code << "\n";
}
 
std::string MainWindow::read_theme() {
    const std::string path =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data/theme.conf";
 
    std::ifstream f(path);
    if (!f.is_open()) return "dark";
 
    std::string val;
    f >> val;
 
    if (val == "dark" || val == "light")
        return val;
 
    return "dark";
}
 
void MainWindow::save_theme(const std::string& theme_code) {
    const std::string dir =
    Glib::get_home_dir() + "/.config/bastionguard-recovery-data";
 
    std::filesystem::create_directories(dir);
    std::ofstream f(dir + "/theme.conf");
    if (f.is_open()) f << theme_code << "\n";
}
 
void MainWindow::on_language_changed() {
    if (lang_changing_) return;
 
    const std::string current = read_language();
    const guint idx = lang_combo_.get_selected();
 
    std::string new_lang = "en";
    switch (idx) {
        case 1:  new_lang = "it"; break;
        case 2:  new_lang = "de"; break;
        case 3:  new_lang = "es"; break;
        case 4:  new_lang = "fr"; break;
        case 5:  new_lang = "ja"; break;
        case 6:  new_lang = "nl"; break;
        case 7:  new_lang = "pl"; break;
        case 8:  new_lang = "pt"; break;
        case 9:  new_lang = "ru"; break;
        case 10: new_lang = "ar"; break;
        default: new_lang = "en"; break;
    }
 
    if (new_lang == current) return;
 
    save_language(new_lang);
 
    auto alert = Gtk::AlertDialog::create(tr("Restart required"));
    alert->set_detail(
        tr("The language will change after restarting the application.\nRestart now?"));
    alert->set_buttons({tr("Cancel"), tr("Restart")});
    alert->set_default_button(1);
    alert->set_cancel_button(0);
 
    alert->choose(*this, [this, alert, current](Glib::RefPtr<Gio::AsyncResult>& result) {
        int btn = -1;
        try {
            btn = alert->choose_finish(result);
        } catch (...) {}
 
        if (btn == 1) {
            char self_path[4096] = {};
            ssize_t len = readlink("/proc/self/exe", self_path, sizeof(self_path) - 1);
            if (len > 0) {
                self_path[len] = '\0';
    char* argv[] = {self_path, nullptr};
    execv(self_path, argv);
            }
            get_application()->quit();
        } else {
            lang_changing_ = true;
            save_language(current);
 
            if      (current == "it") lang_combo_.set_selected(1);
            else if (current == "de") lang_combo_.set_selected(2);
            else if (current == "es") lang_combo_.set_selected(3);
            else if (current == "fr") lang_combo_.set_selected(4);
            else if (current == "ja") lang_combo_.set_selected(5);
            else if (current == "nl") lang_combo_.set_selected(6);
            else if (current == "pl") lang_combo_.set_selected(7);
            else if (current == "pt") lang_combo_.set_selected(8);
            else if (current == "ru") lang_combo_.set_selected(9);
            else if (current == "ar") lang_combo_.set_selected(10);
            else                      lang_combo_.set_selected(0);
 
            lang_changing_ = false;
        }
    });
}
 
std::string MainWindow::human_size(uint64_t bytes) {
    const char* units[] = {"B", "KiB", "MiB", "GiB", "TiB"};
    double value = static_cast<double>(bytes);
    int unit_index = 0;
 
    while (value >= 1024.0 && unit_index < 4) {
        value /= 1024.0;
        ++unit_index;
    }
 
    std::ostringstream oss;
    oss << std::fixed << std::setprecision(2) << value << ' ' << units[unit_index];
    return oss.str();
}