Dqn/Dqn_MetaDesk.h

#if !defined(DQN_META_DESK_H)
#define DQN_META_DESK_H
// -----------------------------------------------------------------------------
// NOTE: Dqn_MetaDesk
// -----------------------------------------------------------------------------
// Contains helpers functions to code generate formatted CPP files using
// Dion-System's MetaDesk library.
//
// MetaDesk must be available under the include path at
// "metadesk/source/md.[c|h]" when this file is compiled.
//
// -----------------------------------------------------------------------------
// NOTE: Configuration
// -----------------------------------------------------------------------------
// #define DQN_META_DESK_IMPLEMENTATION
//     Define this in one and only one C++ file to enable the implementation
//     code of the header file.
//
// #define DQN_META_DESK_STANDALONE_PROGRAM
//     Define this to enable a "main" function allowing this translation unit to
//     be compiled into an executable, by default this program will generate all
//     the possible code generation outputs. This file's implementation must
//     also be available to this translation unit.
//
// -----------------------------------------------------------------------------
// NOTE: Dqn_MetaDesk Header File
// -----------------------------------------------------------------------------
#if !defined(_CRT_SECURE_NO_WARNINGS)
    #define _CRT_SECURE_NO_WARNINGS
    #define DQN_MD_UNDEFINE_CRT_WARNING
#endif

#include <stdio.h>
#include <stdarg.h>
#include "metadesk/source/md.h"

