#include <nlohmann/json.hpp>
using json = nlohmann::json;

json cfg;

cfg["name"]          = "Alice";
cfg["age"]           = 31;
cfg["scores"]        = {92, 88, 95};
cfg["active"]        = true;
cfg["settings"]["theme"] = "dark";           // nested object
cfg["tags"]          = json::array({"cpp", "performance", "modern"});

// very convenient access
std::string name = cfg["name"];
int age          = cfg.value("age", 0);       // default value
auto scores      = cfg["scores"].get<std::vector<int>>();

#include <variant>
#include <map>
#include <string>
#include <vector>

using Value = std::variant<
    std::monostate,               // null
    bool,
    int64_t,
    double,
    std::string,
    std::vector<Value>,           // ← recursion
    std::map<std::string, Value>  // ← recursion
>;

class UniversalMap
{
    std::map<std::string, Value> data;

public:
    template<class T>
    void put(std::string key, T&& value)
    {
        data[std::move(key)] = std::forward<T>(value);
    }

    // helper getters with default
    template<class T>
    T get(const std::string& key, T default_value = {}) const
    {
        if (auto it = data.find(key); it != data.end())
            if (auto* v = std::get_if<T>(&it->second))
                return *v;
        return default_value;
    }
};

UniversalMap m;

m.put("pi",     3.141592);
m.put("name",   std::string("Violet"));
m.put("active", true);
m.put("scores", std::vector<Value>{10, 20, 30});

m.put("person", std::map<std::string, Value>{
    {"name", "Alex"},
    {"age",  27}
});

m.put("nested", std::vector<Value>{
    std::map<std::string, Value>{{"x",1}, {"y",2}},
    std::map<std::string, Value>{{"x",3}, {"y",4}}
});

#include <nlohmann/json.hpp>

#include <nlohmann/json.hpp>
using json = nlohmann::json;

int main()
{
    json j;

    // primitives + containers work out of the box
    j["pi"]      = 3.141592653589793;
    j["happy"]   = true;
    j["nothing"] = nullptr;
    j["answer"]  = 42;
    j["list"]    = {1, 0, 2};
    j["object"]  = { {"currency", "EUR"}, {"value", 349.95} };
    j["vec"]     = std::vector<int>{10, 20, 30};
    j["map"]     = std::map<std::string, double>{{"temp", 23.5}, {"pressure", 1013.25}};

    // serialization = dumping to string
    std::string s = j.dump();           // compact
    std::string pretty = j.dump(4);     // indented with 4 spaces

    std::cout << pretty << "\n";
}

#include <nlohmann/json.hpp>
using json = nlohmann::json;

namespace my_app
{
    struct Person
    {
        std::string name;
        int         age          = 0;
        bool        is_student   = false;
        std::vector<std::string> hobbies;
    };

    // ── Serialization ─────────────────────────────────────────────
    void to_json(json& j, const Person& p)
    {
        j = json{
            {"name",       p.name},
            {"age",        p.age},
            {"is_student", p.is_student},
            {"hobbies",    p.hobbies}
        };
    }

    // ── Deserialization ───────────────────────────────────────────
    void from_json(const json& j, Person& p)
    {
        // Option A: safe + explicit
        j.at("name").get_to(p.name);
        j.at("age").get_to(p.age);
        j.at("is_student").get_to(p.is_student);
        j.at("hobbies").get_to(p.hobbies);

        // Option B: shorter but throws if key missing
        // p.name       = j.value("name", "");
        // p.age        = j.value("age", 0);
        // p.is_student = j.value("is_student", false);
        // p.hobbies    = j.value("hobbies", std::vector<std::string>{});
    }
}

my_app::Person alice{"Alice", 28, true, {"reading", "hiking"}};

json j = alice;                        // ← calls to_json automatically
std::string serialized = j.dump(2);

std::cout << serialized << "\n";
// {
//   "name": "Alice",
//   "age": 28,
//   "is_student": true,
//   "hobbies": ["reading", "hiking"]
// }

