#include "lmtp2nntp_val.h"
#include "lmtp2nntp_lh.h"
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>

/* usually val_object_t.data is a pointer val_object_t.data.p, but VAL_INLINE
 * signals val_object_t.data is actual data val_object_t.data.[csilfd]
 */
enum {
    VAL_INLINE      = 1<<31
};

typedef struct {
    int type;
    union {
        val_t *v;
        void  *p;
        char   c;
        short  s;
        int    i;
        long   l;
        float  f;
        double d;
    } data;
    char *desc;
} val_object_t;

struct val_s {
    lh_t *lh;
};

static void *val_storage(val_object_t *obj)
{
    void *storage;

    if (obj->type & VAL_INLINE) {
        switch (obj->type & ~VAL_INLINE) {
            case VAL_TYPE_VAL:
                storage = &obj->data.v;
                break;
            case VAL_TYPE_PTR:
                storage = &obj->data.p;
                break;
            case VAL_TYPE_CHAR:
                storage = &obj->data.c;
                break;
            case VAL_TYPE_SHORT:
                storage = &obj->data.s;
                break;
            case VAL_TYPE_INT:
                storage = &obj->data.i;
                break;
            case VAL_TYPE_LONG:
                storage = &obj->data.l;
                break;
            case VAL_TYPE_FLOAT:
                storage = &obj->data.f;
                break;
            case VAL_TYPE_DOUBLE:
                storage = &obj->data.d;
                break;
            default:
                storage = NULL;
        }
    }
    else 
        storage = obj->data.p;
    return storage;
}

val_rc_t val_create(val_t **valp)
{
    val_t *val;

    if (valp == NULL)
        return VAL_ERR_ARG;
    if ((val = (val_t *)malloc(sizeof(val_t))) == NULL)
        return VAL_ERR_SYS;
    if ((val->lh = lh_create()) == NULL) {
        free(val);
        return VAL_ERR_SYS;
    }
    *valp = val;
    return VAL_OK;
}

static int (val_destroy_cb)(void *_ctx, const void *keyptr, int keylen, const void *datptr, int datlen)
{
    val_object_t *obj;
    
    obj = (val_object_t *)datptr;
    if (obj->desc != NULL)
        free(obj->desc);
    return TRUE;
}

val_rc_t val_destroy(val_t *val)
{
    if (val == NULL)
        return VAL_ERR_ARG;
    lh_apply(val->lh, val_destroy_cb, NULL);
    if (!lh_destroy(val->lh))
        return VAL_ERR_SYS;
    free(val);
    return VAL_OK;
}

val_rc_t val_reg(val_t *val, const char *name, int type, const char *desc, void *storage)
{
    val_object_t *obj;
    val_object_t newobj;
    const char *cp;
    val_t *child;

    if (val == NULL || name == NULL || type == 0)
        return VAL_ERR_ARG;



    if ((cp = strchr(name, '.')) != NULL) {
        if (!lh_lookup(val->lh, name, cp-name, (void **)&obj, NULL))
            return VAL_ERR_ARG;
        if (!(obj->type & VAL_TYPE_VAL))
            return VAL_ERR_USE;
        child = *(val_t **)(val_storage(obj));
        return val_reg(child, cp+1, type, desc, storage);
    }



    if (desc != NULL)
        newobj.desc = strdup(desc);
    else
        newobj.desc = NULL;
    if (storage == NULL) { 
        newobj.type   = (type | VAL_INLINE);
        newobj.data.l = 0;
    }
    else {
        newobj.type   = (type & ~VAL_INLINE);
        newobj.data.p = storage;
    }
    if (!lh_insert(val->lh, name, strlen(name), &newobj, sizeof(newobj), 1))
        return VAL_ERR_SYS;

    return VAL_OK;
}

val_rc_t val_vset(val_t *val, const char *name, va_list ap)
{
    val_object_t *obj;
    void *storage;
    const char *cp;
    val_t *child;

    if (val == NULL || name == NULL || ap == NULL)
        return VAL_ERR_ARG;
    if ((cp = strchr(name, '.')) != NULL) {
        if (!lh_lookup(val->lh, name, cp-name, (void **)&obj, NULL))
            return VAL_ERR_ARG;
        if (!(obj->type & VAL_TYPE_VAL))
            return VAL_ERR_USE;
        child = *(val_t **)(val_storage(obj));
        return val_vset(child, cp+1, ap);
    }
    if (!lh_lookup(val->lh, name, strlen(name), (void **)&obj, NULL))
        return VAL_ERR_ARG;
    storage = val_storage(obj);
    switch (obj->type & ~VAL_INLINE) {
        case VAL_TYPE_VAL:
            *(val_t **)storage = (val_t *)va_arg(ap, void *);
            break;
        case VAL_TYPE_PTR:
            *(char **)storage = (char *)va_arg(ap, void *);
            break;
        case VAL_TYPE_CHAR:
            *(char *)storage = (char)va_arg(ap, int);
            break;
        case VAL_TYPE_SHORT:
            *(short *)storage = (short)va_arg(ap, int);
            break;
        case VAL_TYPE_INT:
            *(int *)storage = (int)va_arg(ap, int);
            break;
        case VAL_TYPE_LONG:
            *(long *)storage = (long)va_arg(ap, long);
            break;
        case VAL_TYPE_FLOAT:
            *(float *)storage = (float)va_arg(ap, double);
            break;
        case VAL_TYPE_DOUBLE:
            *(double *)storage = (double)va_arg(ap, double);
            break;
    }
    return VAL_OK;
}