#define DQN_MD_ASSERT_MSG(expr, fmt, ...)                                                                              \
    if (!(expr))                                                                                                       \
    {                                                                                                                  \
        fprintf(stderr, "Assertion triggered at %s line %d. ", __FILE__, __LINE__);                                    \
        fprintf(stderr, fmt, ##__VA_ARGS__);                                                                           \
        fputc('\n', stderr);                                                                                           \
        *((int *)0);                                                                                                   \
    }

#define DQN_MD_INVALID_CODE_PATH do { DQN_MD_ASSERT_MSG(0, "Invalid code path") } while (0)
#define DQN_MD_INVALID_CODE_PATH_MSG(fmt, ...) do { DQN_MD_ASSERT_MSG(0, fmt, __VA_ARGS__) } while(0)
#define DQN_MD_CAST(Type) (Type)

// -----------------------------------------------------------------------------
// NOTE: Dqn_MDCppFile: Helper functions to generate formatted CPP files
// -----------------------------------------------------------------------------
struct Dqn_MDCppFile
{
    FILE *file;
    int   indent;
    int   space_per_indent;
    bool  append_extra_new_line;
};

int     Dqn_MDCppFile_SpacePerIndent(Dqn_MDCppFile *cpp);
void    Dqn_MDCppFile_LineBeginV    (Dqn_MDCppFile *cpp, char const *fmt, va_list args);
void    Dqn_MDCppFile_LineBegin     (Dqn_MDCppFile *cpp, char const *fmt, ...);
void    Dqn_MDCppFile_LineEnd       (Dqn_MDCppFile *cpp, char const *fmt, ...);
void    Dqn_MDCppFile_LineAdd       (Dqn_MDCppFile *cpp, char const *fmt, ...);
void    Dqn_MDCppFile_LineV         (Dqn_MDCppFile *cpp, char const *fmt, va_list args);
void    Dqn_MDCppFile_Line          (Dqn_MDCppFile *cpp, char const *fmt, ...);
void    Dqn_MDCppFile_NewLine       (Dqn_MDCppFile *cpp);
void    Dqn_MDCppFile_Indent        (Dqn_MDCppFile *cpp);
void    Dqn_MDCppFile_Unindent      (Dqn_MDCppFile *cpp);
void    Dqn_MDCppFile_BeginBlock    (Dqn_MDCppFile *cpp, char const *fmt, ...);
void    Dqn_MDCppFile_EndBlock      (Dqn_MDCppFile *cpp, bool trailing_semicolon, bool new_line_on_next_block);
#define Dqn_MDCppFile_EndEnumBlock(cpp) Dqn_MDCppFile_EndBlock(cpp, true /*trailing_semicolon*/, true /*new_line_on_next_block*/)
#define Dqn_MDCppFile_EndForBlock(cpp) Dqn_MDCppFile_EndBlock(cpp, false /*trailing_semicolon*/, false /*new_line_on_next_block*/)
#define Dqn_MDCppFile_EndIfBlock(cpp) Dqn_MDCppFile_EndBlock(cpp, false /*trailing_semicolon*/, false /*new_line_on_next_block*/)
#define Dqn_MDCppFile_EndFuncBlock(cpp) Dqn_MDCppFile_EndBlock(cpp, false /*trailing_semicolon*/, true /*new_line_on_next_block*/)
#define Dqn_MDCppFile_EndStructBlock(cpp) Dqn_MDCppFile_EndBlock(cpp, true /*trailing_semicolon*/, true /*new_line_on_next_block*/)

// -----------------------------------------------------------------------------
// NOTE: Dqn_MD: Code generating helper
// -----------------------------------------------------------------------------
enum Dqn_MD_CodeGenFlag
{
    Dqn_MD_CodeGenFlag_CEnum                   = (1 << 0),
    Dqn_MD_CodeGenFlag_CppStruct               = (1 << 1),
    Dqn_MD_CodeGenFlag_ImGuiFunction           = (1 << 2),
    Dqn_MD_CodeGenFlag_JsonParsingFunction     = (1 << 3),
    Dqn_MD_CodeGenFlag_CurlQueryFunction       = (1 << 4),
    Dqn_MD_CodeGenFlag_JsonEndpointURLFunction = (1 << 5),
    Dqn_MD_CodeGenFlag_JsonRPCPostDataFunction = (1 << 5),
    Dqn_MD_CodeGenFlag_PrintFunction           = (1 << 6),
    Dqn_MD_CodeGenFlag_All                     = (0xFFFFFFFF),
};

// file_path: The path of the file to feed into the code generator to parse and spit out code.
// output_name: The name to assign the .cpp/.h file that is generated from the
// function, i.e. <output_name>.h and <output_name>.cpp
void Dqn_MD_CodeGen(char const *file_path, char const *output_name, unsigned int flags);

// -----------------------------------------------------------------------------
// NOTE: Dqn_MD: Code generating functions
// -----------------------------------------------------------------------------
/*
Generate a CPP struct for the given 'struct_node'. Children nodes of the
'struct_node' must have a 'type' child associated with it.

Input
    INS_CoinGecko_Coin:
    {
        id:              {type: string},
        symbol:          {type: string},
        name:            {type: string},
        market_cap_rank: {type: u16},
        market_data:     {type: INS_CoinGecko_CoinMarketData},
    }

Output
    struct CoinGecko_CoinMarketDataPrice
    {
        Dqn_f32 aud;
        Dqn_f32 btc;
        Dqn_f32 eth;
        Dqn_f32 usd;
    };
*/
void Dqn_MD_GenerateCppStruct(Dqn_MDCppFile *cpp, MD_Node const *struct_node);

/*
Generate for any root MetaDesk node tagged with the 'required_tag'
required_tag: The tag that must be attached to the MetaDesk node for an enum to be generated for it
name: The name of the enum to generate

Input: (With name = "INS_QueryType", required_tag = "json_endpoint")
    char const EXAMPLE[] = R"(@json_endpoint Etherscan_TXListForAddress: {}
                              @json_endpoint CoinGecko_Coin: {}");

Output
    enum INS_QueryType
    {
        INS_QueryType_Etherscan_TXListForAddress,
        INS_QueryType_CoinGecko_Coin,
        INS_QueryType_Count
    };
*/
void Dqn_MD_GenerateCEnum(Dqn_MDCppFile *cpp, MD_ParseResult *parse, MD_String8 required_tag, char const *name);

/*
Generate ImGui widgets for visualising the given 'struct_node'. If a custom type
is provided, we assume that an ImGui function has been previously generated for
the type already.

Input
    INS_CoinGecko_Coin:
    {
        id:              {type: string,                       json_type: string},
        symbol:          {type: string,                       json_type: string},
        name:            {type: string,                       json_type: string},
        market_cap_rank: {type: u16,                          json_type: number},
        market_data:     {type: INS_CoinGecko_CoinMarketData, json_type: object},
    }

Output
    void INS_CoinGecko_CoinImGui(INS_CoinGecko_Coin const *val){
        ImGui::Text("id: %.*s", DQN_STRING_FMT(val->id));
        ImGui::Text("symbol: %.*s", DQN_STRING_FMT(val->symbol));
        ImGui::Text("name: %.*s", DQN_STRING_FMT(val->name));
        ImGui::Text("market_cap_rank: %I64u", val->market_cap_rank);
        INS_CoinGecko_CoinMarketDataImGui(&val->market_data);
    }
*/
void Dqn_MD_GenerateImGuiFunction(Dqn_MDCppFile *cpp, MD_Node const *struct_node, bool header_file);

/*
Generate for any root MetaDesk node tagged with 'json_endpoint'. The MetaDesk
node containing the 'json_endpoint' can specify fields that the JSON parsing
function will attempt to pull out from the provided JSON string, powered by the
library jsmn.h. This function requires "Dqn_Jsmn.h/cpp" to be present in the
project using this generated code.

Input
    char const EXAMPLE[] = R"(
    Etherscan_TXListForAddressEntry:
    {
        block_number:        {type:  u64,    json_key: "blockNumber",       json_type: string},
        nonce:               {type:  u64,                                   json_type: string},
        block_hash:          {type:  string, json_key: "blockHash",         json_type: string},
    }

    @json_endpoint(url: "http://api.etherscan.io/api?module=account&action=txlist&address=%.*s&startblock=0&endblock=99999999&sort=asc&apikey=%.*s"
                   params: {eth_address:string, api_key: string})
    Etherscan_TXListForAddress:
    {
        status:  {type: bool,   json_type: string},
        message: {type: string, json_type: string},
        result:  {type: Etherscan_TXListForAddressEntry[], json_type: array},
    }");

Output: (Truncated for brevity)
    Etherscan_TXListForAddress Etherscan_TXListForAddressParseTokens(jsmntok_t **start_it, Dqn_JsmnErrorHandle *err_handle, Dqn_String json, Dqn_ArenaAllocator *arena)
    {
        INS_Etherscan_TXListForAddress result = {};
        jsmntok_t *it = (*start_it);
        if (!Dqn_JsmnToken_ExpectObject(*it, err_handle)) return result;
        jsmntok_t *object = it++;

        for (int index = 0; index < object->size; index++)
        {
            jsmntok_t *key     = it++;
            jsmntok_t *value   = it++;
            Dqn_String key_str = Dqn_JsmnToken_String(json, *key);
            Dqn_String value_str = Dqn_JsmnToken_String(json, *value); (void)value_str;

            if (key_str == DQN_STRING("status"))
            {
                if (Dqn_JsmnToken_ExpectString(*value, err_handle))
                {
                    result.status = DQN_CAST(Dqn_b32)Dqn_String_ToU64(value_str);
                }
            }
            ...
            else if (key_str == DQN_STRING("result"))
            {
                if (Dqn_JsmnToken_ExpectArray(*value, err_handle))
                {
                    result.result = Dqn_Array_InitWithArenaNoGrow(arena, INS_Etherscan_TXListForAddressEntry, value->size, 0, Dqn_ZeroMem::Yes);
                    for (int array_index = 0; array_index < value->size; array_index++)
                    {
                        auto *result_entry = Dqn_Array_Make(&result.result, 1);
                        *result_entry = INS_Etherscan_TXListForAddressEntryParseTokens(&it, err_handle, json, arena);
                    }
                }
            }
            ...
        }
        *start_it = it;
        return result;
    }

*/
void Dqn_MD_GenerateJsonParsingFunction(Dqn_MDCppFile *cpp, MD_Node const *struct_node, bool header_file);
void Dqn_MD_GenerateCurlQueryFunction(Dqn_MDCppFile *cpp, MD_Node *struct_node, bool header_file);


/*
Generate for any root MetaDesk node with the following tags defined
    @json_endpoint(url: <...>, params: {<...>})

Input
    char const EXAMPLE[] = R"(
    @json_endpoint(url: "http://api.etherscan.io/api?module=account&action=txlist&address=%.*s&startblock=0&endblock=99999999&sort=asc&apikey=%.*s"
                   params: {eth_address:string, api_key: string})
    Etherscan_TXListForAddress:
    {
    }");

Output
    Dqn_String Etherscan_TXListForAddressURL(Dqn_ArenaAllocator *arena, Dqn_String eth_address, Dqn_String api_key)
    {
        Dqn_String result = Dqn_String_InitArenaFmt(arena, "http://api.etherscan.io/api?module=account&action=txlist&address=%.*s&startblock=0&endblock=99999999&sort=asc&apikey=%.*s", DQN_STRING_FMT(eth_address), DQN_STRING_FMT(api_key));
        DQN_HARD_ASSERT(result.str);
        return result;
    }
*/
void Dqn_MD_GenerateJsonEndpointURLFunction(Dqn_MDCppFile *cpp, MD_Node *struct_node, bool header_file);
void Dqn_MD_GenerateJsonRPCPostDataFunction(Dqn_MDCppFile *cpp, MD_Node *root, MD_Node *struct_node, bool header_file);

void Dqn_MD_GeneratePrintFunction(Dqn_MDCppFile *cpp, MD_Node const *struct_node, bool header_file);

#if defined(DQN_MD_UNDEFINE_CRT_WARNING)
    #undef _CRT_SECURE_NO_WARNINGS
#endif
#endif // DQN_META_DESK_H

#if defined(DQN_META_DESK_IMPLEMENTATION)
// -----------------------------------------------------------------------------
// NOTE: Implementation
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
// NOTE: Implementation Defines
// -----------------------------------------------------------------------------
#if defined(__clang__)
    #pragma clang diagnostic ignored "-Wwritable-strings"
#endif

// -----------------------------------------------------------------------------
// NOTE: MetaDesk Defines
// -----------------------------------------------------------------------------
// NOTE: Warning! Order is important here, clang-cl on Windows defines _MSC_VER
#if defined(__clang__)
#elif defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable: 4244) // '=': conversion from 'MD_u64' to 'unsigned int', possible loss of data
    #pragma warning(disable: 4101) // 'consume': unreferenced local variable
#endif

#include "metadesk/source/md.c"

#if defined(__clang__)
#elif defined(_MSC_VER)
    #pragma warning(pop)
#endif

// -----------------------------------------------------------------------------
// NOTE: Dqn_MDCppFile Implementation
// -----------------------------------------------------------------------------
int Dqn_MDCppFile_SpacePerIndent(Dqn_MDCppFile *cpp)
{
    int result = cpp->space_per_indent == 0 ? 4 : cpp->space_per_indent;
    return result;
}

void Dqn_MDCppFile_LineBeginV(Dqn_MDCppFile *cpp, char const *fmt, va_list args)
{
    int spaces = cpp->indent * Dqn_MDCppFile_SpacePerIndent(cpp);
    fprintf(cpp->file, "%*s", spaces, "");
    vfprintf(cpp->file, fmt, args);
}

void Dqn_MDCppFile_LineBegin(Dqn_MDCppFile *cpp, char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    Dqn_MDCppFile_LineBeginV(cpp, fmt, args);
    va_end(args);
}

void Dqn_MDCppFile_LineEnd(Dqn_MDCppFile *cpp, char const *fmt, ...)
{
    if (fmt)
    {
        va_list args;
        va_start(args, fmt);
        vfprintf(cpp->file, fmt, args);
        va_end(args);
    }

    fputc('\n', cpp->file);
}

void Dqn_MDCppFile_LineAdd(Dqn_MDCppFile *cpp, char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    vfprintf(cpp->file, fmt, args);
    va_end(args);
}

void Dqn_MDCppFile_LineV(Dqn_MDCppFile *cpp, char const *fmt, va_list args)
{
    Dqn_MDCppFile_LineBeginV(cpp, fmt, args);
    Dqn_MDCppFile_LineEnd(cpp, nullptr);
}

void Dqn_MDCppFile_Line(Dqn_MDCppFile *cpp, char const *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    Dqn_MDCppFile_LineBeginV(cpp, fmt, args);
    Dqn_MDCppFile_LineEnd(cpp, nullptr);
    va_end(args);
}

void Dqn_MDCppFile_NewLine(Dqn_MDCppFile *cpp)
{
    fputc('\n', cpp->file);
}

void Dqn_MDCppFile_Indent(Dqn_MDCppFile *cpp)
{
    cpp->indent++;
}

void Dqn_MDCppFile_Unindent(Dqn_MDCppFile *cpp)
{
    cpp->indent--;
    MD_Assert(cpp->indent >= 0);
}

void Dqn_MDCppFile_BeginBlock(Dqn_MDCppFile *cpp, char const *fmt, ...)
{
    if (fmt)
    {
        va_list args;
        va_start(args, fmt);
        Dqn_MDCppFile_LineV(cpp, fmt, args);
        va_end(args);
    }

    Dqn_MDCppFile_Line(cpp, "{");
    Dqn_MDCppFile_Indent(cpp);
}

void Dqn_MDCppFile_EndBlock(Dqn_MDCppFile *cpp, bool trailing_semicolon, bool new_line_on_next_block)
{
    Dqn_MDCppFile_Unindent(cpp);
    Dqn_MDCppFile_Line(cpp, trailing_semicolon ? "};" : "}");
    if (new_line_on_next_block) fputc('\n', cpp->file);
}

// -----------------------------------------------------------------------------
// MD Helpers
// -----------------------------------------------------------------------------
static bool Dqn_MD__NodeHasArrayNotation(MD_Node const *node)
{
    unsigned node_brackets = MD_NodeFlag_HasBracketLeft | MD_NodeFlag_HasBracketRight;
    bool     result        = (node->flags & node_brackets) == node_brackets;
    return result;
}

// -----------------------------------------------------------------------------
// Code
// -----------------------------------------------------------------------------
void Dqn_MD_CodeGen(char const *file_path, char const *output_name, unsigned int flags)
{
    MD_String8 h_file_name   = MD_S8Fmt("%s.h", output_name);
    MD_String8 cpp_file_name = MD_S8Fmt("%s.cpp", output_name);

    Dqn_MDCppFile cpp    = {};
    Dqn_MDCppFile header = {};
    cpp.file             = fopen(DQN_MD_CAST(char const *)cpp_file_name.str, "w+b");
    header.file          = fopen(DQN_MD_CAST(char const *)h_file_name.str, "w+b");

    fprintf(stdout, "Generating meta file from %s to %.*s and %.*s\n", file_path, MD_S8VArg(cpp_file_name), MD_S8VArg(h_file_name));

    if (cpp.file && header.file)
    {
        MD_ParseResult parse = MD_ParseWholeFile(MD_S8CString(DQN_MD_CAST(char *)file_path));
        if (flags & Dqn_MD_CodeGenFlag_CEnum)
            Dqn_MD_GenerateCEnum(&header, &parse, MD_S8Lit("json_endpoint"), "INS_QueryType");

        for (MD_EachNode(struct_node, parse.node->first_child))
        {
            if (flags & Dqn_MD_CodeGenFlag_CppStruct)
                Dqn_MD_GenerateCppStruct(&header, struct_node);

            if (flags & Dqn_MD_CodeGenFlag_ImGuiFunction)
                Dqn_MD_GenerateImGuiFunction(&header, struct_node, true /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_JsonParsingFunction)
                Dqn_MD_GenerateJsonParsingFunction(&header, struct_node, true /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_CurlQueryFunction)
                Dqn_MD_GenerateCurlQueryFunction(&header, struct_node, true /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_JsonEndpointURLFunction)
                Dqn_MD_GenerateJsonEndpointURLFunction(&header, struct_node, true /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_JsonRPCPostDataFunction)
                Dqn_MD_GenerateJsonRPCPostDataFunction(&header, parse.node, struct_node, true /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_PrintFunction)
                Dqn_MD_GeneratePrintFunction(&header, struct_node, true /*header_file*/);

            Dqn_MDCppFile_NewLine(&header);

            if (flags & Dqn_MD_CodeGenFlag_ImGuiFunction)
                Dqn_MD_GenerateImGuiFunction(&cpp, struct_node, false /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_JsonParsingFunction)
                Dqn_MD_GenerateJsonParsingFunction(&cpp, struct_node, false /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_CurlQueryFunction)
                Dqn_MD_GenerateCurlQueryFunction(&cpp, struct_node, false /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_JsonEndpointURLFunction)
                Dqn_MD_GenerateJsonEndpointURLFunction(&cpp, struct_node, false /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_JsonRPCPostDataFunction)
                Dqn_MD_GenerateJsonRPCPostDataFunction(&cpp, parse.node, struct_node, false /*header_file*/);

            if (flags & Dqn_MD_CodeGenFlag_PrintFunction)
                Dqn_MD_GeneratePrintFunction(&cpp, struct_node, false /*header_file*/);
        }
    }

    if (cpp.file) fclose(cpp.file);
    if (header.file) fclose(header.file);
}

MD_String8 Dqn_MD__ConvertTypeToCppType(MD_String8 type)
{
    MD_String8 result = type;
    if      (MD_S8Match(type, MD_S8Lit("u8"), 0))     { result = MD_S8Lit("Dqn_u8"); }
    else if (MD_S8Match(type, MD_S8Lit("u16"), 0))    { result = MD_S8Lit("Dqn_u16"); }
    else if (MD_S8Match(type, MD_S8Lit("u32"), 0))    { result = MD_S8Lit("Dqn_u32"); }
    else if (MD_S8Match(type, MD_S8Lit("u64"), 0))    { result = MD_S8Lit("Dqn_u64"); }
    else if (MD_S8Match(type, MD_S8Lit("u128"), 0))   { result = MD_S8Lit("intx::uint128"); }
    else if (MD_S8Match(type, MD_S8Lit("i8"), 0))     { result = MD_S8Lit("Dqn_i8"); }
    else if (MD_S8Match(type, MD_S8Lit("i16"), 0))    { result = MD_S8Lit("Dqn_i16"); }
    else if (MD_S8Match(type, MD_S8Lit("i32"), 0))    { result = MD_S8Lit("Dqn_i32"); }
    else if (MD_S8Match(type, MD_S8Lit("i64"), 0))    { result = MD_S8Lit("Dqn_i64"); }
    else if (MD_S8Match(type, MD_S8Lit("f32"), 0))    { result = MD_S8Lit("Dqn_f32"); }
    else if (MD_S8Match(type, MD_S8Lit("f64"), 0))    { result = MD_S8Lit("Dqn_f64"); }
    else if (MD_S8Match(type, MD_S8Lit("string"), 0)) { result = MD_S8Lit("Dqn_String"); }
    else if (MD_S8Match(type, MD_S8Lit("bool"), 0))   { result = MD_S8Lit("Dqn_b32"); }
    return result;
}

bool Dqn_MD__IsTypeCppPrimitive(MD_String8 type)
{
    MD_String8 cpp_type = Dqn_MD__ConvertTypeToCppType(type);
    bool result = !MD_S8Match(cpp_type, type, 0);
    // TODO(doyle): We weren't able to convert the type to our Dqn_* type/custom
    // type, we assume that this is a custom CPP type we don't ordinarily
    // recognize.
    return result;
}

bool Dqn_MD__TypeIsUnsignedInt(MD_String8 type)
{
    bool result = MD_S8Match(type, MD_S8Lit("u8"), 0) ||
                  MD_S8Match(type, MD_S8Lit("u16"), 0) ||
                  MD_S8Match(type, MD_S8Lit("u32"), 0) ||
                  MD_S8Match(type, MD_S8Lit("u64"), 0) ||
                  MD_S8Match(type, MD_S8Lit("u128"), 0);
    return result;
}

bool Dqn_MD__TypeIsSignedInt(MD_String8 type)
{
    bool result = MD_S8Match(type, MD_S8Lit("i8"), 0) ||
                  MD_S8Match(type, MD_S8Lit("i16"), 0) ||
                  MD_S8Match(type, MD_S8Lit("i32"), 0) ||
                  MD_S8Match(type, MD_S8Lit("i64"), 0) ||
                  MD_S8Match(type, MD_S8Lit("i128"), 0);
    return result;
}

MD_String8 Dqn_MD__ConvertTypeToFmtString(MD_String8 type)
{
    MD_String8 result = type;
    if      (MD_S8Match(type, MD_S8Lit("u8"), 0))     { result = MD_S8Lit("%I64u"); }
    else if (MD_S8Match(type, MD_S8Lit("u16"), 0))    { result = MD_S8Lit("%I64u"); }
    else if (MD_S8Match(type, MD_S8Lit("u32"), 0))    { result = MD_S8Lit("%I64u"); }
    else if (MD_S8Match(type, MD_S8Lit("u64"), 0))    { result = MD_S8Lit("%I64u"); }
    else if (MD_S8Match(type, MD_S8Lit("i8"), 0))     { result = MD_S8Lit("%I64d"); }
    else if (MD_S8Match(type, MD_S8Lit("i16"), 0))    { result = MD_S8Lit("%I64d"); }
    else if (MD_S8Match(type, MD_S8Lit("i32"), 0))    { result = MD_S8Lit("%I64d"); }
    else if (MD_S8Match(type, MD_S8Lit("i64"), 0))    { result = MD_S8Lit("%I64d"); }
    else if (MD_S8Match(type, MD_S8Lit("f32"), 0))    { result = MD_S8Lit("%f"); }
    else if (MD_S8Match(type, MD_S8Lit("f64"), 0))    { result = MD_S8Lit("%f"); }
    else if (MD_S8Match(type, MD_S8Lit("string"), 0)) { result = MD_S8Lit("%.*s"); }
    else if (MD_S8Match(type, MD_S8Lit("bool"), 0))   { result = MD_S8Lit("%s"); }
    return result;
}

void Dqn_MD_GenerateCppStruct(Dqn_MDCppFile *cpp, MD_Node const *struct_node)
{
    if (!MD_NodeHasTag(DQN_MD_CAST(MD_Node *)struct_node, MD_S8Lit("cpp_struct"), DQN_MD_CAST(MD_MatchFlags)0))
        return;

    Dqn_MDCppFile_BeginBlock(cpp, "struct %.*s", MD_S8VArg(struct_node->string));
    for (MD_EachNode(field, struct_node->first_child))
    {
        MD_Node *type_node = MD_NodeFromString(field->first_child, field->last_child + 1, MD_S8Lit("type"), (MD_MatchFlags)0);
        MD_String8 type    = type_node->first_child->string;
        MD_Assert(!MD_NodeIsNil(type_node));

        MD_String8 cpp_type = Dqn_MD__ConvertTypeToCppType(type);
        bool const is_array = Dqn_MD__NodeHasArrayNotation(type_node->first_child->next);
        if (is_array)
        {
            Dqn_MDCppFile_Line(cpp, "Dqn_Array<%.*s> %.*s;", MD_S8VArg(cpp_type), MD_S8VArg(field->string));
        }
        else
        {
            Dqn_MDCppFile_Line(cpp, "%.*s %.*s;", MD_S8VArg(cpp_type), MD_S8VArg(field->string));
        }
    }
    Dqn_MDCppFile_EndStructBlock(cpp);
}

void Dqn_MD_GenerateCEnum(Dqn_MDCppFile *cpp, MD_ParseResult *parse, MD_String8 required_tag, char const *name)
{
    Dqn_MDCppFile_BeginBlock(cpp, "enum %s", name);
    for (MD_EachNode(struct_node, parse->node->first_child))
    {
        if (MD_NodeHasTag(struct_node, required_tag, DQN_MD_CAST(MD_MatchFlags)0))
            Dqn_MDCppFile_Line(cpp, "%s_%.*s,", name, MD_S8VArg(struct_node->string));
    }
    Dqn_MDCppFile_Line(cpp, "%s_Count", name);
    Dqn_MDCppFile_EndEnumBlock(cpp);
}

void Dqn_MD_GeneratePrintFunction(Dqn_MDCppFile *cpp, MD_Node const *struct_node, bool header_file)
{
    if (!MD_NodeHasTag(DQN_MD_CAST(MD_Node *)struct_node, MD_S8Lit("cpp_struct"), DQN_MD_CAST(MD_MatchFlags)0) ||
        !MD_NodeHasTag(DQN_MD_CAST(MD_Node *)struct_node, MD_S8Lit("cpp_print"), DQN_MD_CAST(MD_MatchFlags)0))
    {
        return;
    }

    const MD_String8 VAL_STR = MD_S8Lit("val");
    Dqn_MDCppFile_LineBegin(cpp,
                            "void %.*sPrint(FILE *file, %.*s const *%.*s",
                            MD_S8VArg(struct_node->string),
                            MD_S8VArg(struct_node->string),
                            MD_S8VArg(VAL_STR));

    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ");");
        return;
    }

    Dqn_MDCppFile_LineEnd(cpp, ")");
    Dqn_MDCppFile_BeginBlock(cpp, nullptr);
    for (MD_EachNode(field_node, struct_node->first_child))
    {
        MD_Node *type_node = MD_NodeFromString(field_node->first_child, field_node->last_child + 1, MD_S8Lit("type"), (MD_MatchFlags)0);
        MD_String8 type    = type_node->first_child->string;
        MD_String8 field   = field_node->string;
        MD_Assert(!MD_NodeIsNil(type_node));

        MD_String8 cpp_type = Dqn_MD__ConvertTypeToCppType(type);
        bool is_array = Dqn_MD__NodeHasArrayNotation(type_node->first_child->next);
        MD_String8 param = VAL_STR;
        MD_String8 variable_to_print = is_array ? MD_S8Lit("it") : MD_S8Fmt("%.*s->%.*s", MD_S8VArg(param), MD_S8VArg(field));
        if (is_array)
            Dqn_MDCppFile_BeginBlock(cpp, "for (%.*s const &it : %.*s->%.*s)", MD_S8VArg(cpp_type), MD_S8VArg(param), MD_S8VArg(field));

        if      (MD_S8Match(type, MD_S8Lit("u8"), 0))     Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%u\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u16"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%u\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u32"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%u\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u64"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%zu\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u128"), 0))   Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%.*s\n", Dqn_U128_String(%.*s, true /*separate*/, ','));)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i8"), 0))     Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%d\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i16"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%d\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i32"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%d\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i64"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%zd\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("f32"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%f\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("f64"), 0))    Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%f\n", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("string"), 0)) Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%.*s\n", DQN_STRING_FMT(%.*s));)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("bool"), 0))   Dqn_MDCppFile_Line(cpp, R"(fprintf(file, "%.*s: %%s\n", %.*s ? "true" : "false");)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else                                              Dqn_MDCppFile_Line(cpp, R"(%.*sPrint(file, &%.*s);)", MD_S8VArg(type), MD_S8VArg(variable_to_print));

        if (is_array)
            Dqn_MDCppFile_EndForBlock(cpp);

    }
    Dqn_MDCppFile_EndFuncBlock(cpp);
}

void Dqn_MD_GenerateImGuiFunction(Dqn_MDCppFile *cpp, MD_Node const *struct_node, bool header_file)
{
    const MD_String8 VAL_STR = MD_S8Lit("val");
    Dqn_MDCppFile_LineBegin(cpp,
                            "void %.*sImGui(%.*s const *%.*s)",
                            MD_S8VArg(struct_node->string),
                            MD_S8VArg(struct_node->string),
                            MD_S8VArg(VAL_STR));

    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ";");
        return;
    }

    Dqn_MDCppFile_BeginBlock(cpp, nullptr);
    for (MD_EachNode(field_node, struct_node->first_child))
    {
        MD_Node *type_node = MD_NodeFromString(field_node->first_child, field_node->last_child + 1, MD_S8Lit("type"), (MD_MatchFlags)0);
        MD_String8 type    = type_node->first_child->string;
        MD_String8 field   = field_node->string;
        MD_Assert(!MD_NodeIsNil(type_node));

        MD_String8 cpp_type = Dqn_MD__ConvertTypeToCppType(type);
        bool is_array = Dqn_MD__NodeHasArrayNotation(type_node->first_child->next);
        MD_String8 param = VAL_STR;
        MD_String8 variable_to_print = is_array ? MD_S8Lit("it") : MD_S8Fmt("%.*s->%.*s", MD_S8VArg(param), MD_S8VArg(field));
        if (is_array)
            Dqn_MDCppFile_BeginBlock(cpp, "for (%.*s const &it : %.*s->%.*s)", MD_S8VArg(cpp_type), MD_S8VArg(param), MD_S8VArg(field));

        if      (MD_S8Match(type, MD_S8Lit("u8"), 0))     Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64u", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u16"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64u", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u32"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64u", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u64"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64u", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("u128"), 0))   Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64u", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i8"), 0))     Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64d", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i16"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64d", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i32"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64d", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("i64"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%I64d", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("f32"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%f", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("f64"), 0))    Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%f", %.*s);)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("string"), 0)) Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%.*s", DQN_STRING_FMT(%.*s));)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else if (MD_S8Match(type, MD_S8Lit("bool"), 0))   Dqn_MDCppFile_Line(cpp, R"(ImGui::Text("%.*s: %%s", %.*s ? "true" : "false");)", MD_S8VArg(field), MD_S8VArg(variable_to_print));
        else                                              Dqn_MDCppFile_Line(cpp, R"(%.*sImGui(&%.*s);)", MD_S8VArg(type), MD_S8VArg(variable_to_print));

        if (is_array)
            Dqn_MDCppFile_EndForBlock(cpp);
    }
    Dqn_MDCppFile_EndFuncBlock(cpp);
}

