#include "alloc.h"
#include "common.h"
#include "list.h"

List* List_Create()
{
    List* list = (List*)kmalloc(sizeof(List));

    memset((uint8*)list, 0, sizeof(List));

    return list;
}

void List_Clear(List* list)
{
    ListNode* listNode = list->head;

    while (NULL != listNode)
    {
        ListNode* next = listNode->next;

        kfree(listNode);

        listNode = next;
    }

    list->head = NULL;
    list->tail = NULL;
}

void List_Destroy(List* list)
{
    List_Clear(list);

    kfree(list);
}

List* List_CreateClone(List* list)
{
    List* newList = List_Create();

    List_Foreach(n, list)
    {
        List_Append(newList, n->data);
    }

    return newList;
}

BOOL List_IsEmpty(List* list)
{
    //At empty state, both head and tail are null!
    return list->head == NULL;
}

void List_Append(List* list, void* data)
{
    ListNode* node = (ListNode*)kmalloc(sizeof(ListNode));

    memset((uint8*)node, 0, sizeof(ListNode));
    node->data = data;

    //At empty state, both head and tail are null!
    if (NULL == list->tail)
    {
        list->head = node;

        list->tail = node;

        return;
    }

    node->previous = list->tail;
    node->previous->next = node;
    list->tail = node;
}

void List_Prepend(List* list, void* data)
{
    ListNode* node = (ListNode*)kmalloc(sizeof(ListNode));

    memset((uint8*)node, 0, sizeof(ListNode));
    node->data = data;

    //At empty state, both head and tail are null!
    if (NULL == list->tail)
    {
        list->head = node;

        list->tail = node;

        return;
    }

    node->next = list->head;
    node->next->previous = node;
    list->head = node;
}

ListNode* List_GetFirstNode(List* list)
{
    return list->head;
}

ListNode* List_GetLastNode(List* list)
{
    return list->tail;
}

ListNode* List_FindFirstOccurrence(List* list, void* data)
{
    List_Foreach(n, list)
    {
        if (n->data == data)
        {
            return n;
        }
    }

    return NULL;
}

int List_FindFirstOccurrenceIndex(List* list, void* data)
{
    int result = 0;

    List_Foreach(n, list)
    {
        if (n->data == data)
        {
            return result;
        }

        ++result;
    }

    return -1;
}

int List_GetCount(List* list)
{
    int result = 0;

    List_Foreach(n, list)
    {
        ++result;
    }

    return result;
}

void List_RemoveNode(List* list, ListNode* node)
{
    if (NULL == node)
    {
        return;
    }

    if (NULL != node->previous)
    {
        node->previous->next = node->next;
    }

    if (NULL != node->next)
    {
        node->next->previous = node->previous;
    }

    if (node == list->head)
    {
        list->head = node->next;
    }

    if (node == list->tail)
    {
        list->tail = node->previous;
    }

    kfree(node);
}

void List_RemoveFirstNode(List* list)
{
    if (NULL != list->head)
    {
        List_RemoveNode(list, list->head);
    }
}

void List_RemoveLastNode(List* list)
{
    if (NULL != list->tail)
    {
        List_RemoveNode(list, list->tail);
    }
}

void List_RemoveFirstOccurrence(List* list, void* data)
{
    ListNode* node = List_FindFirstOccurrence(list, data);

    if (NULL != node)
    {
        List_RemoveNode(list, node);
    }
}

Stack* Stack_Create()
{
    Stack* stack = (Stack*)kmalloc(sizeof(Stack));

    memset((uint8*)stack, 0, sizeof(Stack));

    stack->list = List_Create();

    return stack;
}

void Stack_Clear(Stack* stack)
{
    List_Clear(stack->list);
}

void Stack_Destroy(Stack* stack)
{
    List_Destroy(stack->list);

    kfree(stack);
}

BOOL Stack_IsEmpty(Stack* stack)
{
    return List_IsEmpty(stack->list);
}

void Stack_Push(Stack* stack, void* data)
{
    List_Prepend(stack->list, data);
}

void* Stack_Pop(Stack* stack)
{
    void* result = NULL;

    ListNode* node = List_GetFirstNode(stack->list);

    if (NULL != node)
    {
        result = node->data;

        List_RemoveNode(stack->list, node);
    }

    return result;
}

Queue* Queue_Create()
{
    Queue* queue = (Queue*)kmalloc(sizeof(Queue));

    memset((uint8*)queue, 0, sizeof(Queue));

    queue->list = List_Create();

    return queue;
}

void Queue_Clear(Queue* queue)
{
    List_Clear(queue->list);
}

void Queue_Destroy(Queue* queue)
{
    List_Destroy(queue->list);

    kfree(queue);
}

BOOL Queue_IsEmpty(Queue* queue)
{
    return List_IsEmpty(queue->list);
}

void Queue_Enqueue(Queue* queue, void* data)
{
    List_Append(queue->list, data);
}

void* Queue_Dequeue(Queue* stack)
{
    void* result = NULL;

    ListNode* node = List_GetFirstNode(stack->list);

    if (NULL != node)
    {
        result = node->data;

        List_RemoveNode(stack->list, node);
    }

    return result;
}