DekiJson.cpp

#include "DekiJson.h"
#include <deki/LogSystem.h>

// cJSON is vendored under third_party/cJSON/, so this package needs nothing
// from any platform. The package's recursive source glob compiles its .c file.
#include "third_party/cJSON/cJSON.h"

#include <cstring>

namespace DekiJson
{

// ---- ctor / dtor / move ----

Document::Document() = default;

Document::~Document()
{
    if (m_Owns && m_Node)
    {
        cJSON_Delete(static_cast<cJSON*>(m_Node));
    }
    m_Node = nullptr;
    m_Owns = false;
}

Document::Document(Document&& other) noexcept
    : m_Node(other.m_Node),
      m_Owns(other.m_Owns)
{
    other.m_Node = nullptr;
    other.m_Owns = false;
}

Document& Document::operator=(Document&& other) noexcept
{
    if (this != &other)
    {
        if (m_Owns && m_Node)
        {
            cJSON_Delete(static_cast<cJSON*>(m_Node));
        }
        m_Node = other.m_Node;
        m_Owns = other.m_Owns;
        other.m_Node = nullptr;
        other.m_Owns = false;
    }
    return *this;
}

// ---- construction ----

Document Document::Parse(const std::string& text)
{
    cJSON* root = cJSON_Parse(text.c_str());
    if (!root)
    {
        DEKI_LOG_ERROR("[deki-json] parse failed");
        return Document();
    }
    return Document(root, /*owns=*/true);
}

Document Document::Object()
{
    return Document(cJSON_CreateObject(), /*owns=*/true);
}

Document Document::Array()
{
    return Document(cJSON_CreateArray(), /*owns=*/true);
}

bool Document::Valid() const
{
    return m_Node != nullptr;
}

// ---- reading ----

bool Document::HasKey(const char* key) const
{
    if (!m_Node || !key)
    {
        return false;
    }
    return cJSON_GetObjectItem(static_cast<cJSON*>(m_Node), key) != nullptr;
}

double Document::GetNumber(const char* key, double fallback) const
{
    if (!m_Node || !key)
    {
        return fallback;
    }
    cJSON* n = cJSON_GetObjectItem(static_cast<cJSON*>(m_Node), key);
    return cJSON_IsNumber(n) ? n->valuedouble : fallback;
}

bool Document::GetBool(const char* key, bool fallback) const
{
    if (!m_Node || !key)
    {
        return fallback;
    }
    cJSON* n = cJSON_GetObjectItem(static_cast<cJSON*>(m_Node), key);
    if (cJSON_IsBool(n))
    {
        return cJSON_IsTrue(n);
    }
    return fallback;
}

std::string Document::GetString(const char* key, const char* fallback) const
{
    if (!m_Node || !key)
    {
        return fallback ? fallback : "";
    }
    cJSON* n = cJSON_GetObjectItem(static_cast<cJSON*>(m_Node), key);
    if (cJSON_IsString(n) && n->valuestring)
    {
        return n->valuestring;
    }
    return fallback ? fallback : "";
}

Document Document::GetChild(const char* key) const
{
    if (!m_Node || !key)
    {
        return Document();
    }
    cJSON* n = cJSON_GetObjectItem(static_cast<cJSON*>(m_Node), key);
    if (!n)
    {
        return Document();
    }
    return Document(n, /*owns=*/false);  // borrowed view
}

int Document::Size() const
{
    if (!m_Node)
    {
        return 0;
    }
    return cJSON_GetArraySize(static_cast<cJSON*>(m_Node));
}

Document Document::GetAt(int index) const
{
    if (!m_Node || index < 0)
    {
        return Document();
    }
    cJSON* n = cJSON_GetArrayItem(static_cast<cJSON*>(m_Node), index);
    if (!n)
    {
        return Document();
    }
    return Document(n, /*owns=*/false);
}

// ---- building ----

// Puts `item` under `key`, replacing a member already there. cJSON's Add*
// functions append even when the key exists, which left {"n":1,"n":2} and
// reads that kept returning the first value. Lookups are case-insensitive, as
// GetNumber and the other readers are. Takes ownership of `item`.
static void SetMember(cJSON* object, const char* key, cJSON* item)
{
    if (!item)
    {
        return;
    }
    const bool stored = cJSON_GetObjectItem(object, key) ? cJSON_ReplaceItemInObject(object, key, item)
                                                         : cJSON_AddItemToObject(object, key, item);
    if (!stored)
    {
        cJSON_Delete(item);
    }
}

void Document::SetNumber(const char* key, double value)
{
    if (!m_Node || !key)
    {
        return;
    }
    SetMember(static_cast<cJSON*>(m_Node), key, cJSON_CreateNumber(value));
}

void Document::SetBool(const char* key, bool value)
{
    if (!m_Node || !key)
    {
        return;
    }
    SetMember(static_cast<cJSON*>(m_Node), key, cJSON_CreateBool(value));
}

void Document::SetString(const char* key, const std::string& value)
{
    if (!m_Node || !key)
    {
        return;
    }
    SetMember(static_cast<cJSON*>(m_Node), key, cJSON_CreateString(value.c_str()));
}

// The node to link into another tree. A borrowed view (GetChild / GetAt)
// still belongs to its own tree, so it is copied: linked as-is, one node
// would sit in two trees and both roots would free it.
static cJSON* TakeForLinking(void*& node, bool& owns)
{
    cJSON* taken = owns ? static_cast<cJSON*>(node) : cJSON_Duplicate(static_cast<cJSON*>(node), /*recurse=*/1);
    if (owns)
    {
        node = nullptr;
        owns = false;
    }
    return taken;
}

void Document::SetChild(const char* key, Document child)
{
    if (!m_Node || !key || !child.Valid())
    {
        return;
    }
    cJSON* node = TakeForLinking(child.m_Node, child.m_Owns);
    if (!node)
    {
        return;
    }
    SetMember(static_cast<cJSON*>(m_Node), key, node);
}

void Document::PushBack(Document child)
{
    if (!m_Node || !child.Valid())
    {
        return;
    }
    cJSON* node = TakeForLinking(child.m_Node, child.m_Owns);
    if (!node)
    {
        return;
    }
    if (!cJSON_AddItemToArray(static_cast<cJSON*>(m_Node), node))
    {
        cJSON_Delete(node);
    }
}

// ---- serialization ----

std::string Document::Dump() const
{
    if (!m_Node)
    {
        return {};
    }
    char* s = cJSON_PrintUnformatted(static_cast<cJSON*>(m_Node));
    if (!s)
    {
        return {};
    }
    std::string out(s);
    cJSON_free(s);
    return out;
}

}  // namespace DekiJson