/**
 *Licensed to the Apache Software Foundation (ASF) under one
 *or more contributor license agreements.  See the NOTICE file
 *distributed with this work for additional information
 *regarding copyright ownership.  The ASF licenses this file
 *to you under the Apache License, Version 2.0 (the
 *"License"); you may not use this file except in compliance
 *with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 *Unless required by applicable law or agreed to in writing,
 *software distributed under the License is distributed on an
 *"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 *specific language governing permissions and limitations
 *under the License.
 */
#include "json_serializer.h"
#include "dyn_type.h"
#include "dyn_interface.h"

#include <jansson.h>
#include <assert.h>
#include <stdint.h>
#include <string.h>

static int jsonSerializer_createType(dyn_type *type, json_t *object, void **result);
static int jsonSerializer_parseObject(dyn_type *type, json_t *object, void *inst);
static int jsonSerializer_parseObjectMember(dyn_type *type, const char *name, json_t *val, void *inst);
static int jsonSerializer_parseSequence(dyn_type *seq, json_t *array, void *seqLoc);
static int jsonSerializer_parseAny(dyn_type *type, void *input, json_t *val);

static int jsonSerializer_writeAny(dyn_type *type, void *input, json_t **val);

static int jsonSerializer_writeComplex(dyn_type *type, void *input, json_t **val);

static int jsonSerializer_writeSequence(dyn_type *type, void *input, json_t **out);

static int OK = 0;
static int ERROR = 1;

DFI_SETUP_LOG(jsonSerializer);

int jsonSerializer_deserialize(dyn_type *type, const char *input, void **result) {
    assert(dynType_type(type) == DYN_TYPE_COMPLEX || dynType_type(type) == DYN_TYPE_SEQUENCE);
    int status = 0;

    json_error_t error;
    json_t *root = json_loads(input, JSON_DECODE_ANY, &error);

    if (root != NULL) {
        status = jsonSerializer_deserializeJson(type, root, result);
        json_decref(root);
    } else {
        status = ERROR;
        LOG_ERROR("Error parsing json input '%s'. Error is: %s\n", input, error.text);
    }

    return status;
}

int jsonSerializer_deserializeJson(dyn_type *type, json_t *input, void **out) {
    return jsonSerializer_createType(type, input, out);
}

static int jsonSerializer_createType(dyn_type *type, json_t *val, void **result) {
    assert(val != NULL);
    int status = OK;

    void *inst = NULL;
    status = dynType_alloc(type, &inst);

    if (status == OK) {
        assert(inst != NULL);
        status = jsonSerializer_parseAny(type, inst, val);

        if (status != OK) {
            dynType_free(type, inst);
        }
    }

    if (status == OK) {
        *result = inst;
    }

    return status;
}

static int jsonSerializer_parseObject(dyn_type *type, json_t *object, void *inst) {
    assert(object != NULL);
    int status = 0;
    json_t *value;
    const char *key;

    json_object_foreach(object, key, value) {
        status = jsonSerializer_parseObjectMember(type, key, value, inst);
        if (status != OK) {
            break;
        }
    }

    return status;
}

static int jsonSerializer_parseObjectMember(dyn_type *type, const char *name, json_t *val, void *inst) {
    int status = OK;
    void *valp = NULL;
    dyn_type *valType = NULL;

    int index = dynType_complex_indexForName(type, name);
    if (index < 0) {
        LOG_ERROR("Cannot find index for member '%s'", name);
        status = ERROR;
    }

    if (status == OK) {
        status = dynType_complex_valLocAt(type, index, inst, &valp);
    }

    if (status == OK ) {
        status = dynType_complex_dynTypeAt(type, index, &valType);
    }

    if (status == OK) {
        status = jsonSerializer_parseAny(valType, valp, val);
    }

    return status;
}

