main.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 "wizard_window.hpp"
#include "StyleProvider.hpp"
#include "resource.hpp"
#include <gtkmm.h>
#include <fstream>
#include <clocale>
#include <glib/gi18n.h>
#include <glib.h>
#include <filesystem>
#include <system_error>
#include <unistd.h>
#include <cerrno>
#include <cstring>
#include <iostream>
 
#ifndef LOCALEDIR
#error "LOCALEDIR non definita per questo target"
#endif
 
 
namespace fs = std::filesystem;
 
static bool bastionguard_mo_exists(const std::string& lang) {
    fs::path mo = fs::path(LOCALEDIR) / lang / "LC_MESSAGES" / "BastionGuard.mo";
    std::error_code ec;
    return fs::exists(mo, ec) && !ec;
}
 
static std::string pick_wizard_language_from_localedir() {
    const std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    std::ifstream f(lang_conf);
 
    auto normalize = [](std::string s) {
        auto ltrim = [](std::string& x){ x.erase(0, x.find_first_not_of(" \t\r\n")); };
        auto rtrim = [](std::string& x){ x.erase(x.find_last_not_of(" \t\r\n") + 1); };
        ltrim(s); rtrim(s);
        auto dot = s.find('.');
        if (dot != std::string::npos) s = s.substr(0, dot);
        auto at = s.find('@');
        if (at != std::string::npos) s = s.substr(0, at);
        return s;
    };
 
    if (f.is_open()) {
        std::string line;
        while (std::getline(f, line)) {
            if (line.empty() || line[0] == '#') continue;
            auto pos = line.find('=');
            if (pos == std::string::npos) continue;
 
            std::string key = line.substr(0, pos);
            std::string val = line.substr(pos + 1);
            key = normalize(key);
            val = normalize(val);
 
            if ((key == "LANGUAGE" || key == "LC_MESSAGES" || key == "LANG") && !val.empty()) {
                auto colon = val.find(':');
                std::string first = (colon == std::string::npos) ? val : val.substr(0, colon);
 
                if (bastionguard_mo_exists(first))
                    return first;
 
                // fallback: se "it_IT" non esiste, prova "it"
                auto us = first.find('_');
                if (us != std::string::npos) {
                    std::string base = first.substr(0, us);
                    if (bastionguard_mo_exists(base))
                        return base;
                }
            }
        }
    }
 
    if (bastionguard_mo_exists("en_US")) return "en_US";
    if (bastionguard_mo_exists("en"))    return "en";
    return "C";
}
 
 
static bool load_lang_conf()
{
    const std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    std::ifstream f(lang_conf);
    if (!f.is_open())
        return false;
 
    std::string line;
    bool any = false;
 
    while (std::getline(f, line)) {
        if (line.empty() || line[0] == '#')
            continue;
 
        auto pos = line.find('=');
        if (pos == std::string::npos)
            continue;
 
        std::string key = line.substr(0, pos);
        std::string val = line.substr(pos + 1);
 
        auto ltrim = [](std::string& s){
            s.erase(0, s.find_first_not_of(" \t\r\n"));
        };
        auto rtrim = [](std::string& s){
            s.erase(s.find_last_not_of(" \t\r\n") + 1);
        };
        ltrim(key); rtrim(key);
        ltrim(val); rtrim(val);
 
        if (!key.empty() && !val.empty()) {
            setenv(key.c_str(), val.c_str(), 1);
            any = true;
        }
    }
 
    return any;
}
 
int main(int argc, char* argv[]) {
 
    const std::string lang_conf = Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    {
        std::error_code ec;
        if (!fs::exists(lang_conf, ec) || ec) {
            std::string cfgdir = Glib::get_home_dir() + "/.config/BastionGuard";
            fs::create_directories(cfgdir, ec);
            std::ofstream out(lang_conf, std::ios::out | std::ios::trunc);
            if (out.is_open()) {
                out << "LANG=en_US.UTF-8\n";
                out << "LC_ALL=en_US.UTF-8\n";
                out << "LANGUAGE=en_US\n";
                out.close();
                std::cout << "[Lang] ✅ Creato lang.conf di default: " << lang_conf << std::endl;
            }
        }
    }
 
    std::ifstream f(lang_conf);
    if (f.is_open()) {
        std::string line;
        while (std::getline(f, line)) {
            auto pos = line.find('=');
            if (pos != std::string::npos) {
                std::string key = line.substr(0, pos);
                std::string val = line.substr(pos + 1);
                if (!key.empty() && !val.empty())
                    setenv(key.c_str(), val.c_str(), 1);
            }
        }
        f.close();
        std::cout << "[Lang] Config caricata da " << lang_conf << std::endl;
    } else {
        std::cerr << "[Lang] ⚠️ Impossibile aprire lang.conf, forzo inglese di default" << std::endl;
    }
 
    const char* lang_env = std::getenv("LANG");
    if (!lang_env || std::string(lang_env).empty())
        setenv("LANG", "en_US.UTF-8", 1);
 
    const char* lc_all_env = std::getenv("LC_ALL");
    if (!lc_all_env || std::string(lc_all_env).empty())
        setenv("LC_ALL", "en_US.UTF-8", 1);
 
    const char* language_env = std::getenv("LANGUAGE");
    if (!language_env || std::string(language_env).empty())
        setenv("LANGUAGE", "en_US", 1);
 
    const char* applied = setlocale(LC_ALL, "");
    if (!applied) applied = setlocale(LC_ALL, "en_US.UTF-8");
    if (!applied) applied = setlocale(LC_ALL, "en_US");
    if (!applied) applied = setlocale(LC_ALL, "C.UTF-8");
    if (!applied) applied = setlocale(LC_ALL, "C");
 
 
    bindtextdomain("BastionGuard", LOCALEDIR);
    bind_textdomain_codeset("BastionGuard", "UTF-8");
    textdomain("BastionGuard");
 
    auto app = Gtk::Application::create("org.BastionGuard.wizard");
    load_style();
 
    auto* wizard = new BastionGuard::wizard::WizardWindow();
    app->add_window(*wizard);
 
    wizard->signal_finished().connect([&app, wizard]() {
        wizard->hide();
        app->remove_window(*wizard);
        delete wizard;
 
        // 7) Lancia BastionGuard-first-run e aspetta che finisca
        const std::string first_run_app = "/usr/bin/BastionGuard-first-run";
        pid_t pid = fork();
 
        if (pid == 0) {
            execl(first_run_app.c_str(), first_run_app.c_str(), nullptr);
            std::cerr << "[Wizard] ❌ Impossibile lanciare BastionGuard-first-run: "
                      << strerror(errno) << std::endl;
            _exit(1);
 
        } else if (pid > 0) {
            Glib::signal_child_watch().connect([&app](GPid child_pid, int status) {
                g_spawn_close_pid(child_pid);
 
                const std::string main_app = "/usr/bin/BastionGuard";
                std::cout << "[Wizard] 🚀 Lancio: " << main_app << std::endl;
                execl(main_app.c_str(), main_app.c_str(), nullptr);
 
                std::cerr << "[Wizard] ❌ Impossibile lanciare BastionGuard: "
                          << strerror(errno) << std::endl;
                app->quit();
            }, pid);
 
        } else {
            std::cerr << "[Wizard] ❌ fork() fallita: " << strerror(errno) << std::endl;
            app->quit();
        }
    });
 
    wizard->present();
    return app->run(argc, argv);
}