SystemConfig.hpp

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <functional>
#include <string_view>
#include <variant>
 
// Third-party includes
#include <nlohmann/json.hpp>
 
// Project includes
#include "FileSystem.hpp"
#include "StringMap.hpp"
#include "MonotonicIdAllocator.hpp"
 
namespace dfx::Utils
{
class SystemConfig
{
public:
    using StringList = std::vector<std::string>;

    struct Value : public std::variant<bool, int64_t, double, std::string, StringList>
    {
        using std::variant<bool, int64_t, double, std::string, StringList>::variant;

        bool is_bool() const noexcept       { return std::holds_alternative<bool>(*this); }
        bool is_integer() const noexcept    { return std::holds_alternative<int64_t>(*this); }
        bool is_double() const noexcept     { return std::holds_alternative<double>(*this); }
        bool is_string() const noexcept     { return std::holds_alternative<std::string>(*this); }
        bool is_stringlist() const noexcept { return std::holds_alternative<StringList>(*this); }

        bool        to_bool() const      { return std::get<bool>(*this); }
        int64_t     to_integer() const   { return std::get<int64_t>(*this); }
        double      to_double() const    { return std::get<double>(*this); }
        std::string to_string() const    { return std::get<std::string>(*this); }
        StringList to_stringlist() const { return std::get<StringList>(*this); }

        std::string convert_to_string() const;
    };
 
public:
    using Setter    = std::move_only_function<void (Value)>;

    using Getter    = std::move_only_function<Value ()>;

    using Callback  = std::move_only_function<void (std::string_view, Value const &, Value const &)>;

    using Id        = uint32_t;

    using Callbacks = std::unordered_map<Id, Callback>;

    struct Entry
    {
        mutable Getter getter;   
        Setter setter;           
        std::string description; 
        Value defaultValue;      
        bool readOnly = false;   
    };
 
private:
    struct Pimpl;
    using PimplPtr = std::unique_ptr<Pimpl>;
 
public:
    explicit SystemConfig(UnorderedStringMap<Value> cliOverride = {});

    explicit SystemConfig(fs::path const & path, UnorderedStringMap<Value> cliOverride = {});

    ~SystemConfig();
 
public:
    void addEntry(std::string key, Value defaultValue, std::string description,
                  Getter getter, Setter setter, bool readOnly = false);

    void removeEntry(std::string_view key);

    bool hasEntry(std::string_view key) const;

    bool isEntryReadOnly(std::string_view configKey) const         { return _entry(configKey).readOnly; }
    std::string entryDescription(std::string_view configKey) const { return _entry(configKey).description; }
    Value entryDefaultValue(std::string_view configKey) const      { return _entry(configKey).defaultValue; }
    Value entryValue(std::string_view configKey) const             { return _entry(configKey).getter(); }

    void setEntryValue(std::string_view configKey, Value newValue);

    nlohmann::json queryJson(std::string_view path) const;

    std::unordered_map<std::string, Value> allEntryValues() const;
 
public:
    void loadConfig(fs::path const & path);

    fs::path const & configPath() const noexcept { return _configPath; }
 
public:
    Id registerCallback(std::string_view configKey, Callback cb);
    void deregisterCallback(Id id);
 
private:
    Entry const & _entry(std::string_view configKey) const;
    Entry & _entry(std::string_view configKey);
 
private:
    fs::path _configPath;
 
    UnorderedStringMap<Value>     _cliOverride;
    UnorderedStringMap<Entry>     _entries;
    UnorderedStringMap<Callbacks> _callbacks;
 
    MonotonicIdAllocator<Id> _idAllocator;
 
private:
    PimplPtr _pimpl;
};
} // !namespace dfx::Utils
 
template<>
struct std::formatter<dfx::Utils::SystemConfig::Value> : public formatter<std::string_view>
{
    inline auto format(dfx::Utils::SystemConfig::Value const & val, format_context & ctx) const
    { return formatter<std::string_view>::format(val.convert_to_string(), ctx); }
};