/* eurephia_values.c  --  Generic interface for processing key->value pairs
 *
 *  GPLv2 - Copyright (C) 2008  David Sommerseth <dazo@users.sourceforge.net>
 *
 *  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; version 2
 *  of the License.
 *
 *  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, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <eurephia_nullsafe.h>
#include <eurephia_context.h>
#include <eurephia_log.h>


eurephiaVALUES *eGet_valuestruct(eurephiaVALUES *vls, const char *key)
{
        eurephiaVALUES *ptr = NULL;

        if( vls == NULL ) {
                return NULL;
        }

        ptr = vls;
        while( ptr != NULL ) {
                if( (key != NULL) && (ptr->key != NULL) && (strcmp(key, ptr->key) == 0) ) {
                        return ptr;
                }
                ptr = ptr->next;
        }
        return NULL;
}


char *eGet_value(eurephiaVALUES *vls, const char *key)
{
        eurephiaVALUES *ptr = NULL;

        ptr = eGet_valuestruct(vls, key);
        return (ptr != NULL ? ptr->val : NULL);
}


eurephiaVALUES *eCreate_value_space(eurephiaCTX *ctx, int evgid)
{
        eurephiaVALUES *ptr = NULL;

        DEBUG(ctx, 32, "Function call: eCreate_value_space(ctx, %i)", evgid);

        ptr = (eurephiaVALUES *) malloc(sizeof(eurephiaVALUES) + 2);
        if( ptr == NULL ) {
                eurephia_log(ctx, LOG_PANIC, 0, "Could not allocate memory for a new eurephiaVALUE struct");
                return NULL;
        }
        memset(ptr, 0, sizeof(eurephiaVALUES) + 2);
        ptr->evgid = evgid;
        return ptr;
}


void eAdd_value(eurephiaCTX *ctx, eurephiaVALUES *vls, const char *key, const char *val)
{
        eurephiaVALUES *ptr = NULL, *ptr2 = NULL;
        int vid = 0;

        DEBUG(ctx, 31, "Function call: eAdd_value(ctx, vls(%i), '%s', '%s')",
              (vls != NULL ? vls->evid : -1), key, val);

        // Allocate buffer and safe values
        ptr = eCreate_value_space(ctx, vls->evid);
        if( ptr == NULL ) {
                eurephia_log(ctx, LOG_FATAL, 0, "Could not add the new value");
                return;
        }
        ptr->key = strdup_nullsafe(key);
        ptr->val = strdup_nullsafe(val);
        ptr->evgid = vls->evgid;

        // Add values to the value chain, loop to the end and append it
        ptr2 = vls;
        while( ptr2->next != NULL ) {
                vid = ptr2->evid;
                ptr2 = ptr2->next;
        }
        ptr->evid = vid+1; // Increase the value counter
        ptr2->next = ptr;
}


void do_free_vals(eurephiaVALUES *vls) {
        if( vls->next != NULL ) {
                do_free_vals(vls->next);
        }
        free_nullsafe(vls->key);
        free_nullsafe(vls->val);
        free_nullsafe(vls);
}

void eFree_values_func(eurephiaCTX *ctx, eurephiaVALUES *vls) {
        DEBUG(ctx, 31, "Function call: eFree_values(ctx, vls(%i))",
              (vls != NULL ? vls->evid : -1));

        if( (vls == NULL) ) {
                return;
        }
        do_free_vals(vls);
}