/**

 * @file printer/json.c

 * @author Radek Krejci <rkrejci@cesnet.cz>

 * @brief JSON printer for libyang data structure

 *

 * Copyright (c) 2015 CESNET, z.s.p.o.

 *

 * This source code is licensed under BSD 3-Clause License (the "License").

 * You may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     https://opensource.org/licenses/BSD-3-Clause

 */

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include <inttypes.h>

#include "common.h"

#include "printer.h"

#include "tree_data.h"

#include "resolve.h"

#include "tree_internal.h"

#define INDENT ""

#define LEVEL (level*2)

static int json_print_nodes(struct lyout *out, int level, const struct lyd_node *root, int withsiblings, int toplevel,

                            int options);

int

json_print_string(struct lyout *out, const char *text)

{

    unsigned int i, n;

    if (!text) {

        return 0;

    }

    ly_write(out, "\"", 1);

    for (i = n = 0; text[i]; i++) {

        const unsigned char ascii = text[i];

        if (ascii < 0x20) {

            /* control character */

            n += ly_print(out, "\\u%.4X", ascii);

        } else {

            switch (ascii) {

            case '"':

                n += ly_print(out, "\\\"");

                break;

            case '\\':

                n += ly_print(out, "\\\\");

                break;

            default:

                ly_write(out, &text[i], 1);

                n++;

            }

        }

    }

    ly_write(out, "\"", 1);

    return n + 2;

}

static int

json_print_attrs(struct lyout *out, int level, const struct lyd_node *node, const struct lys_module *wdmod)

{

    struct lyd_attr *attr;

    size_t len;

    char *p;

    if (wdmod) {

        ly_print(out, "%*s\"%s:default\":\"true\"", LEVEL, INDENT, wdmod->name);

        ly_print(out, "%s%s", node->attr ? "," : "", (level ? "\n" : ""));

    }

    for (attr = node->attr; attr; attr = attr->next) {

        if (!attr->annotation) {

            /* skip exception for the NETCONF's attribute since JSON is not defined for NETCONF */

            continue;

        }

        if (lys_main_module(attr->annotation->module) != lys_main_module(node->schema->module)) {

            ly_print(out, "%*s\"%s:%s\":", LEVEL, INDENT, attr->annotation->module->name, attr->name);

        } else {

            ly_print(out, "%*s\"%s\":", LEVEL, INDENT, attr->name);

        }

        /* leafref is not supported */

        switch (attr->value_type) {

        case LY_TYPE_BINARY:

        case LY_TYPE_STRING:

        case LY_TYPE_BITS:

        case LY_TYPE_ENUM:

        case LY_TYPE_INST:

        case LY_TYPE_INT64:

        case LY_TYPE_UINT64:

        case LY_TYPE_DEC64:

            json_print_string(out, attr->value_str);

            break;

        case LY_TYPE_INT8:

        case LY_TYPE_INT16:

        case LY_TYPE_INT32:

        case LY_TYPE_UINT8:

        case LY_TYPE_UINT16:

        case LY_TYPE_UINT32:

        case LY_TYPE_BOOL:

            ly_print(out, "%s", attr->value_str[0] ? attr->value_str : "null");

            break;

        case LY_TYPE_IDENT:

            p = strchr(attr->value_str, ':');

            assert(p);

            len = p - attr->value_str;

            if (!strncmp(attr->value_str, attr->annotation->module->name, len)

                    && !attr->annotation->module->name[len]) {

                /* do not print the prefix, it is the default prefix for this node */

                json_print_string(out, ++p);

            } else {

                json_print_string(out, attr->value_str);

            }

            break;

        case LY_TYPE_EMPTY:

            ly_print(out, "[null]");

            break;

        default:

            /* error */

            ly_print(out, "\"(!error!)\"");

            return EXIT_FAILURE;

        }

        ly_print(out, "%s%s", attr->next ? "," : "", (level ? "\n" : ""));

    }

    return EXIT_SUCCESS;

}

static int

json_print_leaf(struct lyout *out, int level, const struct lyd_node *node, int onlyvalue, int toplevel, int options)

