/*
 ============================================================================
 Name        : hashset.c
 Author      : martin.dvorak@mindforger.com
 Copyright   : Apache 2.0
 Description : Hash set
 ============================================================================
*/

#include "include/hashset.h"
#include "include/hstr_utils.h"

unsigned int hashmap_hash(const char *str)
{
    int i;
    unsigned int result=5381;

    for(i=0; str[i]!='\0'; i++) {
        result=result*33+str[i];
    }
    result = result^(result>>16);

    return result%HASH_MAP_SIZE;
}

void hashset_init(HashSet * hs)
{
    int i;
    hs->currentSize = 0;
    for(i = 0; i<HASH_MAP_SIZE; i++) {
        hs->lists[i] = NULL;
    }
}

void *hashset_get(const HashSet * hs, const char *key)
{
    int listNum = hashmap_hash( key );
    struct HashSetNode *ptr = hs->lists[ listNum ];

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

    return (ptr!=NULL?ptr->value:NULL);
}

int hashset_contains(const HashSet * hs, const char *key)
{
	return (hashset_get(hs, key) != NULL);
}

int hashset_put(HashSet *hs, const char *key, void *value)
{
    if(hashset_get(hs, key)) {
        return 0;
    } else {
        int listNum = hashmap_hash( key );
        struct HashSetNode *newNode=(struct HashSetNode *)malloc(sizeof(struct HashSetNode));
        if(newNode == NULL) {
            fprintf(stderr,"Unable to allocate hashset entry!");
            return 0;
        }

        newNode->key=malloc(strlen(key)+1);
        strcpy(newNode->key, key);
        newNode->value=value;
        newNode->next=hs->lists[listNum];
        hs->lists[listNum]=newNode;
        hs->currentSize++;

        return 1;
    }
}

int hashset_add(HashSet * hs, const char *key)
{
	return hashset_put(hs, key, "nil");
}

int hashset_size(const HashSet *hs)
{
    return hs->currentSize;
}

void hashset_stat(const HashSet *hs)
{
    int i;
    struct HashSetNode *ptr;
    for(i=0; i<HASH_MAP_SIZE; i++) {
        for(ptr=hs->lists[i]; ptr!=NULL; ptr=ptr->next) {
            printf("%s\n",ptr->key);
        }
    }
}

char** hashset_keys(const HashSet *hs)
{
	if(hs->currentSize) {
	    char **result=malloc(sizeof(char*) * hs->currentSize);
		int i=0, j=0;
		struct HashSetNode *p;
		for(i=0; i<HASH_MAP_SIZE; i++) {
	    	p=hs->lists[i];
	    	while(p && p->next) {
	    		result[j++]=hstr_strdup(p->key);
	    		p=p->next;
	    	}
	    	if(p) {
		    	result[j++]=hstr_strdup(p->key);
	    	}
	    }
		return result;
	} else {
		return NULL;
	}
}

void hashset_destroy(HashSet *hs, const bool freeValues)
{
	// only hashset keys (and possibly values) are freed - caller must free hashset itself
	if(hs && hs->currentSize) {
		int i=0;
		struct HashSetNode *p, *pp;
		for(i=0; i<HASH_MAP_SIZE; i++) {
			p=hs->lists[i];
			while(p && p->next) {
				if(p->key) {
					free(p->key);
					if(freeValues && p->value) free(p->value);
				}
				pp=p;
				p=p->next;
				free(pp);
			}
			if(p && p->key) {
				free(p->key);
				if(freeValues && p->value) free(p->value);
				free(p);
			}
		}
	}
}