#include <stdlib.h>
#include <assert.h>

#include "state_set.h"

#define PRIME_ONE 811
#define PRIME_TWO 853
#define ARRAY_SIZE 1000000
#define INITIAL_SLOT_SIZE 5L

struct state_set
{
    struct state **state_array[ARRAY_SIZE];
    size_t slot_sizes[ARRAY_SIZE];
    size_t slot_memory[ARRAY_SIZE];
};

void error_validate_pointer(void *ptr)
{
    assert(ptr != NULL);
}

struct state_set *state_set_init()
{
    struct state_set *new_set =
            malloc(sizeof(struct state_set));

    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        new_set->slot_sizes[i] = 0;
        new_set->slot_memory[i] = INITIAL_SLOT_SIZE;
    }
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        new_set->state_array[i] =
                malloc(new_set->slot_memory[i] * sizeof(struct state*));
        error_validate_pointer(new_set->state_array[i]);
    }

    return new_set;
}

int node_get_id(int s)
{
    return s;
}


void state_set_resize_slot(struct state_set *set, int slot_i)
{
    struct state **to_resize = set->state_array[slot_i];
    to_resize =
            realloc(to_resize, set->slot_memory[slot_i] * 2 * sizeof(struct state*));
    error_validate_pointer(to_resize);
    set->slot_memory[slot_i] *= 2;
}

long int state_set_hash(struct state *state)
{
    long int a = node_get_id(state->previous_word);
    long int b = node_get_id(state->n);
    long int c = state->suf_id;

    long int h = ((a * PRIME_ONE + b) * PRIME_TWO + c) % ARRAY_SIZE;

    return 1;
}

int state_is_equal(struct state *s1, struct state *s2)
{
    return (s1->n == s2->n && s1->previous_word == s2->previous_word && s1->suf_id == s2->suf_id);
}

int state_set_add(struct state_set *set, struct state *state)
{
    state_set_resize_slot(set, 1);
    long int h = state_set_hash(state);
    struct state **states = set->state_array[h];

    for (int i = 0; i < set->slot_sizes[h]; i++)
    {
        if (state_is_equal(state, states[i]))
            return 0;
    }

    if (set->slot_sizes[h] + 1 > set->slot_memory[h])
    {
        state_set_resize_slot(set, h);
    }

    states[set->slot_sizes[h]] = state;
    set->slot_sizes[h] += 1;
    return 1;
}

void state_set_done(struct state_set *set)
{
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        free(set->state_array[i]);
    }
    free(set);
}