/**
 * dyntype.c: structur to hold values of different type and retrieve them again
 * Copyright (C) 2011  Georg Hopp
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <json/json.h>

#include "token/dyntype.h"
#include "token/dyntype/hash.h"


static
void
__construct(struct DYNTYPE * _this, va_list * params)
{
    _this->type = va_arg(* params, enum DYNTYPE_TYPES);
    _this->size = va_arg(* params, size_t);

    switch(_this->type) {
        case DYNTYPE_TYPE_INT:
            (_this->data)._int = va_arg(* params, int);
            break;

        case DYNTYPE_TYPE_STRING:
            (_this->data)._string = calloc(_this->size + 1, sizeof(char));
            memcpy((_this->data)._string, va_arg(* params, const char *), _this->size);
            break;

        case DYNTYPE_TYPE_HASH:
            (_this->data)._hash = va_arg(* params, struct DYNTYPE_HASH *);
            break;

        default:
            (_this->data)._hash = NULL;
    }
}

static
void
__jsonConst(struct DYNTYPE * _this, struct json_object * json)
{
    switch (json_object_get_type(json)) {
        case json_type_int:
            _this->type = DYNTYPE_TYPE_INT;
            _this->size = sizeof(int);
            (_this->data)._int = (int)json_object_get_int(json);
            break;

        case json_type_string:
            {
                const char * string = json_object_get_string(json);

                _this->type = DYNTYPE_TYPE_STRING;
                _this->size = strlen(string);
                (_this->data)._string = calloc(_this->size + 1, sizeof(char));
                memcpy((_this->data)._string, string, _this->size);
                // the json object handles the memory for string....
            }
            break;

        case json_type_object:
            _this->type = DYNTYPE_TYPE_HASH;
            _this->size = sizeof(struct DYNTYPE_HASH *);
            (_this->data)._hash = newFromJson(DYNTYPE_HASH, json);
            break;

        default:
            _this->type = DYNTYPE_TYPE_NULL;
            _this->size = 0;
            (_this->data)._hash = NULL;
    }
}

static
void
__destruct(struct DYNTYPE * _this)
{
    if (_this) {
        switch(_this->type) {
            case DYNTYPE_TYPE_STRING:
                free((_this->data)._string);
                break;

            case DYNTYPE_TYPE_HASH:
                delete((_this->data)._hash);
                break;

            default:
                break;
        }
    }
}

static
struct json_object *
__toJson(struct DYNTYPE * _this)
{
    struct json_object * json = NULL;

    switch(_this->type) {
        case DYNTYPE_TYPE_INT:
            json = json_object_new_int((_this->data)._int);
            break;

        case DYNTYPE_TYPE_STRING:
            json = json_object_new_string((_this->data)._string);
            break;

        case DYNTYPE_TYPE_HASH:
            json = toJson((_this->data)._hash);
            break;

        default:
            json = NULL;
    }

    return json;
}

static const
struct CCLASS _dyntype = {
    sizeof(struct DYNTYPE),
    (ctor)__construct,
    (jCtor)__jsonConst,
    (dtor)__destruct,
    (jTo)__toJson
};

const struct CCLASS * const DYNTYPE = &_dyntype;

// vim: set et ts=4 sw=4: