// list.cpp: implementation of the list class.
//
//////////////////////////////////////////////////////////////////////

#include "list.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

list::list()
{
	listHead = 0;
	currentPos = 0;
}

list::~list()
{
	node *next;
	node * current = listHead;
	if (current == NULL) return;
	do {
		next = current->next;
		delete current;
		current = next;
	} while (current != NULL);	
}

	////////
	//	Insertion right after currentPos
	////////
void list::insert(String newName)
// Takes O(1) time.
{
	if (currentPos == NULL) { // If list is empty, its a special case
		node * newNode = new node(newName, NULL, NULL);
		currentPos = newNode;
		listHead = newNode;
		return;
	}
	node *nextNode = currentPos->next;
	node *previousNode = currentPos;
	node *newNode = new node(newName, nextNode, previousNode );
	currentPos = newNode;
	previousNode->next = newNode;
	if (nextNode != NULL)
		nextNode->previous = newNode;
}


void list::insertAtHead(String newName)
// O(1) time
{
	node *newNode = new node(newName, listHead, NULL);
	if (listHead != NULL)
		listHead->previous = newNode;
	listHead = newNode;
	currentPos = newNode;
}

void list::print() const
// O(n) time.
{
	node * current = listHead;
	if (current == 0) return;
	cout << current->element;
	while (current->next != 0) {
		current = current->next;
		cout << " " << current->element;
	}
	cout << endl;
}

int list::find(const String name)
// Set currentPos to point to the first node with name
//  Returns 1 if it finds one.
// O(n) time
{
	node * current = listHead;
	if (current == 0) return 0;
	do {
		if (current->element == name){
			currentPos = current;
			return 1;
		}
	current = current->next;
	}
	while (current != 0);
	return 0;	
}

int list::eliminate()
//eliminates the node at currentPos
// O(1) time.
{
	if (currentPos == NULL)
		return 0; //list is empty
	else if (currentPos->previous == NULL) { //current is head, special case
		listHead = currentPos ->next;
		listHead->previous = NULL;
		delete currentPos;
		currentPos = listHead;
	}
	else {
		node * prevNode = currentPos->previous;
		node * nextNode = currentPos->next;
		prevNode->next = nextNode;
		nextNode->previous = prevNode;
		delete currentPos;
		currentPos = prevNode;
	};
	return 1;
}


int list::eliminate(const String name)
// eliminates the node with name name.
// O(n) time.
{
	if (find(name) == 1){
		eliminate();
		return 1;
	}
	return 0;
}

String list::getCurrent()
//Returns the name of the current node.
// O(1) time.
{
	if (currentPos == NULL)
		return emptyString;
	return currentPos->element;
}

const list & list::operator ++(int dummy)
// Increases currentPos to point to the next one.
//  If currentPos is at the end of the list, it stays there.
// O(1)
{
	if (currentPos != NULL) {
		node * nextPos = currentPos->next;
		if (nextPos == NULL)
//			currentPos = listHead;
			currentPos = currentPos;
		else
			currentPos = nextPos;
	}
	return *this;
}


const list & list::operator --(int dummy)
// Decreases currentPos to point to the previous node.
// If there is no previous node then it stays there.
// O(1)
{
	if (currentPos != NULL) {
		node * prevPos = currentPos->previous;
		if (prevPos == NULL)
			currentPos = listHead;
		else
			currentPos = prevPos;
	}
	return *this;
}

int list::isAtHead()
// O(1)
{
	if (currentPos == NULL) //if list is empty, we are at head
		return 1;
	else if (currentPos == listHead)
		return 1;
	else
		return 0;
}

int list::isAtTail()
// O(1)
{
	if (currentPos == NULL)
		return 1;
	else if (currentPos->next == NULL)
		return 1;
	else return 0;
}