#include <automerge-cpp/automerge.hpp>
namespace am = automerge_cpp;

int main() {
    auto doc = am::Document{};

    // Initializer lists — just like nlohmann/json
    const auto items = doc.transact([](am::Transaction& tx) {
        tx.put(am::root, "title", "Shopping List");
        tx.put(am::root, "config", {{"theme", "dark"}, {"lang", "en"}});
        return tx.put(am::root, "items", {"Milk", "Eggs", "Bread"});
    });

    // Typed get<T>() — no variant unwrapping
    const auto title = doc.get<std::string>(am::root, "title");  // "Shopping List"

    // operator[] and get_path() — nested access
    const auto value = doc["title"];                    // root map access
    const auto theme = doc.get_path("config", "theme"); // nested path access

    // Fork, edit concurrently, merge — conflict-free
    auto doc2 = doc.fork();
    doc.transact([&](auto& tx)  { tx.insert(items, 3, "Butter"); });
    doc2.transact([&](auto& tx) { tx.insert(items, 3, "Cheese"); });
    doc.merge(doc2);  // both items preserved, no data loss

    // Save to binary and reload
    const auto bytes = doc.save();
    auto loaded = am::Document::load(bytes);
}

auto name = doc.get<std::string>(root, "name");       // optional<string>
auto age  = doc.get<std::int64_t>(root, "age");        // optional<int64_t>
auto pi   = doc.get<double>(root, "pi");               // optional<double>
auto ok   = doc.get<bool>(root, "active");             // optional<bool>
auto hits = doc.get<Counter>(root, "hits");            // optional<Counter>

doc.transact([](auto& tx) {
    tx.put(root, "name", "Alice");                     // const char*
    tx.put(root, "age", 30);                           // int → int64_t
    tx.put(root, "score", 99.5);                       // double
    tx.put(root, "active", true);                      // bool
    tx.put(root, "views", Counter{0});                 // Counter
    tx.put(root, "empty", Null{});                     // null
});

// Lambda return type is deduced — no external variable needed
auto list_id = doc.transact([](Transaction& tx) {
    return tx.put(root, "items", {"Milk", "Eggs", "Bread"});
});

// transact_with_patches returns {result, patches}
auto [obj_id, patches] = doc.transact_with_patches([](Transaction& tx) {
    return tx.put(root, "data", Map{});
});

doc.transact([](auto& tx) {
    // Bare initializer lists — auto-detects list vs map
    auto items = tx.put(root, "items", {"Milk", "Eggs", "Bread"});
    auto config = tx.put(root, "config", {{"port", 8080}, {"host", "localhost"}});

    // Explicit wrappers also work
    auto tags = tx.put(root, "tags", List{"crdt", "cpp", "collaborative"});
    auto meta = tx.put(root, "meta", Map{{"version", "1.0"}, {"stable", true}});

    // Mixed types work naturally
    auto mixed = tx.put(root, "data", List{1, "hello", 3.14, true});

    // Insert populated objects into lists
    auto records = tx.put(root, "records", ObjType::list);
    tx.insert(records, 0, {{"name", "Alice"}, {"role", "admin"}});
    tx.insert(records, 1, {{"name", "Bob"}, {"role", "editor"}});
});

// std::vector → creates a list
auto tags = std::vector<std::string>{"crdt", "cpp", "collaborative"};
doc.transact([&](auto& tx) { tx.put(root, "tags", tags); });

// std::set → creates a list (sorted)
auto unique = std::set<std::string>{"alpha", "beta", "gamma"};
doc.transact([&](auto& tx) { tx.put(root, "sorted", unique); });

// std::map → creates a map
auto dims = std::map<std::string, ScalarValue>{
    {"w", ScalarValue{std::int64_t{800}}},
    {"h", ScalarValue{std::int64_t{600}}},
};
doc.transact([&](auto& tx) { tx.put(root, "dims", dims); });

auto port = doc.get_path("config", "database", "port");
auto item = doc.get_path("todos", std::size_t{0}, "title");

std::visit(overload{
    [](std::string s)  { printf("%s\n", s.c_str()); },
    [](std::int64_t i) { printf("%ld\n", i); },
    [](auto&&)         { printf("other\n"); },
}, some_scalar_value);

#include <automerge-cpp/automerge.hpp>
#include <automerge-cpp/json.hpp>
#include <nlohmann/json.hpp>

namespace am = automerge_cpp;
using json = nlohmann::json;

// Import JSON into an Automerge document (recursive, handles nested objects)
auto input = json::parse(R"({"name": "Alice", "scores": [10, 20, 30]})");
auto doc = am::Document{};
am::json::import_json(doc, input);

// Export back to JSON — lossless round-trip
auto output = am::json::export_json(doc);
assert(input == output);

// JSON Pointer (RFC 6901) — path-based access
auto score = am::json::get_pointer(doc, "/scores/0");          // 10
am::json::put_pointer(doc, "/config/port", am::ScalarValue{std::int64_t{8080}});
am::json::delete_pointer(doc, "/scores/2");

// JSON Patch (RFC 6902) — atomic batch operations
am::json::apply_json_patch(doc, json::parse(R"([
    {"op": "add",     "path": "/scores/-", "value": 99},
    {"op": "replace", "path": "/name",     "value": "Bob"},
    {"op": "test",    "path": "/name",     "value": "Bob"}
])"));

// JSON Merge Patch (RFC 7386) — partial updates
am::json::apply_merge_patch(doc, json{{"name", "Charlie"}, {"scores", nullptr}});

// Flatten to JSON Pointer paths
auto flat = am::json::flatten(doc);  // {"/config/port": 8080, "/name": "Charlie"}

// ADL serialization — automerge types ↔ nlohmann::json (in am:: namespace)
json j = am::ScalarValue{am::Counter{42}};  // {"__type": "counter", "value": 42}

// Fork, diff as RFC 6902, then merge
auto bob = doc.fork();
bob.transact([](am::Transaction& tx) { tx.put(am::root, "name", "Dave"); });
auto diff = am::json::diff_json_patch(doc, bob);
doc.merge(bob);