void Dqn_MD__CppCodeGenDeserializeJSONPrimitiveToken(Dqn_MDCppFile *cpp,
                                                     MD_Node *json_type_node,
                                                     MD_Node *type_node,
                                                     MD_String8 field,
                                                     MD_String8 dest,
                                                     MD_String8 json_value_variable_name)
{
    // NOTE: This function is a little bit more complicated than it'd like to be
    // because we support the JSON specifiying a different type than the native
    // storage stype (i.e. the json could specify a number as a json string i.e.
    // "100" but our CPP struct wants a primitive integer.
    //
    // So we handle that and do that conversion step here.

    // -------------------------------------------------------------------------
    // Determine the source type we're converting from
    // -------------------------------------------------------------------------
    MD_String8 json_type = json_type_node->first_child->string;
    MD_String8 type = type_node->first_child->string;
    enum JsonPrimitive
    {
        Number,
        String,
        Object,
        Bool,
        Array,
    };

    JsonPrimitive json_primitive = {};
    if (MD_S8Match(json_type, MD_S8Lit("number"), (MD_MatchFlags)0))
    {
        json_primitive = JsonPrimitive::Number;
        Dqn_MDCppFile_BeginBlock(cpp, "if (Dqn_JsmnToken_ExpectNumber(json, *%.*s, err_handle))", MD_S8VArg(json_value_variable_name));
    }
    else if (MD_S8Match(json_type, MD_S8Lit("string"), (MD_MatchFlags)0))
    {
        json_primitive = JsonPrimitive::String;
        Dqn_MDCppFile_BeginBlock(cpp, "if (Dqn_JsmnToken_ExpectString(*%.*s, err_handle))", MD_S8VArg(json_value_variable_name));
    }
    else if (MD_S8Match(json_type, MD_S8Lit("bool"), (MD_MatchFlags)0))
    {
        json_primitive = JsonPrimitive::Bool;
        Dqn_MDCppFile_BeginBlock(cpp, "if (Dqn_JsmnToken_ExpectBool(json, *%.*s, err_handle))", MD_S8VArg(json_value_variable_name));
    }
    else if (MD_S8Match(json_type, MD_S8Lit("array"), (MD_MatchFlags)0))
    {
        json_primitive = JsonPrimitive::Array;
        Dqn_MDCppFile_BeginBlock(cpp, "if (Dqn_JsmnToken_ExpectArray(*%.*s, err_handle))", MD_S8VArg(json_value_variable_name));
    }
    else if (MD_S8Match(json_type, MD_S8Lit("object"), (MD_MatchFlags)0))
    {
        json_primitive = JsonPrimitive::Object;
        Dqn_MDCppFile_BeginBlock(cpp, "if (Dqn_JsmnToken_ExpectObject(*%.*s, err_handle))", MD_S8VArg(json_value_variable_name));
    }
    else
        DQN_MD_INVALID_CODE_PATH_MSG("Unhandled json type: '%.*s'. Expected 'array', 'number', 'string' or 'object'", MD_S8VArg(json_type));

    // -------------------------------------------------------------------------
    // Convert the JSON token to our CPP struct's expecting type
    // -------------------------------------------------------------------------
    if (json_primitive == JsonPrimitive::Array)
    {
        MD_String8 cpp_type    = Dqn_MD__ConvertTypeToCppType(type);
        bool const custom_type = MD_S8Match(cpp_type, type, DQN_MD_CAST(MD_MatchFlags)0); // Type was not recognised, i.e we didn't convert it

        Dqn_MDCppFile_Line(cpp, R"(%.*s = Dqn_Array_InitWithArenaNoGrow(arena, %.*s, value->size, 0, Dqn_ZeroMem::Yes);)", MD_S8VArg(dest), MD_S8VArg(cpp_type));
        Dqn_MDCppFile_BeginBlock(cpp, "for (int array_index = 0; array_index < value->size; array_index++)");
        Dqn_MDCppFile_Line(cpp,
                           R"(auto *%.*s_entry = Dqn_Array_Make(&%.*s, 1);)",
                           MD_S8VArg(field),
                           MD_S8VArg(dest));
        if (custom_type)
        {
            Dqn_MDCppFile_Line(cpp,
                               R"(*%.*s_entry = %.*sParseTokens(&it, err_handle, json, arena);)",
                               MD_S8VArg(field),
                               MD_S8VArg(type));
        }
        else
        {
            Dqn_MDCppFile_Line(cpp, "jsmntok_t *sub_value     = it++;");
            Dqn_MDCppFile_Line(cpp, "Dqn_String sub_value_str = Dqn_JsmnToken_String(json, *sub_value); (void)sub_value_str;");

            MD_String8 dest = MD_S8Fmt("*%.*s_entry", MD_S8VArg(field));
            Dqn_MD__CppCodeGenDeserializeJSONPrimitiveToken(cpp, type_node, type_node, field, dest, MD_S8Lit("sub_value"));
        }
        Dqn_MDCppFile_EndForBlock(cpp);
    }
    else if (json_primitive == JsonPrimitive::Object)
    {
        Dqn_MDCppFile_BeginBlock(cpp, "if (Dqn_JsmnToken_ExpectObject(*%.*s, err_handle))", MD_S8VArg(json_value_variable_name));
        Dqn_MDCppFile_Line(cpp, "it = %.*s; // Rewind the iterator to the object", MD_S8VArg(json_value_variable_name));
        Dqn_MDCppFile_Line(cpp, "%.*s = %.*sParseTokens(&it, err_handle, json, arena);", MD_S8VArg(dest), MD_S8VArg(type));
        Dqn_MDCppFile_EndIfBlock(cpp);
    }
    else
    {
        if (MD_S8Match(type, MD_S8Lit("f32"),  (MD_MatchFlags)0))
        {
            DQN_MD_ASSERT_MSG(json_primitive == JsonPrimitive::String || json_primitive == JsonPrimitive::Number, "Implement the other part");
            Dqn_MDCppFile_Line(cpp, "%.*s = DQN_CAST(Dqn_f32)atof(%.*s_str.str);", MD_S8VArg(dest), MD_S8VArg(json_value_variable_name));
        }
        else if (MD_S8Match(type, MD_S8Lit("f64"),  (MD_MatchFlags)0))
        {
            DQN_MD_ASSERT_MSG(json_primitive == JsonPrimitive::String || json_primitive == JsonPrimitive::Number, "Implement the other part");
            Dqn_MDCppFile_Line(cpp, "%.*s = atof(%.*s_str.str);", MD_S8VArg(dest), MD_S8VArg(json_value_variable_name));
        }
        else if (MD_S8Match(type, MD_S8Lit("u8"),  (MD_MatchFlags)0) ||
                 MD_S8Match(type, MD_S8Lit("u16"), (MD_MatchFlags)0) ||
                 MD_S8Match(type, MD_S8Lit("u32"), (MD_MatchFlags)0) ||
                 MD_S8Match(type, MD_S8Lit("u64"), (MD_MatchFlags)0))
        {
            DQN_MD_ASSERT_MSG(json_primitive == JsonPrimitive::String || json_primitive == JsonPrimitive::Number, "Implement the other part");
            if (MD_S8Match(type, MD_S8Lit("u64"), (MD_MatchFlags)0))
            {
                if (MD_NodeHasTag(json_type_node->first_child, MD_S8Lit("hex"), (MD_MatchFlags)0))
                {
                    Dqn_MDCppFile_Line(
                        cpp,
                        R"(%.*s = Dqn_Hex_StringToU64(%.*s_str);)",
                        MD_S8VArg(dest), MD_S8VArg(json_value_variable_name));
                }
                else
                {
                    Dqn_MDCppFile_Line(
                        cpp,
                        R"(%.*s = Dqn_String_ToU64(%.*s_str);)",
                        MD_S8VArg(dest), MD_S8VArg(json_value_variable_name));
                }
            }
            else
            {
                // We need to truncate the deserialized type to write it
                // to our struct.

                // NOTE: This bit capitalises the types, i.e. turns u16
                // -> U16, which matches our function naming convention
                // for Dqn_Safe_TruncateU64To<Type> and co.
                char type_all_caps[4] = {};
                memcpy(type_all_caps, type.str, type.size);
                type_all_caps[0] = MD_CharToUpper(type_all_caps[0]);

                Dqn_MDCppFile_Line(
                    cpp,
                    R"(%.*s = Dqn_Safe_TruncateU64To%s(Dqn_String_ToU64(%.*s_str));)",
                    MD_S8VArg(dest),
                    type_all_caps,
                    MD_S8VArg(json_value_variable_name));
            }
        }
        else if (MD_S8Match(type, MD_S8Lit("u128"), 0))
        {
            DQN_MD_ASSERT_MSG(json_primitive == JsonPrimitive::String || json_primitive == JsonPrimitive::Number, "Implement the other part");
            Dqn_MDCppFile_Line(
                cpp,
                R"(%.*s = Dqn_U128_FromString(%.*s_str.str, Dqn_Safe_TruncateU64ToInt(%.*s_str.size));)",
                MD_S8VArg(dest),
                MD_S8VArg(json_value_variable_name),
                MD_S8VArg(json_value_variable_name));
        }
        else if (MD_S8Match(type, MD_S8Lit("i8"), 0) ||
                 MD_S8Match(type, MD_S8Lit("i16"), 0) ||
                 MD_S8Match(type, MD_S8Lit("i32"), 0) ||
                 MD_S8Match(type, MD_S8Lit("i64"), 0))
        {
            DQN_MD_ASSERT_MSG(json_primitive == JsonPrimitive::String || json_primitive == JsonPrimitive::Number, "Implement the other part");
            char type_all_caps[4] = {};
            memcpy(type_all_caps, type.str, type.size);
            type_all_caps[0] = MD_CharToUpper(type_all_caps[0]);

            Dqn_MDCppFile_Line(
                cpp,
                R"(%.*s = Dqn_Safe_TruncateU64To%s(Dqn_String_ToU64(%.*s_str));)",
                MD_S8VArg(dest),
                type_all_caps,
                MD_S8VArg(json_value_variable_name)
                );
        }
        else if (MD_S8Match(type, MD_S8Lit("string"), 0))
        {
            DQN_MD_ASSERT_MSG(json_primitive == JsonPrimitive::String, "Implement the other part");
            Dqn_MDCppFile_Line(
                cpp,
                R"(%.*s = Dqn_String_Copy(%.*s_str, arena);)",
                MD_S8VArg(dest),
                MD_S8VArg(json_value_variable_name));
        }
        else if (MD_S8Match(type, MD_S8Lit("bool"), 0))
        {
            if (json_primitive == JsonPrimitive::Bool)
            {
                Dqn_MDCppFile_Line(
                    cpp,
                    R"(%.*s = Dqn_JsmnToken_Bool(json, *%.*s);)",
                    MD_S8VArg(dest),
                    MD_S8VArg(json_value_variable_name));
            }
            else if (json_primitive == JsonPrimitive::Number)
            {
                Dqn_MDCppFile_Line(
                    cpp,
                    R"(%.*s = DQN_CAST(Dqn_b32)Dqn_String_ToU64(%.*s_str);)",
                    MD_S8VArg(dest),
                    MD_S8VArg(json_value_variable_name));
            }
            else
            {
                DQN_MD_INVALID_CODE_PATH_MSG("Unhandled");
            }
        }
        else
        {
            // NOTE: Unhandled 'json_type' specified in the .mdesk file
            DQN_MD_INVALID_CODE_PATH;
        }
    }

    Dqn_MDCppFile_EndIfBlock(cpp);
}

