PasswordImportDialog.cpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * 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, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#include "PasswordImportDialog.hpp"
#include "PasswordImporter.hpp"
#include <glibmm/i18n.h>
#include <fstream>
#include <sstream>
 
 
PasswordImportDialog::PasswordImportDialog(Gtk::Window& parent)
: parent_(parent),
  mainBox_(Gtk::Orientation::VERTICAL, 10),
  hintLabel_(_("Seleziona un file CSV esportato da Chrome, Edge, Firefox o Safari.")),
  chooseFileBtn_(_("📂  Scegli file CSV…")),
  progressBox_(Gtk::Orientation::VERTICAL, 4),
  importBtn_(_("⬆  Importa credenziali"))
{
    dialog_ = new Gtk::Dialog(_("Importa credenziali da browser"), parent, true);
    dialog_->set_default_size(720, 560);
 
    dispProgress_.connect(sigc::mem_fun(*this, &PasswordImportDialog::onProgressTick));
    dispDone_.connect(sigc::mem_fun(*this, &PasswordImportDialog::onImportDone));
 
    buildUi();
}
 
PasswordImportDialog::~PasswordImportDialog() {
    if (importThread_.joinable()) importThread_.join();
    delete dialog_;
}
 
void PasswordImportDialog::present() { dialog_->present(); }
void PasswordImportDialog::hide()    { dialog_->hide(); }
 
void PasswordImportDialog::buildUi() {
    auto* content = dialog_->get_content_area();
    content->set_spacing(0);
    content->set_margin(0);
 
    mainBox_.set_margin(16);
    mainBox_.set_spacing(10);
 
    hintLabel_.set_xalign(0.0f);
    hintLabel_.set_wrap(true);
    mainBox_.append(hintLabel_);
 
    auto* fileRow = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
    fileLabel_.set_xalign(0.0f);
    fileLabel_.set_hexpand(true);
    fileLabel_.set_ellipsize(Pango::EllipsizeMode::MIDDLE);
    fileRow->append(chooseFileBtn_);
    fileRow->append(fileLabel_);
    mainBox_.append(*fileRow);
 
    auto* infoRow = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 16);
    formatLabel_.set_xalign(0.0f);
    countLabel_.set_xalign(0.0f);
    infoRow->append(formatLabel_);
    infoRow->append(countLabel_);
    mainBox_.append(*infoRow);
 
    mainBox_.append(*Gtk::make_managed<Gtk::Separator>(Gtk::Orientation::HORIZONTAL));
 
    auto* previewLabel = Gtk::make_managed<Gtk::Label>(
        _("Anteprima (prime 50 righe — tutte verranno importate):"));
    previewLabel->set_xalign(0.0f);
    previewLabel->get_style_context()->add_class("heading");
    mainBox_.append(*previewLabel);
 
    previewList_.set_selection_mode(Gtk::SelectionMode::NONE);
    previewScrolled_.set_child(previewList_);
    previewScrolled_.set_vexpand(true);
    previewScrolled_.set_min_content_height(240);
    mainBox_.append(previewScrolled_);
    progressLabel_.set_xalign(0.0f);
    progressBar_.set_show_text(false);
    progressBar_.set_fraction(0.0);
    progressBox_.append(progressLabel_);
    progressBox_.append(progressBar_);
    progressBox_.set_visible(false);
    mainBox_.append(progressBox_);
 
    content->append(mainBox_);
 
    dialog_->add_button(_("Chiudi"), Gtk::ResponseType::CANCEL);
 
    importBtn_.set_sensitive(false);
    styleImportButton();
    content->append(importBtn_);
 
    chooseFileBtn_.signal_clicked().connect(
        sigc::mem_fun(*this, &PasswordImportDialog::onChooseFile));
    importBtn_.signal_clicked().connect(
        sigc::mem_fun(*this, &PasswordImportDialog::onImportClicked));
 
    dialog_->signal_response().connect([this](int r) {
        if ((r == Gtk::ResponseType::CANCEL || r == Gtk::ResponseType::DELETE_EVENT)
            && !importing_)
            dialog_->hide();
    });
}
 