{

    struct lyd_node_leaf_list *leaf = (struct lyd_node_leaf_list *)node, *iter;

    const struct lys_type *type;

    const char *schema = NULL, *p, *mod_name;

    const struct lys_module *wdmod = NULL;

    LY_DATA_TYPE datatype;

    size_t len;

    if ((node->dflt && (options & (LYP_WD_ALL_TAG | LYP_WD_IMPL_TAG))) ||

            (!node->dflt && (options & LYP_WD_ALL_TAG) && lyd_wd_default(leaf))) {

        /* we have implicit OR explicit default node */

        /* get with-defaults module */

        wdmod = ly_ctx_get_module(node->schema->module->ctx, "ietf-netconf-with-defaults", NULL, 1);

    }

    if (!onlyvalue) {

        if (toplevel || !node->parent || nscmp(node, node->parent)) {

            /* print "namespace" */

            schema = lys_node_module(node->schema)->name;

            ly_print(out, "%*s\"%s:%s\":%s", LEVEL, INDENT, schema, node->schema->name, (level ? " " : ""));

        } else {

            ly_print(out, "%*s\"%s\":%s", LEVEL, INDENT, node->schema->name, (level ? " " : ""));

        }

    }

    datatype = leaf->value_type;

contentprint:

    switch (datatype) {

    case LY_TYPE_BINARY:

    case LY_TYPE_STRING:

    case LY_TYPE_BITS:

    case LY_TYPE_ENUM:

    case LY_TYPE_INST:

    case LY_TYPE_INT64:

    case LY_TYPE_UINT64:

    case LY_TYPE_UNION:

    case LY_TYPE_DEC64:

        json_print_string(out, leaf->value_str);

        break;

    case LY_TYPE_INT8:

    case LY_TYPE_INT16:

    case LY_TYPE_INT32:

    case LY_TYPE_UINT8:

    case LY_TYPE_UINT16:

    case LY_TYPE_UINT32:

    case LY_TYPE_BOOL:

        ly_print(out, "%s", leaf->value_str[0] ? leaf->value_str : "null");

        break;

    case LY_TYPE_IDENT:

        p = strchr(leaf->value_str, ':');

        assert(p);

        len = p - leaf->value_str;

        mod_name = leaf->schema->module->name;

        if (!strncmp(leaf->value_str, mod_name, len) && !mod_name[len]) {

            /* do not print the prefix, it is the default prefix for this node */

            json_print_string(out, ++p);

        } else {

            json_print_string(out, leaf->value_str);

        }

        break;

    case LY_TYPE_LEAFREF:

        iter = (struct lyd_node_leaf_list *)leaf->value.leafref;

        while (iter && (iter->value_type == LY_TYPE_LEAFREF)) {

            iter = (struct lyd_node_leaf_list *)iter->value.leafref;

        }

        if (!iter) {

            /* unresolved and invalid, but we can learn the correct type anyway */

            type = lyd_leaf_type((struct lyd_node_leaf_list *)leaf);

            if (!type) {

                /* error */

                ly_print(out, "\"(!error!)\"");

                return EXIT_FAILURE;

            }

            datatype = type->base;

        } else {

            datatype = iter->value_type;

        }

        goto contentprint;

    case LY_TYPE_EMPTY:

        ly_print(out, "[null]");

        break;

    default:

        /* error */

        ly_print(out, "\"(!error!)\"");

        return EXIT_FAILURE;

    }

    /* print attributes as sibling leafs */

    if (!onlyvalue && (node->attr || wdmod)) {

        if (schema) {

            ly_print(out, ",%s%*s\"@%s:%s\":%s{%s", (level ? "\n" : ""), LEVEL, INDENT, schema, node->schema->name,

                     (level ? " " : ""), (level ? "\n" : ""));

        } else {

            ly_print(out, ",%s%*s\"@%s\":%s{%s", (level ? "\n" : ""), LEVEL, INDENT, node->schema->name,

                     (level ? " " : ""), (level ? "\n" : ""));

        }

        if (json_print_attrs(out, (level ? level + 1 : level), node, wdmod)) {

            return EXIT_FAILURE;

        }

        ly_print(out, "%*s}", LEVEL, INDENT);

    }

    return EXIT_SUCCESS;

}

static int

json_print_container(struct lyout *out, int level, const struct lyd_node *node, int toplevel, int options)