static int jsonSerializer_parseAny(dyn_type *type, void *loc, json_t *val) {
    int status = OK;

    dyn_type *subType = NULL;
    char c = dynType_descriptorType(type);

    /*
    printf("parseAny with descriptor '%c' :", c);
    json_dumpf(val, stdout, 0); //TODO remove
    printf("\n");
     */

    bool *z;            //Z
    float *f;           //F
    double *d;          //D
    char *b;            //B
    int *n;             //N
    int16_t *s;         //S
    int32_t *i;         //I
    int64_t *l;         //J
    uint8_t   *ub;      //b
    uint16_t  *us;      //s
    uint32_t  *ui;      //i
    uint64_t  *ul;      //j

    switch (c) {
        case 'Z' :
            z = loc;
            *z = (bool) json_is_true(val);
            break;
        case 'F' :
            f = loc;
            *f = (float) json_real_value(val);
            break;
        case 'D' :
            d = loc;
            *d = json_real_value(val);
            break;
        case 'N' :
            n = loc;
            *n = (int) json_real_value(val);
            break;
        case 'B' :
            b = loc;
            *b = (char) json_integer_value(val);
            break;
        case 'S' :
            s = loc;
            *s = (int16_t) json_integer_value(val);
            break;
        case 'I' :
            i = loc;
            *i = (int32_t) json_integer_value(val);
            break;
        case 'J' :
            l = loc;
            *l = (int64_t) json_integer_value(val);
            break;
        case 'b' :
            ub = loc;
            *ub = (uint8_t) json_integer_value(val);
            break;
        case 's' :
            us = loc;
            *us = (uint16_t) json_integer_value(val);
            break;
        case 'i' :
            ui = loc;
            *ui = (uint32_t) json_integer_value(val);
            break;
        case 'j' :
            ul = loc;
            *ul = (uint64_t) json_integer_value(val);
            break;
        case 't' :
            if (json_is_string(val)) {
                dynType_text_allocAndInit(type, loc, json_string_value(val));
            } else {
                status = ERROR;
                LOG_ERROR("Expected json string type got %i", json_typeof(val));
            }
            break;
        case '[' :
            if (json_is_array(val)) {
                status = jsonSerializer_parseSequence(type, val, loc);
            } else {
                status = ERROR;
                LOG_ERROR("Expected json array type got '%i'", json_typeof(val));
            }
            break;
        case '{' :
            if (status == OK) {
                status = jsonSerializer_parseObject(type, val, loc);
            }
            break;
        case '*' :
            status = dynType_typedPointer_getTypedType(type, &subType);
            if (status == OK) {
                status = jsonSerializer_createType(subType, val, (void **) loc);
            }
            break;
        case 'P' :
            status = ERROR;
            LOG_WARNING("Untyped pointer are not supported for serialization");
            break;
        default :
            status = ERROR;
            LOG_ERROR("Error provided type '%c' not supported for JSON\n", dynType_descriptorType(type));
            break;
    }

    return status;
}

static int jsonSerializer_parseSequence(dyn_type *seq, json_t *array, void *seqLoc) {
    assert(dynType_type(seq) == DYN_TYPE_SEQUENCE);
    int status = OK;

    size_t size = json_array_size(array);
    //LOG_DEBUG("Allocating sequence with capacity %zu", size);
    status = dynType_sequence_alloc(seq, seqLoc, (int) size);

    if (status == OK) {
        dyn_type *itemType = dynType_sequence_itemType(seq);
        size_t index;
        json_t *val;
        json_array_foreach(array, index, val) {
            void *valLoc = NULL;
            status = dynType_sequence_increaseLengthAndReturnLastLoc(seq, seqLoc, &valLoc);
            //LOG_DEBUG("Got sequence loc %p for index %zu", valLoc, index);

            if (status == OK) {
                status = jsonSerializer_parseAny(itemType, valLoc, val);
                if (status != OK) {
                    break;
                }
            }
        }
    }

    return status;
}

int jsonSerializer_serialize(dyn_type *type, void *input, char **output) {
    int status = OK;

    json_t *root = NULL;
    status = jsonSerializer_serializeJson(type, input, &root);

    if (status == OK) {
        *output = json_dumps(root, JSON_COMPACT);
        json_decref(root);
    }

    return status;
}

int jsonSerializer_serializeJson(dyn_type *type, void *input, json_t **out) {
    return jsonSerializer_writeAny(type, input, out);
}