void Dqn_MD_GenerateJsonParsingFunction(Dqn_MDCppFile *cpp, MD_Node const *struct_node, bool header_file)
{
    MD_Node *tag = MD_NodeFromString(struct_node->first_tag, struct_node->last_tag + 1, MD_S8Lit("json_parsing_function"), (MD_MatchFlags)0);
    if (MD_NodeIsNil(tag))
        return;

    bool return_array_type = false;
    MD_String8 return_type = struct_node->string;

    MD_Node *struct_type_node      = MD_NodeFromString(struct_node->first_child, struct_node->last_child + 1, MD_S8Lit("type"), (MD_MatchFlags)0);
    MD_Node *struct_json_type_node = MD_NodeFromString(struct_node->first_child, struct_node->last_child + 1, MD_S8Lit("json_type"), (MD_MatchFlags)0);
    if (MD_NodeIsNil(struct_type_node) && MD_NodeIsNil(struct_json_type_node))
    {
    }
    else
    {
        return_array_type = true;
        return_type = MD_S8Fmt("Dqn_Array<%.*s>", MD_S8VArg(struct_type_node->first_child->string));
    }

    // -------------------------------------------------------------------------
    // Write json helper parsing function
    // -------------------------------------------------------------------------
    Dqn_MDCppFile_LineBegin(cpp, "%.*s %.*sParse(Dqn_String json, Dqn_JsmnErrorHandle *err_handle, Dqn_ArenaAllocator *temp_arena, Dqn_ArenaAllocator *arena", MD_S8VArg(return_type), MD_S8VArg(struct_node->string));
    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ");");
    }
    else
    {
        Dqn_MDCppFile_LineEnd(cpp, ")");
        Dqn_MDCppFile_BeginBlock(cpp, nullptr);
        Dqn_MDCppFile_Line(cpp, "(void)arena; // TODO(dqn): We don't always need an Arena, but we always have it in the prototype to make life easy if somewhere deep in the json heirarchy we need an arena");
        Dqn_MDCppFile_Line(cpp, "jsmn_parser parser = {};");
        Dqn_MDCppFile_Line(cpp, "jsmn_init(&parser);");
        Dqn_MDCppFile_NewLine(cpp);
        Dqn_MDCppFile_Line(cpp, "int tokens_required = jsmn_parse(&parser, json.str, json.size, nullptr, 0);");
        Dqn_MDCppFile_Line(cpp, "DQN_HARD_ASSERT(tokens_required > 0);");
        Dqn_MDCppFile_Line(cpp, "auto *tokens = Dqn_ArenaAllocator_NewArray(temp_arena, jsmntok_t, tokens_required, Dqn_ZeroMem::No);");
        Dqn_MDCppFile_NewLine(cpp);
        Dqn_MDCppFile_Line(cpp, "jsmn_init(&parser);");
        Dqn_MDCppFile_Line(cpp, "jsmn_parse(&parser, json.str, json.size, tokens, tokens_required);");
        Dqn_MDCppFile_Line(cpp, "jsmntok_t *it = tokens + 0;");
        Dqn_MDCppFile_NewLine(cpp);
        Dqn_MDCppFile_Line(cpp, "%.*s result = %.*sParseTokens(&it, err_handle, json, arena);", MD_S8VArg(return_type), MD_S8VArg(struct_node->string));
        Dqn_MDCppFile_Line(cpp, "return result;");
        Dqn_MDCppFile_EndFuncBlock(cpp);
    }

    // -------------------------------------------------------------------------
    // Write the main work horse code
    // -------------------------------------------------------------------------
    Dqn_MDCppFile_LineBegin(cpp, "%.*s %.*sParseTokens(jsmntok_t **start_it, Dqn_JsmnErrorHandle *err_handle, Dqn_String json, Dqn_ArenaAllocator *arena", MD_S8VArg(return_type), MD_S8VArg(struct_node->string));
    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ");");
        return;
    }

    Dqn_MDCppFile_LineEnd(cpp, ")");
    Dqn_MDCppFile_BeginBlock(cpp, nullptr);
    Dqn_MDCppFile_Line(cpp, "(void)arena; // TODO(dqn): We don't always need an Arena, but we always have it in the prototype to make life easy if somewhere deep in the json heirarchy we need an arena");
    Dqn_MDCppFile_Line(cpp, "%.*s result = {};", MD_S8VArg(return_type));
    Dqn_MDCppFile_Line(cpp, "jsmntok_t *it = (*start_it);");

    if (return_array_type)
    {
        MD_String8 struct_type = struct_type_node->first_child->string;
        MD_String8 struct_json_type = struct_json_type_node->first_child->string;
        Dqn_MDCppFile_Line(cpp, "jsmntok_t *value = it++;");
        Dqn_MDCppFile_NewLine(cpp);
        Dqn_MD__CppCodeGenDeserializeJSONPrimitiveToken(cpp, struct_json_type_node, struct_type_node, MD_S8Lit("root"), MD_S8Lit("result"), MD_S8Lit("value"));
    }
    else
    {
        //----------------------------------------------------------------------
        // Convert the type's in our .mdesk struct into JSON parsing code
        //----------------------------------------------------------------------
        Dqn_MDCppFile_Line(cpp, "if (!Dqn_JsmnToken_ExpectObject(*it, err_handle)) return result;");
        Dqn_MDCppFile_Line(cpp, "jsmntok_t *object = it++;");
        Dqn_MDCppFile_NewLine(cpp);
        Dqn_MDCppFile_BeginBlock(cpp, "for (int index = 0; index < object->size; index++)");
        Dqn_MDCppFile_Line(cpp, "jsmntok_t *key       = it++;");
        Dqn_MDCppFile_Line(cpp, "jsmntok_t *value     = it++;");
        Dqn_MDCppFile_Line(cpp, "Dqn_String key_str   = Dqn_JsmnToken_String(json, *key);");
        Dqn_MDCppFile_Line(cpp, "Dqn_String value_str = Dqn_JsmnToken_String(json, *value); (void)value_str;");
        Dqn_MDCppFile_NewLine(cpp);

        MD_String8 const IF_BRANCH      = MD_S8Lit("if");
        MD_String8 const ELSE_IF_BRANCH = MD_S8Lit("else if");
        MD_String8       branch_str     = IF_BRANCH;
        for (MD_EachNode(field_node, struct_node->first_child))
        {
            MD_Node *type_node      = MD_NodeFromString(field_node->first_child, field_node->last_child + 1, MD_S8Lit("type"), (MD_MatchFlags)0);
            MD_Node *json_type_node = MD_NodeFromString(field_node->first_child, field_node->last_child + 1, MD_S8Lit("json_type"), (MD_MatchFlags)0);
            MD_Node *json_key_node  = MD_NodeFromString(field_node->first_child, field_node->last_child + 1, MD_S8Lit("json_key"), (MD_MatchFlags)0);

            MD_String8 field     = field_node->string;
            MD_String8 type      = type_node->first_child->string;
            MD_String8 json_type = json_type_node->first_child->string;
            MD_String8 json_key  = MD_NodeIsNil(json_key_node) ? field : json_key_node->first_child->string;
            MD_Assert(!MD_NodeIsNil(type_node));

            Dqn_MDCppFile_BeginBlock(
                cpp, "%.*s (key_str == DQN_STRING(\"%.*s\"))", MD_S8VArg(branch_str), MD_S8VArg(json_key));
            branch_str = ELSE_IF_BRANCH;
            MD_String8 dest = MD_S8Fmt("result.%.*s", MD_S8VArg(field));
            Dqn_MD__CppCodeGenDeserializeJSONPrimitiveToken(cpp, json_type_node, type_node, field, dest, MD_S8Lit("value"));
            Dqn_MDCppFile_EndIfBlock(cpp);
        }

        if (struct_node->first_child)
        {
            Dqn_MDCppFile_BeginBlock(cpp, "else");
            Dqn_MDCppFile_Line      (cpp, "// Potential unhandled json object and value, advance the iterator accordingly");
            Dqn_MDCppFile_Line      (cpp, "DQN_ASSERT(key->type == JSMN_STRING);");
            Dqn_MDCppFile_BeginBlock(cpp, "if (value->type == JSMN_OBJECT)");
            Dqn_MDCppFile_Line      (cpp,    "it = Dqn_JsmnToken_AdvanceItPastObject(value, err_handle, json);");
            Dqn_MDCppFile_EndIfBlock(cpp);
            Dqn_MDCppFile_BeginBlock(cpp, "else if (value->type == JSMN_ARRAY)");
            Dqn_MDCppFile_Line      (cpp,    "it = Dqn_JsmnToken_AdvanceItPastArray(value, err_handle, json);");
            Dqn_MDCppFile_EndIfBlock(cpp);
            Dqn_MDCppFile_EndIfBlock(cpp);
        }
        Dqn_MDCppFile_EndForBlock(cpp);
    }

    Dqn_MDCppFile_NewLine(cpp);
    Dqn_MDCppFile_Line(cpp, "*start_it = it;");
    Dqn_MDCppFile_Line(cpp, "return result;");
    Dqn_MDCppFile_EndFuncBlock(cpp);
}