void PasswordImportDialog::styleImportButton() {
    importBtn_.get_style_context()->add_class("suggested-action");
    auto provider = Gtk::CssProvider::create();
    provider->load_from_data(
        "button.suggested-action {"
        "  background: linear-gradient(to bottom, #33d17a, #26a269);"
        "  color: white; font-weight: bold;"
        "  padding: 8px 24px; border-radius: 6px;"
        "  border: 1px solid #1e8449;"
        "}");
    importBtn_.get_style_context()->add_provider(
        provider, GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
 
 
void PasswordImportDialog::onChooseFile() {
    auto* fc = new Gtk::FileChooserDialog(
        _("Seleziona file CSV"), Gtk::FileChooser::Action::OPEN);
    fc->set_transient_for(*dialog_);
    fc->set_modal(true);
 
    auto filter = Gtk::FileFilter::create();
    filter->set_name(_("File CSV (*.csv)"));
    filter->add_pattern("*.csv");
    filter->add_pattern("*.CSV");
    fc->add_filter(filter);
 
    auto filterAll = Gtk::FileFilter::create();
    filterAll->set_name(_("Tutti i file"));
    filterAll->add_pattern("*");
    fc->add_filter(filterAll);
 
    fc->add_button(_("Annulla"), Gtk::ResponseType::CANCEL);
    fc->add_button(_("Apri"),    Gtk::ResponseType::OK);
 
    fc->signal_response().connect([this, fc](int r) {
        if (r == Gtk::ResponseType::OK) {
            const auto file = fc->get_file();
            if (file) loadFile(file->get_path());
        }
        fc->hide();
        delete fc;
    });
    fc->present();
}
 
 
void PasswordImportDialog::loadFile(const std::string& path) {
    std::string errorMsg;
    parsed_ = PasswordImporter::importFromFile(path, errorMsg);
 
    const auto slash = path.rfind('/');
    fileLabel_.set_text(slash != std::string::npos ? path.substr(slash + 1) : path);
 
    if (!errorMsg.empty() || parsed_.empty()) {
        const std::string msg = errorMsg.empty() ? "Nessuna credenziale trovata." : errorMsg;
        formatLabel_.set_markup(
            std::string("<span foreground='red'>⚠ ") +
            Glib::Markup::escape_text(msg) + "</span>");
        countLabel_.set_text("");
        importBtn_.set_sensitive(false);
        while (auto* child = previewList_.get_first_child())
            previewList_.remove(*child);
        return;
    }
 
    std::ifstream probe(path);
    std::string firstLine;
    std::getline(probe, firstLine);
    if (!firstLine.empty() && firstLine.back() == '\r') firstLine.pop_back();
 
    const auto fmt = PasswordImporter::detectFormat(firstLine);
    std::string fmtName;
    switch (fmt) {
        case BrowserFormat::Chrome:  fmtName = "Chrome";  break;
        case BrowserFormat::Edge:    fmtName = "Edge";    break;
        case BrowserFormat::Firefox: fmtName = "Firefox"; break;
        case BrowserFormat::Safari:  fmtName = "Safari";  break;
        default:                     fmtName = "?";       break;
    }
 
    formatLabel_.set_markup(
        std::string("<b>") + std::string(_("Browser: ")) + "</b>" + fmtName);
    countLabel_.set_markup(
        std::string("<b>") + std::string(_("Credenziali trovate: ")) + "</b>" +
        std::to_string(parsed_.size()));
 
    importBtn_.set_sensitive(true);
    populatePreview();
}
 
 
void PasswordImportDialog::populatePreview() {
    while (auto* child = previewList_.get_first_child())
        previewList_.remove(*child);
 
    // Header
    {
        auto* row = Gtk::make_managed<Gtk::ListBoxRow>();
        auto* box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
        box->set_margin(6);
        auto makeHdr = [](const std::string& t, int chars) {
            auto* l = Gtk::make_managed<Gtk::Label>();
            l->set_markup("<b>" + Glib::Markup::escape_text(t) + "</b>");
            l->set_xalign(0.0f);
            l->set_width_chars(chars);
            l->set_max_width_chars(chars);
            l->set_ellipsize(Pango::EllipsizeMode::END);
            return l;
        };
        box->append(*makeHdr(_("Nome / Sito"), 26));
        box->append(*makeHdr(_("Username"),    22));
        box->append(*makeHdr(_("URL"),         28));
        row->set_child(*box);
        row->set_activatable(false);
        previewList_.append(*row);
    }
 
    const size_t limit = std::min(parsed_.size(), size_t(50));
    for (size_t i = 0; i < limit; ++i) {
        const auto& c = parsed_[i];
        auto* row = Gtk::make_managed<Gtk::ListBoxRow>();
        auto* box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 0);
        box->set_margin_top(3); box->set_margin_bottom(3);
        box->set_margin_start(6); box->set_margin_end(6);
        auto makeCell = [](const std::string& t, int chars) {
            auto* l = Gtk::make_managed<Gtk::Label>(t);
            l->set_xalign(0.0f);
            l->set_width_chars(chars);
            l->set_max_width_chars(chars);
            l->set_ellipsize(Pango::EllipsizeMode::END);
            return l;
        };
        const std::string name = c.name.empty()
            ? PasswordImporter::domainFromUrl(c.url) : c.name;
        box->append(*makeCell(name,       26));
        box->append(*makeCell(c.username, 22));
        box->append(*makeCell(c.url,      28));
        row->set_child(*box);
        row->set_activatable(false);
        previewList_.append(*row);
    }
 
    if (parsed_.size() > limit) {
        auto* row = Gtk::make_managed<Gtk::ListBoxRow>();
        auto* lbl = Gtk::make_managed<Gtk::Label>(
            std::string("… ") + std::to_string(parsed_.size() - limit) +
            std::string(_(" altre (tutte verranno importate)")));
        lbl->set_margin(6);
        lbl->get_style_context()->add_class("dim-label");
        row->set_child(*lbl);
        row->set_activatable(false);
        previewList_.append(*row);
    }
}
 
 
void PasswordImportDialog::onImportClicked() {
    if (parsed_.empty() || importing_) return;
 
    importing_     = true;
    progressDone_  = 0;
    progressTotal_ = static_cast<int>(parsed_.size());
 
    progressBar_.set_fraction(0.0);
    progressLabel_.set_text(
        std::string(_("Preparazione: ")) +
        std::to_string(progressTotal_) +
        std::string(_(" credenziali…")));
    progressBox_.set_visible(true);
    importBtn_.set_sensitive(false);
    chooseFileBtn_.set_sensitive(false);
    dialog_->set_response_sensitive(Gtk::ResponseType::CANCEL, false);
    auto creds = parsed_;
 
    importThread_ = std::thread([this, creds]() mutable {
        pendingItems_.clear();
        pendingItems_.reserve(creds.size());
 
        for (auto& c : creds) {
            PasswordEntry e = PasswordImporter::toPasswordEntry(c);
            pendingItems_.emplace_back(std::move(e), std::move(c.password));
            ++progressDone_;
            dispProgress_.emit();
        }
 
        dispDone_.emit();
    });
}
 
void PasswordImportDialog::onProgressTick() {
    const int done  = progressDone_.load();
    const int total = progressTotal_.load();
    if (total > 0) {
        progressBar_.set_fraction(static_cast<double>(done) / total);
        progressLabel_.set_text(
            std::string(_("Preparazione: ")) + std::to_string(done) +
            " / " + std::to_string(total));
    }
}
 
void PasswordImportDialog::onImportDone() {
    if (importThread_.joinable()) importThread_.join();
 
    progressBar_.set_fraction(1.0);
    progressLabel_.set_text(_("Salvataggio nel vault…"));
    importing_ = false;
    signalImportConfirmed_.emit(std::move(pendingItems_));
}
 
sigc::signal<void(std::vector<PasswordImportDialog::BulkItem>)>
PasswordImportDialog::signal_import_confirmed() {
    return signalImportConfirmed_;
}