static int jsonSerializer_writeAny(dyn_type *type, void *input, json_t **out) {
    int status = OK;

    int descriptor = dynType_descriptorType(type);
    json_t *val = NULL;
    dyn_type *subType = NULL;

    bool *z;            //Z
    float *f;           //F
    double *d;          //D
    char *b;            //B
    int *n;             //N
    int16_t *s;         //S
    int32_t *i;         //I
    int64_t *l;         //J
    uint8_t   *ub;      //b
    uint16_t  *us;      //s
    uint32_t  *ui;      //i
    uint64_t  *ul;      //j

    switch (descriptor) {
        case 'Z' :
            z = input;
            val = json_boolean((bool)*z);
            break;
        case 'B' :
            b = input;
            val = json_integer((json_int_t)*b);
            break;
        case 'S' :
            s = input;
            val = json_integer((json_int_t)*s);
            break;
        case 'I' :
            i = input;
            val = json_integer((json_int_t)*i);
            break;
        case 'J' :
            l = input;
            val = json_integer((json_int_t)*l);
            break;
        case 'b' :
            ub = input;
            val = json_integer((json_int_t)*ub);
            break;
        case 's' :
            us = input;
            val = json_integer((json_int_t)*us);
            break;
        case 'i' :
            ui = input;
            val = json_integer((json_int_t)*ui);
            break;
        case 'j' :
            ul = input;
            val = json_integer((json_int_t)*ul);
            break;
        case 'N' :
            n = input;
            val = json_integer((json_int_t)*n);
            break;
        case 'F' :
            f = input;
            val = json_real((double) *f);
            break;
        case 'D' :
            d = input;
            val = json_real(*d);
            break;
        case 't' :
            val = json_string(*(const char **) input);
            break;
        case '*' :
            status = dynType_typedPointer_getTypedType(type, &subType);
            if (status == OK) {
                status = jsonSerializer_writeAny(subType, *(void **)input, &val);
            }
            break;
        case '{' :
            status = jsonSerializer_writeComplex(type, input, &val);
            break;
        case '[' :
            status = jsonSerializer_writeSequence(type, input, &val);
            break;
        case 'P' :
            LOG_WARNING("Untyped pointer not supported for serialization. ignoring");
            break;
        default :
            LOG_ERROR("Unsupported descriptor '%c'", descriptor);
            status = ERROR;
            break;
    }

    if (status == OK && val != NULL) {
        *out = val;
    }

    return status;
}

static int jsonSerializer_writeSequence(dyn_type *type, void *input, json_t **out) {
    assert(dynType_type(type) == DYN_TYPE_SEQUENCE);
    int status = OK;

    json_t *array = json_array();
    dyn_type *itemType = dynType_sequence_itemType(type);
    uint32_t len = dynType_sequence_length(input);

    int i = 0;
    void *itemLoc = NULL;
    json_t *item = NULL;
    for (i = 0; i < len; i += 1) {
        item = NULL;
        status = dynType_sequence_locForIndex(type, input, i, &itemLoc);
        if (status == OK) {
            status = jsonSerializer_writeAny(itemType, itemLoc, &item);
            if (status == OK) {
                json_array_append(array, item);
                json_decref(item);
            }
        }

        if (status != OK) {
            break;
        }
    }

    if (status == OK && array != NULL) {
        *out = array;
    }

    return status;
}

static int jsonSerializer_writeComplex(dyn_type *type, void *input, json_t **out) {
    assert(dynType_type(type) == DYN_TYPE_COMPLEX);
    int status = OK;

    json_t *val = json_object();
    struct complex_type_entry *entry = NULL;
    struct complex_type_entries_head *entries = NULL;
    int index = -1;

    status = dynType_complex_entries(type, &entries);
    if (status == OK) {
        TAILQ_FOREACH(entry, entries, entries) {
            void *subLoc = NULL;
            json_t *subVal = NULL;
            dyn_type *subType = NULL;
            index = dynType_complex_indexForName(type, entry->name);
            status = dynType_complex_valLocAt(type, index, input, &subLoc);
            if (status == OK ) {
                status = dynType_complex_dynTypeAt(type, index, &subType);
            }
            if (status == OK) {
                status = jsonSerializer_writeAny(subType, subLoc, &subVal);
            }
            if (status == OK) {
                json_object_set(val, entry->name, subVal);
                json_decref(subVal);
            }

            if (status != OK) {
                break;
            }
        }
    }

    if (status == OK && val != NULL) {
        *out = val;
    }

    return status;
}