/*
 * This file Copyright (C) 2008-2014 Mnemosyne LLC
 *
 * It may be used under the GNU GPL versions 2 or 3
 * or any future license endorsed by Mnemosyne LLC.
 *
 */

#include <ctype.h>
#include <math.h> /* fabs() */
#include <stdio.h>
#include <string.h>
#include <errno.h> /* EILSEQ, EINVAL */

#include <event2/buffer.h> /* evbuffer_add() */
#include <event2/util.h> /* evutil_strtoll() */

#define LIBTRANSMISSION_VARIANT_MODULE

#include "transmission.h"
#include "ConvertUTF.h"
#include "jsonsl.h"
#include "list.h"
#include "log.h"
#include "ptrarray.h"
#include "tr-assert.h"
#include "utils.h"
#include "variant.h"
#include "variant-common.h"

/* arbitrary value... this is much deeper than our code goes */
#define MAX_DEPTH 64

struct json_wrapper_data
{
    int error;
    bool has_content;
    tr_variant* top;
    char const* key;
    size_t keylen;
    struct evbuffer* keybuf;
    struct evbuffer* strbuf;
    char const* source;
    tr_ptrArray stack;

    /* A very common pattern is for a container's children to be similar,
     * e.g. they may all be objects with the same set of keys. So when
     * a container is popped off the stack, remember its size to use as
     * a preallocation heuristic for the next container at that depth. */
    size_t preallocGuess[MAX_DEPTH];
};

static tr_variant* get_node(struct jsonsl_st* jsn)
{
    auto* data = static_cast<struct json_wrapper_data*>(jsn->data);

    auto* parent = static_cast<tr_variant*>(tr_ptrArrayEmpty(&data->stack) ? nullptr : tr_ptrArrayBack(&data->stack));

    tr_variant* node = nullptr;
    if (parent == nullptr)
    {
        node = data->top;
    }
    else if (tr_variantIsList(parent))
    {
        node = tr_variantListAdd(parent);
    }
    else if (tr_variantIsDict(parent) && data->key != nullptr)
    {
        node = tr_variantDictAdd(parent, tr_quark_new(data->key, data->keylen));

        data->key = nullptr;
        data->keylen = 0;
    }

    return node;
}

static void error_handler(jsonsl_t jsn, jsonsl_error_t error, struct jsonsl_state_st* state, jsonsl_char_t const* buf)
{
    TR_UNUSED(state);

    auto* data = static_cast<struct json_wrapper_data*>(jsn->data);

    if (data->source != nullptr)
    {
        tr_logAddError(
            "JSON parse failed in %s at pos %zu: %s -- remaining text \"%.16s\"",
            data->source,
            jsn->pos,
            jsonsl_strerror(error),
            buf);
    }
    else
    {
        tr_logAddError("JSON parse failed at pos %zu: %s -- remaining text \"%.16s\"", jsn->pos, jsonsl_strerror(error), buf);
    }

    data->error = EILSEQ;
}

static int error_callback(jsonsl_t jsn, jsonsl_error_t error, struct jsonsl_state_st* state, jsonsl_char_t* at)
{
    error_handler(jsn, error, state, at);
    return 0; /* bail */
}

static void action_callback_PUSH(jsonsl_t jsn, jsonsl_action_t action, struct jsonsl_state_st* state, jsonsl_char_t const* buf)
{
    TR_UNUSED(action);
    TR_UNUSED(buf);

    tr_variant* node;
    auto* data = static_cast<struct json_wrapper_data*>(jsn->data);

    if ((state->type == JSONSL_T_LIST) || (state->type == JSONSL_T_OBJECT))
    {
        data->has_content = true;
        node = get_node(jsn);
        tr_ptrArrayAppend(&data->stack, node);

        int const depth = tr_ptrArraySize(&data->stack);
        size_t const n = depth < MAX_DEPTH ? data->preallocGuess[depth] : 0;
        if (state->type == JSONSL_T_LIST)
        {
            tr_variantInitList(node, n);
        }
        else
        {
            tr_variantInitDict(node, n);
        }
    }
}

/* like sscanf(in+2, "%4x", &val) but less slow */
static bool decode_hex_string(char const* in, unsigned int* setme)
{
    TR_ASSERT(in != nullptr);

    unsigned int val = 0;
    char const* const end = in + 6;

    TR_ASSERT(in[0] == '\\');
    TR_ASSERT(in[1] == 'u');
    in += 2;

    do
    {
        val <<= 4;

        if ('0' <= *in && *in <= '9')
        {
            val += *in - '0';
        }
        else if ('a' <= *in && *in <= 'f')
        {
            val += *in - 'a' + 10U;
        }
        else if ('A' <= *in && *in <= 'F')
        {
            val += *in - 'A' + 10U;
        }
        else
        {
            return false;
        }
    } while (++in != end);

    *setme = val;
    return true;
}

