SettingsStore.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 "SettingsStore.hpp"
 
#include <glibmm/miscutils.h>
#include <filesystem>
#include <fstream>
#include <unordered_set>
#include <algorithm>
#include <locale.h>
#include <iostream>
 
namespace fs = std::filesystem;
 
std::mutex SettingsStore::mtx_;
bool SettingsStore::loaded_ = false;
nlohmann::json SettingsStore::cache_ = nlohmann::json::object();
 
static std::string config_dir_path() {
    return Glib::get_home_dir() + "/.config/BastionGuard";
}
 
std::string SettingsStore::settings_file_path() {
    return config_dir_path() + "/settings.json";
}
 
nlohmann::json SettingsStore::defaults() {
    nlohmann::json j;
    j["security"] = nlohmann::json::object();
    j["security"]["secure_payments_enabled"] = false;
 
    j["ui"] = nlohmann::json::object();
    j["ui"]["language"] = "";  // vuoto = leggi da lang.conf
 
    return j;
}
 
void SettingsStore::init() {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
}
 
void SettingsStore::reload() {
    std::lock_guard<std::mutex> lk(mtx_);
    loaded_ = false;
    cache_.clear();
    ensure_loaded_locked();
}
 
bool SettingsStore::reset_to_defaults() {
    std::lock_guard<std::mutex> lk(mtx_);
    cache_ = defaults();
    loaded_ = true;
    return write_to_disk_locked(cache_);
}
 
void SettingsStore::ensure_loaded_locked() {
    if (loaded_) return;
 
    cache_ = defaults();
 
    load_from_disk_locked();
 
    loaded_ = true;
}
 
bool SettingsStore::load_from_disk_locked() {
    const auto path = settings_file_path();
 
    if (!fs::exists(path)) {
        return true;
    }
 
    try {
        std::ifstream in(path, std::ios::binary);
        if (!in.good()) return false;
 
        nlohmann::json disk;
        in >> disk;
        cache_.merge_patch(disk);
 
        return true;
    } catch (...) {
        return false;
    }
}
 
bool SettingsStore::write_to_disk_locked(const nlohmann::json& j) {
    const auto dir  = config_dir_path();
    const auto path = settings_file_path();
    const auto tmp  = path + ".tmp";
 
    try {
        fs::create_directories(dir);
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
 
        return true;
    } catch (...) {
        return false;
    }
}
 
bool SettingsStore::flush() {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
    return write_to_disk_locked(cache_);
}
 
static std::vector<std::string> split_dotted(const std::string& dotted_key) {
    std::vector<std::string> parts;
    std::string cur;
    for (char c : dotted_key) {
        if (c == '.') {
            if (!cur.empty()) parts.push_back(cur);
            cur.clear();
        } else {
            cur.push_back(c);
        }
    }
    if (!cur.empty()) parts.push_back(cur);
    return parts;
}
 
nlohmann::json* SettingsStore::get_or_create_node_locked(nlohmann::json& root, const std::string& dotted_key) {
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return nullptr;
 
    nlohmann::json* node = &root;
    for (size_t i = 0; i + 1 < parts.size(); ++i) {
        const auto& k = parts[i];
        if (!node->contains(k) || !(*node)[k].is_object()) {
            (*node)[k] = nlohmann::json::object();
        }
        node = &(*node)[k];
    }
    return node;
}
 
const nlohmann::json* SettingsStore::get_node_locked(const nlohmann::json& root, const std::string& dotted_key) {
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return nullptr;
 
    const nlohmann::json* node = &root;
    for (const auto& k : parts) {
        if (!node->is_object() || !node->contains(k)) return nullptr;
        node = &(*node)[k];
    }
    return node;
}
 
bool SettingsStore::get_bool(const std::string& dotted_key, bool fallback_default) {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    const auto* n = get_node_locked(cache_, dotted_key);
    if (!n) return fallback_default;
    if (n->is_boolean()) return n->get<bool>();
    return fallback_default;
}
 
void SettingsStore::set_bool(const std::string& dotted_key, bool value) {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return;
 
    nlohmann::json* parent = get_or_create_node_locked(cache_, dotted_key);
    if (!parent) return;
 
    (*parent)[parts.back()] = value;
    write_to_disk_locked(cache_);
}
 
int SettingsStore::get_int(const std::string& dotted_key, int fallback_default) {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    const auto* n = get_node_locked(cache_, dotted_key);
    if (!n) return fallback_default;
    if (n->is_number_integer()) return n->get<int>();
    if (n->is_number()) return static_cast<int>(n->get<double>());
    return fallback_default;
}
 
void SettingsStore::set_int(const std::string& dotted_key, int value) {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return;
 
    nlohmann::json* parent = get_or_create_node_locked(cache_, dotted_key);
    if (!parent) return;
 
    (*parent)[parts.back()] = value;
    write_to_disk_locked(cache_);
}
 
std::string SettingsStore::get_string(const std::string& dotted_key, const std::string& fallback_default) {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    const auto* n = get_node_locked(cache_, dotted_key);
    if (!n) return fallback_default;
    if (n->is_string()) return n->get<std::string>();
    return fallback_default;
}
 