{

    const char *schema;

    if (toplevel || !node->parent || nscmp(node, node->parent)) {

        /* print "namespace" */

        schema = lys_node_module(node->schema)->name;

        ly_print(out, "%*s\"%s:%s\":%s{%s", LEVEL, INDENT, schema, node->schema->name, (level ? " " : ""), (level ? "\n" : ""));

    } else {

        ly_print(out, "%*s\"%s\":%s{%s", LEVEL, INDENT, node->schema->name, (level ? " " : ""), (level ? "\n" : ""));

    }

    if (level) {

        level++;

    }

    if (node->attr) {

        ly_print(out, "%*s\"@\":%s{%s", LEVEL, INDENT, (level ? " " : ""), (level ? "\n" : ""));

        if (json_print_attrs(out, (level ? level + 1 : level), node, NULL)) {

            return EXIT_FAILURE;

        }

        ly_print(out, "%*s}", LEVEL, INDENT);

        if (node->child) {

            ly_print(out, ",%s", (level ? "\n" : ""));

        }

    }

    if (json_print_nodes(out, level, node->child, 1, 0, options)) {

        return EXIT_FAILURE;

    }

    if (level) {

        level--;

    }

    ly_print(out, "%*s}", LEVEL, INDENT);

    return EXIT_SUCCESS;

}

static int

json_print_leaf_list(struct lyout *out, int level, const struct lyd_node *node, int is_list, int toplevel, int options)

{

    const char *schema = NULL;

    const struct lyd_node *list = node;

    int flag_empty = 0, flag_attrs = 0;

    if (is_list && !list->child) {

        /* empty, e.g. in case of filter */

        flag_empty = 1;

    }

    if (toplevel || !node->parent || nscmp(node, node->parent)) {

        /* print "namespace" */

        schema = lys_node_module(node->schema)->name;

        ly_print(out, "%*s\"%s:%s\":", LEVEL, INDENT, schema, node->schema->name);

    } else {

        ly_print(out, "%*s\"%s\":", LEVEL, INDENT, node->schema->name);

    }

    if (flag_empty) {

        ly_print(out, "%snull", (level ? " " : ""));

        return EXIT_SUCCESS;

    }

    ly_print(out, "%s[%s", (level ? " " : ""), (level ? "\n" : ""));

    if (!is_list && level) {

        ++level;

    }

    while (list) {

        if (is_list) {

            /* list print */

            if (level) {

                ++level;

            }

            ly_print(out, "%*s{%s", LEVEL, INDENT, (level ? "\n" : ""));

            if (level) {

                ++level;

            }

            if (list->attr) {

                ly_print(out, "%*s\"@\":%s{%s", LEVEL, INDENT, (level ? " " : ""), (level ? "\n" : ""));

                if (json_print_attrs(out, (level ? level + 1 : level), list, NULL)) {

                    return EXIT_FAILURE;

                }

                if (list->child) {

                    ly_print(out, "%*s},%s", LEVEL, INDENT, (level ? "\n" : ""));

                } else {

                    ly_print(out, "%*s}", LEVEL, INDENT);

                }

            }

            if (json_print_nodes(out, level, list->child, 1, 0, options)) {

                return EXIT_FAILURE;

            }

            if (level) {

                --level;

            }

            ly_print(out, "%*s}", LEVEL, INDENT);

            if (level) {

                --level;

            }

        } else {

            /* leaf-list print */

            ly_print(out, "%*s", LEVEL, INDENT);

            if (json_print_leaf(out, level, list, 1, toplevel, options)) {

                return EXIT_FAILURE;

            }

            if (list->attr) {

                flag_attrs = 1;

            }

        }

        if (toplevel && !(options & LYP_WITHSIBLINGS)) {

            /* if initially called without LYP_WITHSIBLINGS do not print other list entries */

            break;

        }

        for (list = list->next; list && list->schema != node->schema; list = list->next);

        if (list) {

            ly_print(out, ",%s", (level ? "\n" : ""));

        }

    }

    if (!is_list && level) {

        --level;

    }

    ly_print(out, "%s%*s]", (level ? "\n" : ""), LEVEL, INDENT);

    /* attributes */

    if (!is_list && flag_attrs) {

        if (schema) {

            ly_print(out, ",%s%*s\"@%s:%s\":%s[%s", (level ? "\n" : ""), LEVEL, INDENT, schema, node->schema->name,

                     (level ? " " : ""), (level ? "\n" : ""));

        } else {

            ly_print(out, ",%s%*s\"@%s\":%s[%s", (level ? "\n" : ""), LEVEL, INDENT, node->schema->name,

                     (level ? " " : ""), (level ? "\n" : ""));

        }

        if (level) {

            level++;

        }

        for (list = node; list; ) {

            if (list->attr) {

                ly_print(out, "%*s{%s", LEVEL, INDENT, (level ? " " : ""));

                if (json_print_attrs(out, 0, list, NULL)) {

                    return EXIT_FAILURE;

                }

                ly_print(out, "%*s}", LEVEL, INDENT);

            } else {

                ly_print(out, "%*snull", LEVEL, INDENT);

            }

            for (list = list->next; list && list->schema != node->schema; list = list->next);

            if (list) {

                ly_print(out, ",%s", (level ? "\n" : ""));

            }

        }

        if (level) {

            level--;

        }

        ly_print(out, "%s%*s]", (level ? "\n" : ""), LEVEL, INDENT);

    }

    return EXIT_SUCCESS;

}