json j2 = json::parse(serialized);
my_app::Person copy = j2.get<my_app::Person>();   // ← calls from_json

struct Config
{
    std::string host     = "localhost";
    uint16_t    port     = 8080;
    bool        ssl      = true;
    std::vector<int> timeouts{5, 15, 60};

    // one line!
    NLOHMANN_DEFINE_TYPE_INTRUSIVE(Config, host, port, ssl, timeouts)
};

NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Config, host, port, ssl, timeouts)

json j = ...;

// Serialize
std::string        str  = j.dump();             // compact
std::string        nice = j.dump(4);            // pretty
std::vector<uint8_t> cb = json::to_cbor(j);     // binary

// Deserialize
json j2 = json::parse(str);                     // from string
json j3 = json::from_cbor(binary_vector);

// Convert to C++ type
Person p = j.get<Person>();
j.get_to(p);                // existing object
auto val = j.value("/path/to/value", default_value);

class basic_json
{
    // ── 1. Type tag ────────────────────────────────
    value_t m_type = value_t::null;   // 1 byte enum

    // ── 2. The actual payload ──────────────────────
    json_value m_value {};            // tagged union

    // ── Optional small fields ──────────────────────
    // (some extra bits used only for certain types)
};

enum class value_t : std::uint8_t
{
    null,         // 0
    object,       // 1
    array,        // 2
    string,       // 3
    boolean,      // 4
    number_integer,
    number_unsigned,
    number_float,
    binary,       // CBOR/BSON/MsgPack/UBJSON support
    discarded     // internal helper
};

union json_value
{
    object_t* object;           // std::map<std::string, basic_json>   by default
    array_t*  array;            // std::vector<basic_json>
    string_t* string;           // std::string
    binary_t* binary;           // std::vector<std::uint8_t>
    boolean_t boolean;          // bool
    number_integer_t   number_integer;   // int64_t   by default
    number_unsigned_t  number_unsigned;  // uint64_t
    number_float_t     number_float;     // double

    // ── very small optimization for small strings (SSO-like) ──
    // (not always enabled – depends on compile-time macro)
};

using my_json = nlohmann::basic_json<
    std::unordered_map,           // faster lookup, unordered objects
    std::pmr::vector,             // polymorphic allocator
    std::pmr::string,             // ...
    bool,                         // boolean
    std::int64_t, std::uint64_t, double,
    std::vector<std::uint8_t>
>;

union json_value
{
    // ...
    string_t* string;   // ← pointer to std::string
    // ...
};

json j;

// Usually SSO (no heap alloc for chars) on most implementations
j = "hello";                    // 5 chars → almost always SSO
j = "quite_long_but_still_ok";  // 22 chars → maybe SSO on libc++, no on others

// Almost never SSO
j = std::string(30, 'x');       // 30 chars → heap in all mainstream impls

template<class... Ts> struct overload : Ts... { using Ts::operator()...; };
template<class... Ts> overload(Ts...) -> overload<Ts...>;

std::visit(overload{
    [](int i)          { std::print("int: {}\n", i); },
    [](std::string s)  { std::print("str: {}\n", s); },
    [](auto&& other)   { static_assert(false, "unsupported"); }
}, my_variant);

template <std::size_t I, class V>
using alt_t = std::variant_alternative_t<I, V>;

template <class V, class F>
void visit_by_index(V&& var, std::size_t idx, F&& f) {
    std::visit([&](auto&& v) {
        using T = std::decay_t<decltype(v)>;
        constexpr auto table = std::array{ /* lambdas for each alternative */ };
        table[idx](std::forward<decltype(v)>(v));
    }, std::forward<V>(var));
}

// future C++26 pseudocode
constexpr auto refl = ^^MyVariant;
constexpr auto alts = std::meta::nonstatic_data_members_of(refl); // or variant alternatives
for_each(alts, []<auto R>{
    using T = std::meta::type_of(R);
    // generate visitor, serializer, etc.
});