void SettingsStore::set_string(const std::string& dotted_key, const std::string& value) {
    std::lock_guard<std::mutex> lk(mtx_);
    ensure_loaded_locked();
 
    auto parts = split_dotted(dotted_key);
    if (parts.empty()) return;
 
    nlohmann::json* parent = get_or_create_node_locked(cache_, dotted_key);
    if (!parent) return;
 
    (*parent)[parts.back()] = value;
    write_to_disk_locked(cache_);
}
 
 
bool SettingsStore::get_secure_payments_enabled() {
    // usa default ufficiale (false)
    return get_bool("security.secure_payments_enabled", false);
}
 
void SettingsStore::set_secure_payments_enabled(bool enabled) {
    set_bool("security.secure_payments_enabled", enabled);
}
 
std::string SettingsStore::get_language() {
    return get_string("ui.language", "");
}
 
void SettingsStore::set_language(const std::string& lang) {
    set_string("ui.language", lang);
 
    // Mantieni lang.conf sincronizzato — usato dai binari che girano
    // prima che SettingsStore sia inizializzato (es. script di sistema).
    const std::string lang_conf =
        Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
    try {
        std::filesystem::create_directories(
            std::filesystem::path(lang_conf).parent_path());
        std::ofstream f(lang_conf, std::ios::trunc);
        if (f.is_open()) {
            f << "LANG="     << lang << ".UTF-8\n"
              << "LC_ALL="   << lang << ".UTF-8\n"
              << "LANGUAGE=" << lang << ":" << lang.substr(0, 2) << "\n";
        }
    } catch (...) {}
}
 
void SettingsStore::apply_language() {
    // ── Fonte 1: settings.json ui.language ───────────────────────────────────
    const std::string from_settings = get_language();
 
    // ── Fonte 2: lang.conf ────────────────────────────────────────────────────
    const std::string lang_conf =
        Glib::get_home_dir() + "/.config/BastionGuard/lang.conf";
 
    // Leggi la lingua da lang.conf (es. "it_IT" da LANG=it_IT.UTF-8)
    std::string from_lang_conf;
    {
        std::ifstream f(lang_conf);
        std::string line;
        while (std::getline(f, line)) {
            // Cerca LANG= o LANGUAGE= per estrarre il codice lingua
            if (line.rfind("LANGUAGE=", 0) == 0) {
                from_lang_conf = line.substr(9);
                // Prendi solo la prima voce (es. "it_IT:it" → "it_IT")
                const auto colon = from_lang_conf.find(':');
                if (colon != std::string::npos)
                    from_lang_conf = from_lang_conf.substr(0, colon);
                break;
            }
        }
    }
 
    // Determina la lingua effettiva da usare:
    // Se settings.json è vuoto o è ancora il default "en_US" E lang.conf
    // ha qualcosa di diverso → lang.conf vince (migrazione automatica).
    std::string lang;
    const bool settings_is_default =
        from_settings.empty() || from_settings == "en_US";
 
    if (settings_is_default && !from_lang_conf.empty()
                             && from_lang_conf != "en_US") {
        lang = from_lang_conf;
        // Scrivi in settings.json così i prossimi avvii usano direttamente quello
        set_language(lang);
        std::cerr << "[i18n] migrated language from lang.conf to settings.json: "
                  << lang << "\n";
    } else if (!from_settings.empty()) {
        lang = from_settings;
        std::cerr << "[i18n] language from settings.json: " << lang << "\n";
    } else if (!from_lang_conf.empty()) {
        lang = from_lang_conf;
        std::cerr << "[i18n] language from lang.conf: " << lang << "\n";
    } else {
        std::cerr << "[i18n] no language configured, using system locale\n";
        setlocale(LC_ALL, "");
        return;
    }
 
    setenv("LANGUAGE", lang.c_str(), 1);
    setenv("LANG",    (lang + ".UTF-8").c_str(), 1);
    setenv("LC_ALL",  (lang + ".UTF-8").c_str(), 1);
    if (!setlocale(LC_ALL, (lang + ".UTF-8").c_str()))
        if (!setlocale(LC_ALL, lang.c_str()))
            setlocale(LC_ALL, "");
}
 
std::string SettingsStore::user_payments_path() {
    return Glib::get_home_dir() + "/.config/BastionGuard/payments.json";
}
 
std::string SettingsStore::system_payments_path() {
    return "/usr/share/BastionGuard/data/payments/payments.json";
}
 
static std::string normalize_domain(std::string s) {
    s.erase(0, s.find_first_not_of(" \t\r\n"));
    s.erase(s.find_last_not_of(" \t\r\n") + 1);
    std::transform(s.begin(), s.end(), s.begin(),
                   [](unsigned char c){ return (char)std::tolower(c); });
    if (!s.empty() && s[0] == '.') s.erase(0, 1);
    if (s.rfind("www.", 0) == 0) s.erase(0, 4);
    auto p = s.find(':');
    if (p != std::string::npos) s.erase(p);
 
    return s;
}
 
