#include <stdio.h>
#include <stdlib.h>
#include "linkedList.h"

typedef struct node{
    int value;
    struct node *next;
} node;

typedef struct linkedList{
    node *list;
} linkedList;

node *initNode (void){
    node *newNode = malloc(sizeof(node));
    if (newNode == NULL){
        fprintf(stderr, "New node memory allocation error\n");
        return NULL;
    }
    newNode->next = NULL;
    return newNode;
}

linkedList *initLinkedList (void){
    linkedList *newList = malloc(sizeof(linkedList));
    if (newList == NULL){
        fprintf(stderr, "New linkedList memory allocation error\n");
        return NULL;
    }
    newList->list = NULL;
    return newList;
}

void pushBack (linkedList *L, node *n){
    if (L->list == NULL){
        L->list = n;
        return;
    }

    node *currNode = L->list;
    while (currNode->next != NULL){
        currNode = currNode->next;
    }
    currNode->next = n;
}

void emplaceBack (linkedList *L, int v){
    node *newNode = initNode();
    newNode->value = v;

    pushBack(L, newNode);
}

void pushFront (linkedList *L, node *n){
    n->next = L->list;
    L->list = n;
}

void emplaceFront (linkedList *L, int v){
    node *newNode = initNode();
    newNode->value = v;

    pushFront(L, newNode);
}

void insert (linkedList *L, node *n, int iter){
    if (iter == 0){
        pushFront(L, n);
        return;
    }
    if (L->list == NULL){
        fprintf(stderr, "Node insertion error\n");
        return;
    }

    node *currNode = L->list;
    while (currNode->next != NULL && --iter){
        currNode = currNode->next;
    }
    if (iter){
        fprintf(stderr, "Node insertion error\n");
        return;
    }
    n->next = currNode->next;
    currNode->next = n;
}

void emplace (linkedList *L, int v, int iter){
    node *newNode = initNode();
    newNode->value = v;
    insert(L, newNode, iter);
}

void popBack (linkedList *L){
    if (L->list == NULL){
        return;
    }
    node *currNode = L->list;
    if (currNode->next == NULL){
        free(currNode);
        L->list = NULL;
        return;
    }
    node *prevNode;
    while (currNode->next != NULL){
        prevNode = currNode;
        currNode = currNode->next;
    }
    free(currNode);
    prevNode->next = NULL;

}

void popFront (linkedList *L){
    if (L->list == NULL){
        return;
    }
    node *currNode = L->list;
    if (currNode->next == NULL){
        free(currNode);
        L->list = NULL;
        return;
    }
    L->list = currNode->next;
    free(currNode);
}

void erase (linkedList *L, int iter){
    if (iter == 0){
        popFront(L);
        return;
    }
    extern node *get(linkedList *, int);
    node *prevNode = get(L, iter - 1);
    node *currNode = prevNode->next;
    prevNode->next = currNode->next;
    free(currNode);

}

void clear (linkedList *L){
    node *currNode = L->list;
    node *prevNode;
    while (currNode != NULL){
        prevNode = currNode;
        currNode = currNode->next;
        free(prevNode);
    }
    free(currNode);
    L->list = NULL;
}

node *get (linkedList *L, int iter){
    node *currNode = L->list;
    iter++;
    while (currNode != NULL && --iter){
        currNode = currNode->next;
    }
    if (iter){
        fprintf(stderr, "Node getting error\n");
        return NULL;
    }
    return currNode;
}

int size (linkedList *L){
    int s = 0;
    node *currNode = L->list;
    while (currNode != NULL){
        s++;
        currNode = currNode->next;
    }
    return s;
}

node *getPrev (linkedList *L, node *n){
    node *currNode = L->list;
    node *prevNode = NULL;
    while (currNode != NULL && currNode != n){
        prevNode = currNode;
        currNode = currNode->next;
    }
    if (currNode == NULL || prevNode == NULL){
        fprintf(stderr, "Previous node getting error\n");
        return NULL;
    }
    return prevNode;
}

node *getNext (linkedList *L, node *n){
    if (n->next == NULL){
        fprintf(stderr, "Next node getting error\n");
    }
    return n->next;
}

void printLinkedList (linkedList *L){
    node *currNode = L->list;
    while (currNode != NULL){
        printf("%d ", currNode->value);
        currNode = currNode->next;
    }
    printf("\n");
}




int main (int argc, char **argv){
    linkedList *list = initLinkedList();
    printLinkedList(list);
    for (int i = 0; i < 10; i++){
        emplaceBack(list, i);
    }
    printLinkedList(list);
    for (int i = -1; i > -10; i--){
        emplaceFront(list, i);
    }
    printLinkedList(list);
    emplace(list, 60, 5);
    printLinkedList(list);
    erase(list, 5);
    printLinkedList(list);
    printf("%d\n", size(list));
    clear(list);
    printLinkedList(list);
    free(list);
}