struct Dqn_MD__Variable
{
    MD_Node    *type_node;
    MD_String8  type;
    MD_Node    *name_node;
    MD_String8  name;
    MD_String8  cpp_type;
    bool        is_array;
};

void Dqn_MD__PrintVariableAsFunctionArgument(Dqn_MDCppFile *cpp, Dqn_MD__Variable *variable)
{
    if (variable->is_array)
        Dqn_MDCppFile_LineAdd(cpp, "%.*s const *%.*s, Dqn_isize %.*s_size", MD_S8VArg(variable->cpp_type), MD_S8VArg(variable->name), MD_S8VArg(variable->name));
    else
        Dqn_MDCppFile_LineAdd(cpp, "%.*s %.*s", MD_S8VArg(variable->cpp_type), MD_S8VArg(variable->name));
}

Dqn_MD__Variable Dqn_MD__VariableFromNode(MD_Node *node)
{
    Dqn_MD__Variable result = {};
    result.type_node        = MD_NodeFromString(node->first_child, node->last_child + 1, MD_S8Lit("type"), DQN_MD_CAST(MD_MatchFlags)0);
    result.name             = node->string;
    result.type             = result.type_node->first_child->string;
    result.is_array         = Dqn_MD__NodeHasArrayNotation(result.type_node->first_child->next);
    result.cpp_type         = Dqn_MD__ConvertTypeToCppType(result.type);
    return result;
}

