#ifndef __D_LIST_HPP__
#define __D_LIST_HPP__
#include <iostream>
#include <cassert>

template <typename T>
class dnode
{
public:
	T data;
	dnode<T>* next, * prev;
	dnode() {
		next = prev = NULL;
	}
	dnode(const T& x)
	{
		data = x;
		next = prev = NULL;
	}
};

template <typename T>
class Itr
{
private:
	dnode<T>* current;

public:
	Itr() {
		current = NULL;
	}
	Itr(dnode<T>* ptr) {
		current = ptr;
	}
	Itr<T>& operator++(); //pre-increment x = ++i;   // i = 1;  x = 2
	Itr<T> operator++(int); //post-increment y = i++;	// i = 1; y = 1
	Itr<T>& operator--(); //pre-decrement --i
	Itr<T> operator--(int); //post-decrement i--
	T operator*() const { return current->data; };
	T& operator*() { return current->data; };
	const dnode<T>* operator->() const { return current; };
	dnode<T>* operator->() { return current; };
};

//pre-increment ++i
template <typename T>
Itr<T>& Itr<T>::operator++()
{
	if (current != NULL)
		current = current->next;
	return *this;	// return the iterator after the movement
}

//post-increment
template <typename T>
Itr<T> Itr<T>::operator++(int)
{
	Itr<T> itr(current);
	if (current != NULL)
		current = current->next;
	return itr;		// return the original iterator
}


//pre-decrement --i
template <typename T>
Itr<T>& Itr<T>::operator--()
{
	if (current != NULL)
		current = current->prev;
	return *this;	// return the iterator after the movement
}

//post-decrement
template <typename T>
Itr<T> Itr<T>::operator--(int)
{
	Itr<T> itr(current);
	if (current != NULL)
		current = current->prev;
	return itr;		// return the original iterator
}

template <typename T>
class DList
{
private:
	dnode<T>* front, * rear;

public:
	DList() { front = rear = NULL;  }
	DList(T elem) {
		dnode<T>* newNode = new dnode<T>(elem);
		front = rear = newNode;
	}
	DList(const DList<T>& list2);
	~DList();

	Itr<T>& operator[](int index);
	const Itr<T> operator[](const int index) const;
	Itr<T> begin() { Itr<T> tmp(front);  return tmp; }
	Itr<T> end() { Itr<T> tmp(rear);  return tmp; }
	bool isEmpty() { return front == NULL; }

	void insertBeforeNode(const T& elem, Itr<T> cur);
	void insertAfterNode(const T&elem, Itr<T> cur);
	void remove(Itr<T> cur);

};

template <typename T>
Itr<T>& DList<T>::operator[](int index)
{
	dnode<T>* temp = front;

	for (int i = 0; i <= index; i++)
	{
		if (temp == NULL)
			break;
		temp = temp->next;
	}

	Itr<T> itr(temp);
	return itr;
}

template <typename T>
const Itr<T> DList<T>::operator[](const int index) const
{
	Itr<T> itr(front);
	
	for (int i = 0; i <= index; i++)
	{
		if (itr.operator->() == NULL)
			break;
		itr++;
	}
	
	return itr;
}

template <typename T>
void DList<T>::insertBeforeNode(const T& elem, Itr<T> cur)
{
	dnode<T>* newNode = new dnode<T>(elem);

	// if the list is empty
	if (front == NULL)
	{
		front = rear = newNode;
	}
	else
	{
		// if cur is the first node in the list
		if (cur.operator->() == front)
		{
			newNode->next = front;
			front->prev = newNode;
			front = newNode;
		}
		else
		{
			newNode->next = cur.operator->();
			newNode->prev = cur->prev;
			cur->prev->next = newNode;
			cur->prev = newNode;
		}
	}

}


template <typename T>
void DList<T>::insertAfterNode(const T& elem, Itr<T> cur)
{
	dnode<T>* newNode = new dnode<T>(elem);

	// if the list is empty
	if (front == NULL)
	{
		front = rear = newNode;
	}
	else
	{
		// if cur is the last node in the list
		if (cur.operator->() == rear)
		{
			newNode->prev = rear;
			rear->next = newNode;
			rear = newNode;
		}
		else
		{
			newNode->next = cur->next;
			newNode->prev = cur.operator->();
			cur->next->prev = newNode;
			cur->next = newNode;
		}
	}
}

template <typename T>
void DList<T>::remove(Itr<T> cur)
{
	assert(!isEmpty());

	if (cur.operator->() == front)
	{
		// removing the front node
		front = front->next;
	}
	else
	{
		// Step 1, update the next pointer of previous node
		cur->prev->next = cur->next;
	}

	if (cur.operator->() == rear)
	{
		rear = rear->prev;
	}
	else
	{
		// Step 2, update the previous pointer of next node
		cur->next->prev = cur->prev;
	}

/*
	// Step 1, update the next pointer of previous node
	cur->prev->next = cur->next;

	// Step 2, update the previous pointer of next node
	cur->next->prev = cur->prev;

*/

	// Step 3, delete the node
	delete cur.operator->();

}

template <typename T>
DList<T>::DList(const DList<T>& list2)
{
	// list2 is empty
	if (list2.front == NULL)
	{
		front = rear = NULL;
	}
	else
	{
		front = rear = NULL;
		dnode<T>* temp = list2.front;

		while (temp != NULL)
		{
			dnode<T>* newNode = new dnode<T>(temp->data);
			if (front == NULL)
			{
				front = rear = newNode;
			}
			else
			{
				rear->next = newNode;
				newNode->prev = rear;
				rear = newNode;
			}

			temp = temp->next;
		}
	}
}

template <typename T>
DList<T>::~DList()
{
	dnode<T>* temp;

	while (front != NULL)
	{
		temp = front;
		front = front->next;
		delete temp;
	}
}

#endif