#include "List.h"

typedef struct node Node;

struct node {
    Item data;
    struct node * prev;
    struct node * next;
};

struct list {
    struct node * head;
    struct node * tail;
};

Node * create_node(Item item);

List * ListNew() {
    List * new_list = malloc(sizeof(struct list));
    new_list->head = NULL;
    new_list->tail = NULL;
    return new_list;
}

void ListDestroy(List * l) {
    while (!ListIsEmpty(l)) {
        ListRemoveStart(l);
    }
    free(l);
}

void ListInsertStart(List * l, Item item) {
    Node *n = create_node(item);
    n->next = l->head;
    if (l->head) {
        l->head->prev = n;
    }
    l->head = n;
    if (l->tail == NULL) {
        l->tail = n;
    }
}

void ListInsertEnd(List * l, Item item) {
    Node *n = create_node(item);
    n->prev = l->tail;
    if (l->tail) {
        l->tail->next = n;
    }
    l->tail = n;
    if (l->head == NULL) {
        l->head = n;
    }
}

Item ListRemoveStart(List * l) {
    assert(!ListIsEmpty(l));
    Node *node_removing = l->head;
    l->head = l->head->next;
    Item data_to_return = node_removing->data;
    if (l->tail == node_removing) {
        l->tail = NULL;
    } else {
        l->head->prev = NULL;
    }
    free(node_removing);
    return data_to_return;
}

Item ListRemoveEnd(List * l) {
    assert(!ListIsEmpty(l));
    Node *node_removing = l->tail;

    if (l->head == l->tail) {
        l->head = NULL;
        l->tail = NULL;
    } else {
        l->tail = l->tail->prev;
        l->tail->next = NULL;
    }

    Item data_to_return = node_removing->data;
    free(node_removing);
    return data_to_return;
}

int ListSize(List * l) {
    int count = 0;
    Node *curr = l->head;
    while (curr != NULL) {
        count++;
        curr = curr->next;
    }
    return count;
}

bool ListIsEmpty(List * l) {
    if (l->head == NULL) {
        return true;
    }
    return false;
}

void ListReverse(List * l) {
    // For each node, swap their prev and next. Swap head and tail of list.
    Node * curr = l->head;
    while (curr != NULL) {
        Node * next = curr->next;
        curr->next = curr->prev;
        curr->prev = next;
        curr = next;
    }
    Node * temp = l->head;
    l->head = l->tail;
    l->tail = temp;
}

char * ListToString(List * l) {
    char * s = calloc(MAX_PRINT_LENGTH, sizeof(char));
    Node * curr = l->head;
    char snum[5];
    while (curr != NULL) {
        snprintf(snum, 5, " %d", curr->data);
        strncat(s, snum, MAX_PRINT_LENGTH);
        curr = curr->next;
    }
    return s;
}

void ListDisplay(List * l) {
    Node * curr = l->head;
    while (curr != NULL) {
        printf("%d -> ", curr->data);
        curr = curr->next;
    }
    printf("NULL\n");
}

// Helper Functions

Node * create_node(Item item) {
    Node * new_node = malloc(sizeof(struct node));
    new_node->data = item;
    new_node->prev = NULL;
    new_node->next = NULL;
    return new_node;
}