void Dqn_MD_GenerateJsonEndpointURLFunction(Dqn_MDCppFile *cpp, MD_Node *struct_node, bool header_file)
{
    MD_Node *json_endpoint_node = MD_NodeFromString(struct_node->first_tag, struct_node->last_tag + 1, MD_S8Lit("json_endpoint"), (MD_MatchFlags)0);
    if (MD_NodeIsNil(json_endpoint_node))
        return;

    if (MD_NodeIsNil(json_endpoint_node->first_child))
    {
        DQN_MD_INVALID_CODE_PATH;
        return;
    }

    MD_Node *url_node    = MD_NodeFromString(json_endpoint_node->first_child, json_endpoint_node->last_child + 1, MD_S8Lit("url"), (MD_MatchFlags)0);
    MD_Node *params_node = MD_NodeFromString(json_endpoint_node->first_child, json_endpoint_node->last_child + 1, MD_S8Lit("params"), (MD_MatchFlags)0);
    MD_String8 url       = url_node->first_child->string;

    if (MD_NodeIsNil(url_node))
    {
        DQN_MD_INVALID_CODE_PATH;
        return;
    }

    bool const need_arena = (!MD_NodeIsNil(params_node->first_child));

    Dqn_MDCppFile_LineBegin(cpp, "Dqn_String %.*sURL(", MD_S8VArg(struct_node->string));
    if (need_arena)
    {
        Dqn_MDCppFile_LineBegin(cpp, "Dqn_ArenaAllocator *arena");
        if (!MD_NodeIsNil(params_node->first_child)) Dqn_MDCppFile_LineAdd(cpp, ", ");
        for (MD_EachNode(param_node, params_node->first_child))
        {
            MD_String8 name = param_node->string;
            MD_String8 type = param_node->first_child->string;
            MD_Assert(!MD_NodeIsNil(param_node->first_child));
            Dqn_MDCppFile_LineAdd(cpp, "%.*s %.*s", MD_S8VArg(Dqn_MD__ConvertTypeToCppType(type)), MD_S8VArg(name));
            if (!MD_NodeIsNil(param_node->next)) Dqn_MDCppFile_LineAdd(cpp, ", ");
        }
    }

    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ");");
        return;
    }

    Dqn_MDCppFile_LineEnd(cpp, ")");
    Dqn_MDCppFile_BeginBlock(cpp, nullptr);

    if (need_arena)
    {
        Dqn_MDCppFile_LineBegin(cpp, R"(Dqn_String result = Dqn_String_Fmt(arena, "%.*s")", MD_S8VArg(url));
        if (!MD_NodeIsNil(params_node->first_child)) Dqn_MDCppFile_LineAdd(cpp, ", ");
        for (MD_EachNode(param_node, params_node->first_child))
        {
            MD_String8 name = param_node->string;
            MD_String8 type = param_node->first_child->string;
            Dqn_MD__ConvertTypeToFmtString(type);
            if (MD_S8Match(type, MD_S8Lit("string"), 0))
                Dqn_MDCppFile_LineAdd(cpp, "DQN_STRING_FMT(%.*s)", MD_S8VArg(name));
            else
                Dqn_MDCppFile_LineAdd(cpp, "%.*s", MD_S8VArg(name));

            if (!MD_NodeIsNil(param_node->next)) Dqn_MDCppFile_LineAdd(cpp, ", ");
        }
        Dqn_MDCppFile_LineEnd(cpp, ");");
        Dqn_MDCppFile_Line(cpp, "DQN_HARD_ASSERT(result.str);");
        Dqn_MDCppFile_Line(cpp, "return result;");
    }
    else
    {
        Dqn_MDCppFile_Line(cpp, R"(return DQN_STRING("%.*s");)", MD_S8VArg(url));
    }
    Dqn_MDCppFile_EndFuncBlock(cpp);
}