static char* extract_escaped_string(char const* in, size_t in_len, size_t* len, struct evbuffer* buf)
{
    char const* const in_end = in + in_len;

    evbuffer_drain(buf, evbuffer_get_length(buf));

    while (in < in_end)
    {
        bool unescaped = false;

        if (*in == '\\' && in_end - in >= 2)
        {
            switch (in[1])
            {
            case 'b':
                evbuffer_add(buf, "\b", 1);
                in += 2;
                unescaped = true;
                break;

            case 'f':
                evbuffer_add(buf, "\f", 1);
                in += 2;
                unescaped = true;
                break;

            case 'n':
                evbuffer_add(buf, "\n", 1);
                in += 2;
                unescaped = true;
                break;

            case 'r':
                evbuffer_add(buf, "\r", 1);
                in += 2;
                unescaped = true;
                break;

            case 't':
                evbuffer_add(buf, "\t", 1);
                in += 2;
                unescaped = true;
                break;

            case '/':
                evbuffer_add(buf, "/", 1);
                in += 2;
                unescaped = true;
                break;

            case '"':
                evbuffer_add(buf, "\"", 1);
                in += 2;
                unescaped = true;
                break;

            case '\\':
                evbuffer_add(buf, "\\", 1);
                in += 2;
                unescaped = true;
                break;

            case 'u':
                {
                    if (in_end - in >= 6)
                    {
                        unsigned int val = 0;

                        if (decode_hex_string(in, &val))
                        {
                            UTF32 str32_buf[2] = { val, 0 };
                            UTF32 const* str32_walk = str32_buf;
                            UTF32 const* str32_end = str32_buf + 1;
                            UTF8 str8_buf[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
                            UTF8* str8_walk = str8_buf;
                            UTF8* str8_end = str8_buf + 8;

                            if (ConvertUTF32toUTF8(&str32_walk, str32_end, &str8_walk, str8_end, {}) == 0)
                            {
                                evbuffer_add(buf, str8_buf, str8_walk - str8_buf);
                                unescaped = true;
                            }

                            in += 6;
                            break;
                        }
                    }
                }
            }
        }

        if (!unescaped)
        {
            evbuffer_add(buf, in, 1);
            ++in;
        }
    }

    *len = evbuffer_get_length(buf);
    return (char*)evbuffer_pullup(buf, -1);
}

static char const* extract_string(jsonsl_t jsn, struct jsonsl_state_st* state, size_t* len, struct evbuffer* buf)
{
    char const* ret;
    char const* in_begin;
    char const* in_end;
    size_t in_len;

    /* figure out where the string is */
    in_begin = jsn->base + state->pos_begin;

    if (*in_begin == '"')
    {
        in_begin++;
    }

    in_end = jsn->base + state->pos_cur;
    in_len = in_end - in_begin;

    if (memchr(in_begin, '\\', in_len) == nullptr)
    {
        /* it's not escaped */
        ret = in_begin;
        *len = in_len;
    }
    else
    {
        ret = extract_escaped_string(in_begin, in_len, len, buf);
    }

    return ret;
}

static void action_callback_POP(jsonsl_t jsn, jsonsl_action_t action, struct jsonsl_state_st* state, jsonsl_char_t const* buf)
{
    TR_UNUSED(action);
    TR_UNUSED(buf);

    auto* data = static_cast<struct json_wrapper_data*>(jsn->data);

    if (state->type == JSONSL_T_STRING)
    {
        size_t len;
        char const* str = extract_string(jsn, state, &len, data->strbuf);
        tr_variantInitStr(get_node(jsn), str, len);
        data->has_content = true;
    }
    else if (state->type == JSONSL_T_HKEY)
    {
        data->has_content = true;
        data->key = extract_string(jsn, state, &data->keylen, data->keybuf);
    }
    else if (state->type == JSONSL_T_LIST || state->type == JSONSL_T_OBJECT)
    {
        int const depth = tr_ptrArraySize(&data->stack);
        auto* v = static_cast<tr_variant const*>(tr_ptrArrayPop(&data->stack));
        if (depth < MAX_DEPTH)
        {
            data->preallocGuess[depth] = v->val.l.count;
        }
    }
    else if (state->type == JSONSL_T_SPECIAL)
    {
        if ((state->special_flags & JSONSL_SPECIALf_NUMNOINT) != 0)
        {
            char const* begin = jsn->base + state->pos_begin;
            data->has_content = true;
            tr_variantInitReal(get_node(jsn), strtod(begin, nullptr));
        }
        else if ((state->special_flags & JSONSL_SPECIALf_NUMERIC) != 0)
        {
            char const* begin = jsn->base + state->pos_begin;
            data->has_content = true;
            tr_variantInitInt(get_node(jsn), evutil_strtoll(begin, nullptr, 10));
        }
        else if ((state->special_flags & JSONSL_SPECIALf_BOOLEAN) != 0)
        {
            bool const b = (state->special_flags & JSONSL_SPECIALf_TRUE) != 0;
            data->has_content = true;
            tr_variantInitBool(get_node(jsn), b);
        }
        else if ((state->special_flags & JSONSL_SPECIALf_NULL) != 0)
        {
            data->has_content = true;
            tr_variantInitQuark(get_node(jsn), TR_KEY_NONE);
        }
    }
}

int tr_jsonParse(char const* source, void const* vbuf, size_t len, tr_variant* setme_variant, char const** setme_end)
{
    int error;
    jsonsl_t jsn;
    struct json_wrapper_data data;

    jsn = jsonsl_new(MAX_DEPTH);
    jsn->action_callback_PUSH = action_callback_PUSH;
    jsn->action_callback_POP = action_callback_POP;
    jsn->error_callback = error_callback;
    jsn->data = &data;
    jsonsl_enable_all_callbacks(jsn);

    data.error = 0;
    data.has_content = false;
    data.key = nullptr;
    data.top = setme_variant;
    data.stack = {};
    data.source = source;
    data.keybuf = evbuffer_new();
    data.strbuf = evbuffer_new();
    for (int i = 0; i < MAX_DEPTH; ++i)
    {
        data.preallocGuess[i] = 0;
    }

    /* parse it */
    jsonsl_feed(jsn, static_cast<jsonsl_char_t const*>(vbuf), len);

    /* EINVAL if there was no content */
    if (data.error == 0 && !data.has_content)
    {
        data.error = EINVAL;
    }

    /* maybe set the end ptr */
    if (setme_end != nullptr)
    {
        *setme_end = ((char const*)vbuf) + jsn->pos;
    }

    /* cleanup */
    error = data.error;
    evbuffer_free(data.keybuf);
    evbuffer_free(data.strbuf);
    tr_ptrArrayDestruct(&data.stack, nullptr);
    jsonsl_destroy(jsn);
    return error;
}

/****
*****
****/

struct ParentState
{
    int variantType;
    int childIndex;
    int childCount;
};

struct jsonWalk
{
    bool doIndent;
    tr_list* parents;
    struct evbuffer* out;
};

static void jsonIndent(struct jsonWalk* data)
{
    static char buf[1024] = { '\0' };

    if (*buf == '\0')
    {
        memset(buf, ' ', sizeof(buf));
        buf[0] = '\n';
    }

    if (data->doIndent)
    {
        evbuffer_add(data->out, buf, tr_list_size(data->parents) * 4 + 1);
    }
}

static void jsonChildFunc(struct jsonWalk* data)
{
    if (data->parents != nullptr && data->parents->data != nullptr)
    {
        auto* pstate = static_cast<struct ParentState*>(data->parents->data);

        switch (pstate->variantType)
        {
        case TR_VARIANT_TYPE_DICT:
            {
                int const i = pstate->childIndex;
                ++pstate->childIndex;

                if (i % 2 == 0)
                {
                    evbuffer_add(data->out, ": ", data->doIndent ? 2 : 1);
                }
                else
                {
                    bool const isLast = pstate->childIndex == pstate->childCount;

                    if (!isLast)
                    {
                        evbuffer_add(data->out, ",", 1);
                        jsonIndent(data);
                    }
                }

                break;
            }

        case TR_VARIANT_TYPE_LIST:
            {
                ++pstate->childIndex;
                bool const isLast = pstate->childIndex == pstate->childCount;

                if (!isLast)
                {
                    evbuffer_add(data->out, ",", 1);
                    jsonIndent(data);
                }

                break;
            }

        default:
            break;
        }
    }
}

static void jsonPushParent(struct jsonWalk* data, tr_variant const* v)
{
    struct ParentState* pstate = tr_new(struct ParentState, 1);

    pstate->variantType = v->type;
    pstate->childIndex = 0;
    pstate->childCount = v->val.l.count;

    if (tr_variantIsDict(v))
    {
        pstate->childCount *= 2;
    }

    tr_list_prepend(&data->parents, pstate);
}

static void jsonPopParent(struct jsonWalk* data)
{
    tr_free(tr_list_pop_front(&data->parents));
}

static void jsonIntFunc(tr_variant const* val, void* vdata)
{
    auto* data = static_cast<struct jsonWalk*>(vdata);
    evbuffer_add_printf(data->out, "%" PRId64, val->val.i);
    jsonChildFunc(data);
}

static void jsonBoolFunc(tr_variant const* val, void* vdata)
{
    auto* data = static_cast<struct jsonWalk*>(vdata);

    if (val->val.b)
    {
        evbuffer_add(data->out, "true", 4);
    }
    else
    {
        evbuffer_add(data->out, "false", 5);
    }

    jsonChildFunc(data);
}

static void jsonRealFunc(tr_variant const* val, void* vdata)
{
    auto* data = static_cast<struct jsonWalk*>(vdata);

    if (fabs(val->val.d - (int)val->val.d) < 0.00001)
    {
        evbuffer_add_printf(data->out, "%d", (int)val->val.d);
    }
    else
    {
        evbuffer_add_printf(data->out, "%.4f", tr_truncd(val->val.d, 4));
    }

    jsonChildFunc(data);
}

static void jsonStringFunc(tr_variant const* val, void* vdata)
{
    struct evbuffer_iovec vec[1];
    auto* data = static_cast<struct jsonWalk*>(vdata);

    char const* str = nullptr;
    size_t len = 0;
    (void)tr_variantGetStr(val, &str, &len);
    auto const* it = reinterpret_cast<unsigned char const*>(str);
    unsigned char const* const end = it + len;

    evbuffer_reserve_space(data->out, len * 4, vec, 1);
    auto* out = static_cast<char*>(vec[0].iov_base);
    char const* const outend = out + vec[0].iov_len;

    char* outwalk = out;
    *outwalk++ = '"';

    for (; it != end; ++it)
    {
        switch (*it)
        {
        case '\b':
            *outwalk++ = '\\';
            *outwalk++ = 'b';
            break;

        case '\f':
            *outwalk++ = '\\';
            *outwalk++ = 'f';
            break;

        case '\n':
            *outwalk++ = '\\';
            *outwalk++ = 'n';
            break;

        case '\r':
            *outwalk++ = '\\';
            *outwalk++ = 'r';
            break;

        case '\t':
            *outwalk++ = '\\';
            *outwalk++ = 't';
            break;

        case '"':
            *outwalk++ = '\\';
            *outwalk++ = '"';
            break;

        case '\\':
            *outwalk++ = '\\';
            *outwalk++ = '\\';
            break;

        default:
            if (isprint(*it))
            {
                *outwalk++ = *it;
            }
            else
            {
                UTF8 const* tmp = it;
                UTF32 buf[1] = { 0 };
                UTF32* u32 = buf;
                ConversionResult result = ConvertUTF8toUTF32(&tmp, end, &u32, buf + 1, {});

                if ((result == conversionOK || result == targetExhausted) && tmp != it)
                {
                    outwalk += tr_snprintf(outwalk, outend - outwalk, "\\u%04x", (unsigned int)buf[0]);
                    it = tmp - 1;
                }
            }

            break;
        }
    }

    *outwalk++ = '"';
    vec[0].iov_len = outwalk - out;
    evbuffer_commit_space(data->out, vec, 1);

    jsonChildFunc(data);
}

static void jsonDictBeginFunc(tr_variant const* val, void* vdata)
{
    auto* data = static_cast<struct jsonWalk*>(vdata);

    jsonPushParent(data, val);
    evbuffer_add(data->out, "{", 1);

    if (val->val.l.count != 0)
    {
        jsonIndent(data);
    }
}

static void jsonListBeginFunc(tr_variant const* val, void* vdata)
{
    size_t const nChildren = tr_variantListSize(val);
    auto* data = static_cast<struct jsonWalk*>(vdata);

    jsonPushParent(data, val);
    evbuffer_add(data->out, "[", 1);

    if (nChildren != 0)
    {
        jsonIndent(data);
    }
}

static void jsonContainerEndFunc(tr_variant const* val, void* vdata)
{
    auto* data = static_cast<struct jsonWalk*>(vdata);
    bool emptyContainer = false;

    jsonPopParent(data);

    if (!emptyContainer)
    {
        jsonIndent(data);
    }

    if (tr_variantIsDict(val))
    {
        evbuffer_add(data->out, "}", 1);
    }
    else /* list */
    {
        evbuffer_add(data->out, "]", 1);
    }

    jsonChildFunc(data);
}

static struct VariantWalkFuncs const walk_funcs = {
    jsonIntFunc, //
    jsonBoolFunc, //
    jsonRealFunc, //
    jsonStringFunc, //
    jsonDictBeginFunc, //
    jsonListBeginFunc, //
    jsonContainerEndFunc, //
};

void tr_variantToBufJson(tr_variant const* top, struct evbuffer* buf, bool lean)
{
    struct jsonWalk data;

    data.doIndent = !lean;
    data.out = buf;
    data.parents = nullptr;

    tr_variantWalk(top, &walk_funcs, &data, true);

    if (evbuffer_get_length(buf) != 0)
    {
        evbuffer_add_printf(buf, "\n");
    }
}