val_rc_t val_set(val_t *val, const char *name, ...)
{
    val_rc_t rc;
    va_list ap;

    if (val == NULL || name == NULL)
        return VAL_ERR_ARG;
    va_start(ap, name);
    rc = val_vset(val, name, ap);
    va_end(ap);
    return rc;
}

val_rc_t val_vget(val_t *val, const char *name, va_list ap)
{
    val_object_t *obj;
    void *storage;
    const char *cp;
    val_t *child;

    if (val == NULL || name == NULL || ap == NULL)
        return VAL_ERR_ARG;
    if ((cp = strchr(name, '.')) != NULL) {
        if (!lh_lookup(val->lh, name, cp-name, (void **)&obj, NULL))
            return VAL_ERR_ARG;
        if (!(obj->type & VAL_TYPE_VAL))
            return VAL_ERR_USE;
        child = *(val_t **)(val_storage(obj));
        return val_vget(child, cp+1, ap);
    }
    if (!lh_lookup(val->lh, name, strlen(name), (void **)&obj, NULL))
        return VAL_ERR_ARG;
    storage = val_storage(obj);
    switch (obj->type & ~VAL_INLINE) {
        case VAL_TYPE_VAL:
            *((val_t **)va_arg(ap, void *)) = *(val_t **)storage;
            break;
        case VAL_TYPE_PTR:
            *((char **)va_arg(ap, void *)) = *(char **)storage;
            break;
        case VAL_TYPE_CHAR:
            *((char *)va_arg(ap, int *)) = *(char *)storage;
            break;
        case VAL_TYPE_SHORT:
            *((short *)va_arg(ap, int *)) = *(short *)storage;
            break;
        case VAL_TYPE_INT:
            *((int *)va_arg(ap, int *)) = *(int *)storage;
            break;
        case VAL_TYPE_LONG:
            *((long *)va_arg(ap, long *)) = *(long *)storage;
            break;
        case VAL_TYPE_FLOAT:
            *((float *)va_arg(ap, double *)) = *(float *)storage;
            break;
        case VAL_TYPE_DOUBLE:
            *((double *)va_arg(ap, double *)) = *(double *)storage;
            break;
    }
    return VAL_OK;
}

val_rc_t val_get(val_t *val, const char *name, ...)
{
    val_rc_t rc;
    va_list ap;

    if (val == NULL || name == NULL)
        return VAL_ERR_ARG;
    va_start(ap, name);
    rc = val_vget(val, name, ap);
    va_end(ap);
    return rc;
}

#define VAL_MAXNAME 1024

typedef struct {
    val_cb_t cb;
    void *ctx;
    val_rc_t rc;
} val_apply_ctx_t;

static int (val_apply_cb)(void *_ctx, const void *keyptr, int keylen, const void *datptr, int datlen)
{
    val_apply_ctx_t *ctx = (val_apply_ctx_t *)_ctx;
    val_object_t *obj;
    char name[VAL_MAXNAME+1];

    /* on-the-fly create NUL-terminated name string */
    if (keylen > VAL_MAXNAME) {
        ctx->rc = VAL_ERR_MEM;
        return FALSE;
    }
    strncpy(name, (char *)keyptr, keylen);
    *((char *)name+keylen) = '\0';

    /* take object */
    if (datlen != sizeof(val_object_t)) {
        ctx->rc = VAL_ERR_ARG;
        return FALSE;
    }
    obj = (val_object_t *)datptr;

    /* execute VAL callback */
    if ((ctx->rc = ctx->cb(ctx->ctx, name, (obj->type & ~VAL_INLINE), obj->desc, val_storage(obj))) != VAL_OK)
        return FALSE;

    return TRUE;
}

val_rc_t val_apply(val_t *val, val_cb_t cb, void *ctx)
{
    val_apply_ctx_t val_ctx;

    if (val == NULL || cb == NULL)
        return VAL_ERR_ARG;
    val_ctx.cb  = cb;
    val_ctx.ctx = ctx;
    val_ctx.rc  = VAL_OK;
    if (!lh_apply(val->lh, val_apply_cb, &val_ctx))
        return VAL_ERR_SYS;
    return val_ctx.rc;
}