void Dqn_MD_GenerateJsonRPCPostDataFunction(Dqn_MDCppFile *cpp, MD_Node *root, MD_Node *struct_node, bool header_file)
{
    MD_Node *tag = MD_NodeFromString(struct_node->first_tag, struct_node->last_tag + 1, MD_S8Lit("json_rpc_post_data"), (MD_MatchFlags)0);
    if (MD_NodeIsNil(tag))
        return;

    MD_Node *jsonrpc_node = MD_NodeFromString(tag->first_child, tag->last_child + 1, MD_S8Lit("jsonrpc"), (MD_MatchFlags)0);
    MD_Node *method_node  = MD_NodeFromString(tag->first_child, tag->last_child + 1, MD_S8Lit("method"), (MD_MatchFlags)0);
    MD_Node *id_node      = MD_NodeFromString(tag->first_child, tag->last_child + 1, MD_S8Lit("id"), (MD_MatchFlags)0);
    MD_Node *params_node  = MD_NodeFromString(tag->first_child, tag->last_child + 1, MD_S8Lit("params"), (MD_MatchFlags)0);

    if (MD_NodeIsNil(jsonrpc_node) || MD_NodeIsNil(method_node) || MD_NodeIsNil(id_node))
    {
        DQN_MD_INVALID_CODE_PATH_MSG("Missing mandatory node in the RPC post data tag");
        return;
    }

    bool need_tmp_arena = false;
    bool const need_arena     = (!MD_NodeIsNil(params_node->first_child));
    Dqn_MDCppFile_LineBegin(cpp, "Dqn_String %.*sJsonRPCPostData(", MD_S8VArg(struct_node->string));
    if (need_arena)
    {
        // ---------------------------------------------------------------------
        // Add the required arenas to the function prototype
        // ---------------------------------------------------------------------
        Dqn_MDCppFile_LineBegin(cpp, "Dqn_ArenaAllocator *arena, ");
        for (MD_EachNode(param_node, params_node->first_child))
        {
            MD_Node *type_node = param_node->first_child;
            if (Dqn_MD__NodeHasArrayNotation(type_node->first_child->next))
            {
                // NOTE: We need a string builder to build this data, i.e. we
                // need some temporary memory
                need_tmp_arena = true;
                Dqn_MDCppFile_LineBegin(cpp, "Dqn_ArenaAllocator *tmp_arena, ");
                break;
            }
        }

        // ---------------------------------------------------------------------
        // Add the parameters to the function prototype
        // ---------------------------------------------------------------------
        for (MD_EachNode(param_node, params_node->first_child))
        {
            Dqn_MD__Variable variable = Dqn_MD__VariableFromNode(param_node);
            Dqn_MD__PrintVariableAsFunctionArgument(cpp, &variable);
            if (!MD_NodeIsNil(param_node->next)) Dqn_MDCppFile_LineAdd(cpp, ", ");
        }
    }

    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ");");
        return;
    }

    Dqn_MDCppFile_LineEnd(cpp, ")");
    Dqn_MDCppFile_BeginBlock(cpp, nullptr);

    MD_String8 jsonrpc = jsonrpc_node->first_child->string;
    MD_String8 method  = method_node->first_child->string;
    MD_String8 id      = id_node->first_child->string;

    if (need_arena)
    {
        if (need_tmp_arena)
        {
            Dqn_MDCppFile_Line(cpp, "Dqn_ArenaAllocatorAutoRegion mem_region = Dqn_ArenaAllocator_AutoRegion(tmp_arena);");
            Dqn_MDCppFile_Line(cpp, "Dqn_StringBuilder<> builder = {};");
            Dqn_MDCppFile_Line(cpp, "Dqn_StringBuilder_InitWithArena(&builder, tmp_arena);");
            Dqn_MDCppFile_Line(cpp, R"FOO(Dqn_StringBuilder_AppendString(&builder, DQN_STRING(R"({"jsonrpc":"%.*s", "method":"%.*s", "id":%.*s, "params":[)"));)FOO",
                                    MD_S8VArg(jsonrpc),
                                    MD_S8VArg(method),
                                    MD_S8VArg(id));

            for (MD_EachNode(param_node, params_node->first_child))
            {
                Dqn_MD__Variable variable = Dqn_MD__VariableFromNode(param_node);
                if (variable.is_array)
                {
                    Dqn_MDCppFile_BeginBlock(cpp, "for (Dqn_isize array_index = 0; array_index < %.*s_size; array_index++)", MD_S8VArg(variable.name));
                    Dqn_MDCppFile_Line(cpp, "auto *%.*s_entry = %.*s + array_index;", MD_S8VArg(variable.name), MD_S8VArg(variable.name));
                    if (Dqn_MD__IsTypeCppPrimitive(variable.type))
                    {
                        DQN_MD_INVALID_CODE_PATH_MSG("Unimplemented code path");
                    }
                    else
                    {
                        MD_Node *struct_node = MD_NodeFromString(root->first_child, root->last_child + 1, variable.type, DQN_MD_CAST(MD_MatchFlags)0);
                        DQN_MD_ASSERT_MSG(struct_node, "We don't know how to format print the parameter %.*s", MD_S8VArg(variable.type));

                        Dqn_MDCppFile_Line(cpp, "if (array_index) Dqn_StringBuilder_AppendString(&builder, DQN_STRING(\", \"));");
                        Dqn_MDCppFile_Line(cpp, "Dqn_StringBuilder_AppendChar(&builder, '{');");
                        for (MD_EachNode(struct_param, struct_node->first_child))
                        {
                            // TODO(dqn): Only support strings atm
                            Dqn_MD__Variable struct_variable = Dqn_MD__VariableFromNode(struct_param);
                            DQN_MD_ASSERT_MSG(Dqn_MD__IsTypeCppPrimitive(struct_variable.type), "We don't know how to format print the parameter %.*s", MD_S8VArg(struct_variable.type));
                            Dqn_MDCppFile_Line(cpp, R"FOO(Dqn_StringBuilder_AppendFmt(&builder, "\"%.*s\": \"%.*s\"%s", DQN_STRING_FMT(%.*s_entry->%.*s));)FOO",
                                               MD_S8VArg(struct_variable.name),
                                               MD_S8VArg(Dqn_MD__ConvertTypeToFmtString(struct_variable.type)),
                                               MD_NodeIsNil(struct_param->next) ? "" : ", ",
                                               MD_S8VArg(variable.name),
                                               MD_S8VArg(struct_variable.name));

                        }
                        Dqn_MDCppFile_Line(cpp, "Dqn_StringBuilder_AppendChar(&builder, '}');");
                    }
                    Dqn_MDCppFile_EndForBlock(cpp);
                }
                else
                {
                    Dqn_MDCppFile_Line(cpp, "Dqn_StringBuilder_AppendFmt(&builder, \"%.*s%s\", %.*s);",
                                       MD_S8VArg(Dqn_MD__ConvertTypeToFmtString(variable.type)),
                                       MD_NodeIsNil(param_node->next) ? "" : ", ",
                                       MD_S8VArg(variable.name));
                }
            }

            Dqn_MDCppFile_Line(cpp, "Dqn_StringBuilder_AppendString(&builder, DQN_STRING(\"]}\"));");
            Dqn_MDCppFile_Line(cpp, "Dqn_String result = Dqn_StringBuilder_BuildStringWithArena(&builder, arena);");
        }
        else
        {
            Dqn_MDCppFile_Line(cpp, "Dqn_String result = Dqn_String_Fmt(");
            Dqn_MDCppFile_Indent(cpp);
            Dqn_MDCppFile_Line(cpp, "arena,");
            Dqn_MDCppFile_LineBegin(cpp,
                                    R"FOO(R"({"jsonrpc":"%.*s", "method":"%.*s", "id":%.*s, "params":[)FOO",
                                    MD_S8VArg(jsonrpc),
                                    MD_S8VArg(method),
                                    MD_S8VArg(id));

            for (MD_EachNode(param_node, params_node->first_child))
            {
                Dqn_MDCppFile_LineAdd(cpp, R"("%%.*s")");
                if (!MD_NodeIsNil(param_node->next)) Dqn_MDCppFile_LineAdd(cpp, ", ");
            }
            Dqn_MDCppFile_LineEnd(cpp, R"FOO(]})",)FOO");

            for (MD_EachNode(param_node, params_node->first_child))
            {
                MD_String8 name = param_node->string;
                MD_String8 type = param_node->first_child->string;
                Dqn_MD__ConvertTypeToFmtString(type);
                if (MD_S8Match(type, MD_S8Lit("string"), 0))
                    Dqn_MDCppFile_LineBegin(cpp, "DQN_STRING_FMT(%.*s)", MD_S8VArg(name));
                else
                    Dqn_MDCppFile_LineBegin(cpp, "%.*s", MD_S8VArg(name));

                if (!MD_NodeIsNil(param_node->next))
                {
                    Dqn_MDCppFile_LineAdd(cpp, ",");
                    Dqn_MDCppFile_LineEnd(cpp, nullptr);
                }
            }
            Dqn_MDCppFile_LineEnd(cpp, ");");
            Dqn_MDCppFile_Unindent(cpp);
        }
        Dqn_MDCppFile_Line(cpp, "DQN_HARD_ASSERT(result.str);");
        Dqn_MDCppFile_Line(cpp, "return result;");
    }
    else
    {
        Dqn_MDCppFile_Line(cpp, R"FOO(return DQN_STRING(R"({"jsonrpc":"%.*s", "method":"%.*s", "id":%.*s, "params":[]})");)FOO",
                           MD_S8VArg(jsonrpc),
                           MD_S8VArg(method),
                           MD_S8VArg(id));
    }
    Dqn_MDCppFile_EndFuncBlock(cpp);
}

void Dqn_MD_GenerateCurlQueryFunction(Dqn_MDCppFile *cpp, MD_Node *struct_node, bool header_file)
{
    MD_Node *json_endpoint_node = MD_NodeFromString(struct_node->first_tag, struct_node->last_tag + 1, MD_S8Lit("json_endpoint"), (MD_MatchFlags)0);
    if (MD_NodeIsNil(json_endpoint_node))
        return;

    if (MD_NodeIsNil(json_endpoint_node->first_child))
    {
        DQN_MD_INVALID_CODE_PATH;
        return;
    }

    MD_Node *url_node    = MD_NodeFromString(json_endpoint_node->first_child, json_endpoint_node->last_child + 1, MD_S8Lit("url"), (MD_MatchFlags)0);
    MD_Node *params_node = MD_NodeFromString(json_endpoint_node->first_child, json_endpoint_node->last_child + 1, MD_S8Lit("params"), (MD_MatchFlags)0);
    MD_String8 url       = url_node->first_child->string;

    if (MD_NodeIsNil(url_node) || MD_NodeIsNil(params_node))
    {
        DQN_MD_INVALID_CODE_PATH;
        return;
    }

    Dqn_MDCppFile_LineBegin(cpp, "Dqn_b32 %.*sQuery(struct INS_Core *insight", MD_S8VArg(struct_node->string));
    if (!MD_NodeIsNil(params_node->first_child)) Dqn_MDCppFile_LineAdd(cpp, ", ");
    for (MD_EachNode(param_node, params_node->first_child))
    {
        MD_String8 name = param_node->string;
        MD_String8 type = param_node->first_child->string;
        MD_Assert(!MD_NodeIsNil(param_node->first_child));
        Dqn_MDCppFile_LineAdd(cpp, "%.*s %.*s", MD_S8VArg(Dqn_MD__ConvertTypeToCppType(type)), MD_S8VArg(name));
        if (!MD_NodeIsNil(param_node->next)) Dqn_MDCppFile_LineAdd(cpp, ", ");
    }

    if (header_file)
    {
        Dqn_MDCppFile_LineEnd(cpp, ");");
        return;
    }

    Dqn_MDCppFile_LineEnd(cpp, ")");
    Dqn_MDCppFile_BeginBlock(cpp, nullptr);

    Dqn_MDCppFile_Line(cpp, "Dqn_FixedString<1024> url = {};");
    Dqn_MDCppFile_LineBegin(cpp, R"(Dqn_FixedString_AppendFmt(&url, "%.*s")", MD_S8VArg(url));
    if (!MD_NodeIsNil(params_node->first_child)) Dqn_MDCppFile_LineAdd(cpp, ", ");
    for (MD_EachNode(param_node, params_node->first_child))
    {
        MD_String8 name = param_node->string;
        Dqn_MDCppFile_LineAdd(cpp, "DQN_STRING_FMT(%.*s)", MD_S8VArg(name));
        if (!MD_NodeIsNil(param_node->next)) Dqn_MDCppFile_LineAdd(cpp, ", ");
    }
    Dqn_MDCppFile_LineEnd(cpp, ");");
    Dqn_MDCppFile_Line(cpp, "DQN_HARD_ASSERT(url.size);");

    Dqn_MDCppFile_Line(cpp, "INS_CurlQuery *query = INS_Curl_QueueQuery(insight, INS_QueryType_%.*s, Dqn_FixedString_ToString(&url));", MD_S8VArg(struct_node->string));
    Dqn_MDCppFile_Line(cpp, "Dqn_b32 result = query != nullptr;");
    Dqn_MDCppFile_Line(cpp, "return result;");
    Dqn_MDCppFile_EndFuncBlock(cpp);
}
#endif // DQN_META_DESK_IMPLEMENTATION

#if defined(DQN_META_DESK_STANDALONE_PROGRAM)
int main(int argc, char **argv)
{
    if (argc != 3)
    {
        fprintf(stdout, "Please pass a file name and output name\nUsage: metadesk <file> <output_name>\n");
        return -1;
    }

    char *file        = argv[1];
    char *output_name = argv[2];
    Dqn_MD_CodeGen(file, output_name, Dqn_MD_CodeGenFlag_All);
    return 0;
}
#endif // DQN_META_DESK_STANDALONE_PROGRAM