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

//List implementation

typedef struct listnode listnode_t;
struct listnode {
    listnode_t  *next;
    void        *item;
};

struct list {
    listnode_t *head;
    int numitems;
};


// Create new list
list_t *list_create(void)
{
list_t *myList;
myList = malloc(sizeof(list_t));
myList->head = NULL;
myList->numitems = 0;

return myList;

}

// Free list. items not freed.
void list_destroy(list_t *list)
{
listnode_t *curr;
listnode_t *neste;
curr = list->head;

if (curr != NULL){
	neste = curr->next;
	}

	while (curr != NULL){
	free(curr);
	curr = neste;

	if(curr != NULL){
		neste = curr->next;
		}
	}
	free(list);
}

// Insert item first in list
int list_addfirst(list_t *list, void *item)
{
listnode_t *myNode;
myNode = malloc(sizeof(listnode_t));
myNode->item = item;

myNode->next = list->head;
list->head = myNode;

return 1;
}

// Insert item last in list.
int list_addlast(list_t *list, void *item)
{
listnode_t *myNode;
listnode_t *selNode = list->head;
myNode = malloc(sizeof(listnode_t));

myNode->item = item;
myNode->next = NULL;

if(selNode == NULL){
	list->head = myNode;
	}
	else{
		while(selNode->next != NULL) {
			selNode = selNode->next;
			}
	selNode->next = myNode;
	}

return 0;
}

// Remove item from list
void list_remove(list_t *list, void *item)
{
listnode_t *selNode = list->head;

if(selNode != NULL){
	if(selNode->item == item){
		list->head = selNode->next;
		free(selNode);
		return;
		}
		if(selNode->next != NULL){
			while((selNode->next)->item != item && (selNode->next)->next != NULL){
				selNode = selNode->next;

			}
			listnode_t *removeNode = selNode->next;
			selNode->next = selNode->next->next;
			free(removeNode);
		}
	}
}


// Return # of items in list
int list_size(list_t *list)
{
return list->numitems;
}

//Iterator implementation
 struct list_iterator {
    listnode_t *next;
    list_t *list;
};

// Create new list iterator
list_iterator_t *list_createiterator(list_t *list)
{
list_iterator_t *iterator;
iterator = (list_iterator_t *)malloc(sizeof(list_iterator_t));
iterator->next = list->head;
iterator->list = list;
return iterator;
}

// Free iterator
void list_destroyiterator(list_iterator_t *iter)
{
free(iter);
}

// Move iterator to next item in list and return current.
void *list_next(list_iterator_t *iter)
{
void *value;
value = NULL;


if (iter->next != 0){
	value = iter->next->item;
	iter->next = iter->next->next;
	}
return value;

}


// Let iterator point to first item in list again
void list_resetiterator(list_iterator_t *iter)
{
iter->next = iter->list->head;

}