nlohmann::json SettingsStore::default_payments_seed() {
    nlohmann::json j;
    j["version"] = 1;
    j["updated_at"] = "2026-01-13";
    j["list"] = nlohmann::json::array({
        "paypal.com",
        "stripe.com",
        "adyen.com",
        "klarna.com",
        "checkout.com",
        "worldpay.com",
        "braintreepayments.com",
        "braintreegateway.com",
        "amazonpay.com",
        "pay.google.com",
        "pay.apple.com",
        "sisalpay.it",
        "nexi.it",
        "payments.amazon.com"
    });
    return j;
}
 
bool SettingsStore::read_json_file(const std::string& path, nlohmann::json& out) {
    try {
        if (!fs::exists(path)) return false;
        std::ifstream in(path, std::ios::binary);
        if (!in.good()) return false;
        in >> out;
        return true;
    } catch (...) {
        return false;
    }
}
 
bool SettingsStore::write_json_atomic(const std::string& path, const nlohmann::json& j) {
    try {
        fs::create_directories(fs::path(path).parent_path());
        const auto tmp = path + ".tmp";
 
        {
            std::ofstream out(tmp, std::ios::binary | std::ios::trunc);
            if (!out.good()) return false;
            out << j.dump(2);
            out.flush();
            if (!out.good()) return false;
        }
 
        std::error_code ec;
        fs::rename(tmp, path, ec);
        if (ec) {
            fs::remove(path, ec);
            ec.clear();
            fs::rename(tmp, path, ec);
            if (ec) {
                fs::remove(tmp, ec);
                return false;
            }
        }
        return true;
    } catch (...) {
        return false;
    }
}
 
void SettingsStore::ensure_payments_json_exists() {
    std::lock_guard<std::mutex> lk(mtx_);
 
    const auto up = user_payments_path();
    const auto sp = system_payments_path();
 
    if (fs::exists(up)) return;
    if (fs::exists(sp)) {
        try {
            fs::create_directories(fs::path(up).parent_path());
            std::ifstream in(sp, std::ios::binary);
            std::ofstream out(up, std::ios::binary | std::ios::trunc);
            if (in.good() && out.good()) {
                out << in.rdbuf();
                return;
            }
        } catch (...) {
        }
    }
 
    write_json_atomic(up, default_payments_seed());
}
 
static void extract_domains_from_payments_json(const nlohmann::json& j, std::vector<std::string>& out) {
    if (j.is_object()) {
        if (j.contains("list") && j["list"].is_array()) {
            for (const auto& v : j["list"]) {
                if (v.is_string()) out.push_back(normalize_domain(v.get<std::string>()));
            }
        } else if (j.contains("domains") && j["domains"].is_array()) {
            for (const auto& v : j["domains"]) {
                if (v.is_string()) out.push_back(normalize_domain(v.get<std::string>()));
            }
        }
    } else if (j.is_array()) {
        for (const auto& v : j) {
            if (v.is_string()) out.push_back(normalize_domain(v.get<std::string>()));
        }
    }
}
 
std::vector<std::string> SettingsStore::get_payment_domains() {
    ensure_payments_json_exists();
 
    std::lock_guard<std::mutex> lk(mtx_);
 
    std::vector<std::string> tmp;
    nlohmann::json jsys, jusr;
    if (read_json_file(system_payments_path(), jsys)) extract_domains_from_payments_json(jsys, tmp);
    if (read_json_file(user_payments_path(), jusr))  extract_domains_from_payments_json(jusr, tmp);
 
    // dedup + sort
    std::unordered_set<std::string> uniq;
    std::vector<std::string> out;
    out.reserve(tmp.size());
 
    for (auto& d : tmp) {
        d = normalize_domain(d);
        if (d.empty()) continue;
        if (uniq.insert(d).second) out.push_back(d);
    }
 
    std::sort(out.begin(), out.end());
    return out;
}
 
bool SettingsStore::save_payment_domains_user(const std::vector<std::string>& domains) {
    std::lock_guard<std::mutex> lk(mtx_);
 
    nlohmann::json j;
    j["version"] = 1;
    j["updated_at"] = "2026-01-13";
    j["list"] = nlohmann::json::array();
 
    std::unordered_set<std::string> uniq;
    for (auto d : domains) {
        d = normalize_domain(d);
        if (d.empty()) continue;
        if (uniq.insert(d).second) j["list"].push_back(d);
    }
 
    return write_json_atomic(user_payments_path(), j);
}
 
bool SettingsStore::reset_payment_domains_from_system() {
    std::lock_guard<std::mutex> lk(mtx_);
 
    const auto sp = system_payments_path();
    const auto up = user_payments_path();
 
    if (!fs::exists(sp)) return false;
 
    try {
        fs::create_directories(fs::path(up).parent_path());
        std::ifstream in(sp, std::ios::binary);
        std::ofstream out(up, std::ios::binary | std::ios::trunc);
        if (!in.good() || !out.good()) return false;
        out << in.rdbuf();
        return true;
    } catch (...) {
        return false;
    }
}