#include "linked_list.h"
#include "malloc.h"

void linked_list_init(linked_list_t *linked_list, const size_t data_size)
{
    linked_list->data_size = data_size;
    linked_list->first = NULL;
    linked_list->last = NULL;
}

elem_t *elem_create(linked_list_t *linked_list)
{
    elem_t *elem;
    elem = malloc(sizeof(elem_t));
    if(!elem) return NULL;

    elem->data = malloc(linked_list->data_size);
    if(!elem->data)
    {
        free(elem);
        return NULL;
    }

    return elem;
}

void linked_list_push_back(linked_list_t *linked_list, elem_t *elem)
{
    if(!elem) return;

    elem->prev = linked_list->last;
    elem->next = NULL;

    if(linked_list->last)
        linked_list->last->next = elem;
    else
        linked_list->first = elem;

    linked_list->last = elem;
}

void linked_list_push_front(linked_list_t *linked_list, elem_t *elem)
{
    if(!elem) return;

    elem->next = linked_list->first;
    elem->prev = NULL;

    if(linked_list->first)
        linked_list->first->prev = elem;
    else
        linked_list->last = elem;

    linked_list->first = elem;
}

void linked_list_pop_back(linked_list_t *linked_list)
{
    elem_t *tmp = linked_list->last;
    if(!tmp) return;

    linked_list->last = tmp->prev;

    if(linked_list->last)
        linked_list->last->next = NULL;
    else
        linked_list->first = NULL;

    free(tmp->data);
    free(tmp);
}

void linked_list_pop_front(linked_list_t *linked_list)
{
    elem_t *tmp = linked_list->first;
    if(!tmp) return;

    linked_list->first = tmp->next;

    if(linked_list->first)
        linked_list->first->prev = NULL;
    else
        linked_list->last = NULL;

    free(tmp->data);
    free(tmp);
}

size_t linked_list_get_size(linked_list_t *linked_list)
{
    elem_t *actual_elem = linked_list->first;
    if(!actual_elem) return 0;

    size_t size = 0;
    while(actual_elem)
    {
        actual_elem = actual_elem->next;
        size++;
    }
    return size;
}

bool linked_list_is_empty(linked_list_t *linked_list)
{
   return !linked_list->first;
}

bool linked_list_is_in_bound(linked_list_t *linked_list, size_t index)
{
    return index < linked_list_get_size(linked_list);
}

elem_t *linked_list_get_elem(linked_list_t *linked_list, size_t index)
{
    if(!linked_list_is_in_bound(linked_list, index)) return NULL;

    elem_t *actual_elem = linked_list->first;
    if(!actual_elem) return NULL;

    for (size_t i = 0; i < index; i++)
    {
        actual_elem = actual_elem->next;
    }

    return actual_elem;
}
/*
void linked_list_insert(linked_list_t *linked_list, elem_t *elem, size_t index)
{
    
}*/