static int

json_print_anydataxml(struct lyout *out, int level, const struct lyd_node *node, int toplevel, int options)

{

    struct lyd_node_anydata *any = (struct lyd_node_anydata *)node;

    int is_object = 0;

    char *buf;

    const char *schema = NULL;

    if (toplevel || !node->parent || nscmp(node, node->parent)) {

        /* print "namespace" */

        schema = lys_node_module(node->schema)->name;

        ly_print(out, "%*s\"%s:%s\":", LEVEL, INDENT, schema, node->schema->name);

    } else {

        ly_print(out, "%*s\"%s\":", LEVEL, INDENT, node->schema->name);

    }

    if (level) {

        level++;

    }

    switch (any->value_type) {

    case LYD_ANYDATA_DATATREE:

        is_object = 1;

        ly_print(out, "%s{%s", (level ? " " : ""), (level ? "\n" : ""));

        /* do not print any default values nor empty containers */

        if (json_print_nodes(out, level, any->value.tree, 1, 0,  LYP_WITHSIBLINGS | (options & ~LYP_NETCONF))) {

            return EXIT_FAILURE;

        }

        break;

    case LYD_ANYDATA_JSON:

        if (level) {

            ly_print(out, "\n");

        }

        if (any->value.str) {

            ly_print(out, "%s", any->value.str);

        }

        if (level && (!any->value.str || (any->value.str[strlen(any->value.str) - 1] != '\n'))) {

            /* do not print 2 newlines */

            ly_print(out, "\n");

        }

        break;

    case LYD_ANYDATA_XML:

        lyxml_print_mem(&buf, any->value.xml, (level ? LYXML_PRINT_FORMAT | LYXML_PRINT_NO_LAST_NEWLINE : 0)

                                               | LYXML_PRINT_SIBLINGS);

        if (level) {

            ly_print(out, " ");

        }

        json_print_string(out, buf);

        free(buf);

        break;

    case LYD_ANYDATA_CONSTSTRING:

    case LYD_ANYDATA_SXML:

        if (level) {

            ly_print(out, " ");

        }

        if (any->value.str) {

            json_print_string(out, any->value.str);

        } else {

            ly_print(out, "\"\"");

        }

        break;

    case LYD_ANYDATA_STRING:

    case LYD_ANYDATA_SXMLD:

    case LYD_ANYDATA_JSOND:

    case LYD_ANYDATA_LYBD:

    case LYD_ANYDATA_LYB:

        /* other formats are not supported */

        json_print_string(out, "(error)");

        break;

    }

    /* print attributes as sibling leaf */

    if (node->attr) {

        if (schema) {

            ly_print(out, ",%s%*s\"@%s:%s\":%s{%s", (level ? "\n" : ""), LEVEL, INDENT, schema, node->schema->name,

                     (level ? " " : ""), (level ? "\n" : ""));

        } else {

            ly_print(out, ",%s%*s\"@%s\":%s{%s", (level ? "\n" : ""), LEVEL, INDENT, node->schema->name,

                     (level ? " " : ""), (level ? "\n" : ""));

        }

        if (json_print_attrs(out, (level ? level + 1 : level), node, NULL)) {

            return EXIT_FAILURE;

        }

        ly_print(out, "%*s}", LEVEL, INDENT);

    }

    if (level) {

        level--;

    }

    if (is_object) {

        ly_print(out, "%*s}", LEVEL, INDENT);

    }

    return EXIT_SUCCESS;

}

