#ifndef ___DOUBLE_LINKED_LIST__
#define ___DOUBLE_LINKED_LIST__

#include <iostream>
#include <cassert>

template <typename T>
class dnode
{
public:
	T data;
	dnode<T>* prev, * next;

	dnode() { prev = next = NULL; }
	dnode(const T elem) { data = elem; prev = next = 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 ++i
	Itr<T> operator++(int); //post-increment i++
	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; };

	bool operator==(const Itr<T> itr2)
	{
		if (itr2 == NULL)
		{
			if (current == NULL)
				return true;
			else
				return false;
		}

		if (currnt == itr2.current)
			return true;
		else
			return false;
	}
	bool operator!=(Itr<T> itr2) { return !(*this == itr2); }
};

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

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

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

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


template <typename T>
class DList
{
private:
	dnode<T>* front, * rear;
	
public:
	DList() { front = rear = NULL; }
	~DList()
	{
		dnode<T>* temp;
		while (front != NULL)
		{
			temp = front;
			front = front->next;
			delete temp;
		}
	}

	bool isEmpty() const { return (front == NULL); }
	bool isFull() const 
	{
		dnode<T>* temp = new dnode<T>;
		if (temp != NULL)
		{
			delete temp;
			return false;
		}
		else
			return true;
	}

	const Itr<T> operator[](int) const;
	Itr<T>& operator[](int);

	const Itr<T> find(const T &elem) const;
	Itr<T>& find(const T & elem);

	const Itr<T> begin() const { return Itr<T>(front); }
	Itr<T>& begin()  { Itr<T>* i = new Itr<T>(front); return *i; }
	// Itr<T>& begin() { return Itr<T>(front); }

	const Itr<T> end() const { return Itr<T>(rear); }
	Itr<T>& end() { Itr<T>* i = new Itr<T>(rear); return *i; }
	// Itr<T>& end() { return Itr<T>(rear); }

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

	void remove(Itr<T> iterator);

};

template <typename T>
const Itr<T> DList<T>::operator[](int n) const
{
	assert(n >= 0);

	dnode<T>* tmp = front;

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

	return Itr<T>(tmp);
}

template <typename T>
Itr<T>& DList<T>::operator[](int n)
{
	assert(n >= 0);

	dnode<T>* tmp = front;

	for (int i = 0; i < n; i++)
	{
		if (tmp == NULL)
			break;
		tmp = tmp->next;
	}
	Itr<T>* iter = new Iter<T>(tmp);
	return *iter;
}

template <typename T>
const Itr<T> DList<T>::find(const T& elem)
{
	dnode<T>* tmp = front;
	while (tmp != NULL && tmp->data != elem)
		tmp = tmp->next;

	return Itr<T>(tmp);
}

template <typename T>
void DList<T>::insertBeforeNode(const T& elem, Itr<T> iterator)
{
	dnode<T>* newNode = new dnode<T>(elem);
	// list is empty
	if (front == NULL)
	{
		front = rear = newNode;
		return;
	}

	// iterator is pointing to front of the list
	if (iterator.operator->() == front)
	{

	}


#endif