static int

json_print_nodes(struct lyout *out, int level, const struct lyd_node *root, int withsiblings, int toplevel, int options)

{

    int ret = EXIT_SUCCESS,comma_flag = 0;

    const struct lyd_node *node, *iter;

    LY_TREE_FOR(root, node) {

        if (!lyd_wd_toprint(node, options)) {

            /* wd says do not print */

            continue;

        }

        switch (node->schema->nodetype) {

        case LYS_RPC:

        case LYS_ACTION:

        case LYS_NOTIF:

        case LYS_CONTAINER:

            if (comma_flag) {

                /* print the previous comma */

                ly_print(out, ",%s", (level ? "\n" : ""));

            }

            ret = json_print_container(out, level, node, toplevel, options);

            break;

        case LYS_LEAF:

            if (comma_flag) {

                /* print the previous comma */

                ly_print(out, ",%s", (level ? "\n" : ""));

            }

            ret = json_print_leaf(out, level, node, 0, toplevel, options);

            break;

        case LYS_LEAFLIST:

        case LYS_LIST:

            /* is it already printed? (root node is not) */

            for (iter = node->prev; iter->next && node != root; iter = iter->prev) {

                if (iter == node) {

                    continue;

                }

                if (iter->schema == node->schema) {

                    /* the list has alread some previous instance and therefore it is already printed */

                    break;

                }

            }

            if (!iter->next || node == root) {

                if (comma_flag) {

                    /* print the previous comma */

                    ly_print(out, ",%s", (level ? "\n" : ""));

                }

                /* print the list/leaflist */

                ret = json_print_leaf_list(out, level, node, node->schema->nodetype == LYS_LIST ? 1 : 0, toplevel, options);

            }

            break;

        case LYS_ANYXML:

        case LYS_ANYDATA:

            if (comma_flag) {

                /* print the previous comma */

                ly_print(out, ",%s", (level ? "\n" : ""));

            }

            ret = json_print_anydataxml(out, level, node, toplevel, options);

            break;

        default:

            LOGINT(node->schema->module->ctx);

            ret = EXIT_FAILURE;

            break;

        }

        if (!withsiblings) {

            break;

        }

        comma_flag = 1;

    }

    if (root && level) {

        ly_print(out, "\n");

    }

    return ret;

}

int

json_print_data(struct lyout *out, const struct lyd_node *root, int options)

{

    const struct lyd_node *node, *next;

    int level = 0, action_input = 0;

    if (options & LYP_FORMAT) {

        ++level;

    }

    if (options & LYP_NETCONF) {

        if (root->schema->nodetype != LYS_RPC) {

            /* learn whether we are printing an action */

            LY_TREE_DFS_BEGIN(root, next, node) {

                if (node->schema->nodetype == LYS_ACTION) {

                    break;

                }

                LY_TREE_DFS_END(root, next, node);

            }

        } else {

            node = root;

        }

        if (node && (node->schema->nodetype & (LYS_RPC | LYS_ACTION))) {

            if (node->child && (node->child->schema->parent->nodetype == LYS_OUTPUT)) {

                /* skip the container */

                root = node->child;

            } else if (node->schema->nodetype == LYS_ACTION) {

                action_input = 1;

            }

        }

    }

    /* start */

    ly_print(out, "{%s", (level ? "\n" : ""));

    if (action_input) {

        ly_print(out, "%*s\"yang:action\":%s{%s", LEVEL, INDENT, (level ? " " : ""), (level ? "\n" : ""));

        if (level) {

            ++level;

        }

    }

    /* content */

    if (json_print_nodes(out, level, root, options & LYP_WITHSIBLINGS, 1, options)) {

        return EXIT_FAILURE;

    }

    if (action_input) {

        if (level) {

            --level;

        }

        ly_print(out, "%*s}%s", LEVEL, INDENT, (level ? "\n" : ""));

    }

    /* end */

    ly_print(out, "}%s", (level ? "\n" : ""));

    ly_print_flush(out);

    return EXIT_SUCCESS;

}