#ifndef LIST_CLASS
#define LIST_CLASS

#include <iostream>
#include <string>

#include "d_dnode.h"		// dnode class
#include "d_except.h"	// exception classes

using namespace std;

template <typename T>
class miniList
{
   public:

// include the iterator nested classes
#include "d_liter.h"

		miniList();
			// constructor. create an empty list
		miniList(int n, const T& item = T());
			// constructor. build a list with n elements, all having
			// the value item
		miniList(T* first, T* last);
			// constructor. build a list whose data comes from the
			// pointer range [first, last)
		miniList(const miniList<T>& obj);
			// copy constructor

      ~miniList();
			// destructor

      miniList<T>& operator= (const miniList<T>& rhs);
			// overloaded assignment operator

      int size() const;
			// return the size of the list
      bool empty() const;
			// is the list empty

		void push_front(const T& item);
			// insert item at the front of the list
			// Postcondition: the list size increases by 1
		void push_back(const T& item);
			// insert item at the back of the list
			// Postcondition: the list size increases by 1
		iterator insert(iterator pos, const T& item);
			// insert item before pos.
			// Postcondition: the list size increases by 1

		void pop_front();
			// erase the front of the list.
			// Precondition: the list is not empty. if the list is
			// empty, the function throws the underflowError exception.
			// Postcondition: the list size decreases by 1
		void pop_back();
			// erase the back of the list.
			// Precondition: the list is not empty. if the list is
			// empty, the function throws the underflowError exception.
			// Postcondition: the list size decreases by 1
		void erase(iterator pos);
			// erase the list element at pos
			// Precondition: the list is not empty. if the list is
			// empty, the function throws the underflowError exception.
			// Postcondition: the list size decreases by 1

		T& front();
			// return a reference to the value at the front of the list.
			// Precondition: the list is not empty. if the list is
			// empty, the function throws the underflowError exception
		const T& front() const;
			// constant version of front()
		T& back();
			// return a reference to the value at the back of the list.
			// Precondition: the list is not empty. if the list is
			// empty, the function throws the underflowError exception
		const T& back() const;
			// constant version of back()

      iterator begin();
			// return an iterator pointing at the first node in the list
			// or end() if the list is empty
      const_iterator begin() const;
			// constant version of begin()

      iterator end();
			// return an iterator pointing just past the last node of
			// the list
      const_iterator end() const;
			// constant version of end()

   private:

      // header (sentinel) node
      dnode<T> *header;

      // number of elements in the list
      int listSize;

      dnode<T> *getDNode(const T& item);
			// allocate a dnode object with the value item and
			// return a pointer to it. throw the memoryAllocationError
			// exception of the memory allocation fails

		dnode<T> *dinsert(dnode<T> *curr, const T& item);
			// insert item before node curr of the linked list and
			// return the address of the new node

		void derase(dnode<T> *curr);
			// erase node curr from the linked list.
			// Precondition: the list is not empty. the functions that
			// call derase() check the precondition
};

template <typename T>
dnode<T> *miniList<T>::getDNode(const T& item)
{
	// pointer to the new node
	dnode<T> *newNode;

	// allocate the new node and verify that the
	// allocation succeeded
	newNode = new dnode<T>(item);
	if (newNode == NULL)
		throw memoryAllocationError("miniList(): memory allocation failure");

	// return the address of the new node
	return newNode;
}

template <typename T>
dnode<T> *miniList<T>::dinsert(dnode<T> *curr, const T& item)
{
	// allocate the new node
	dnode<T> *newNode = getDNode(item);

	// insert newNode before curr
	newNode->prev = curr->prev;
	newNode->next = curr;
	curr->prev->next = newNode;
	curr->prev = newNode;

	return newNode;
}

template <typename T>
void miniList<T>::derase(dnode<T> *curr)
{
	// unlink the node from the list
	curr->prev->next = curr->next;
	curr->next->prev = curr->prev;

	// delete the node
	delete curr;
}

// list size is 0
template <typename T>
miniList<T>::miniList(): listSize(0)
{
	// create an empty list
	header = new dnode<T>;
	if (header == NULL)
		throw memoryAllocationError("miniList(): memory allocation failure");
}

// list size is n
template <typename T>
miniList<T>::miniList(int n, const T& value): listSize(n)
{
	int i;

	// create an empty list
	header = new dnode<T>;
	if (header == NULL)
		throw memoryAllocationError
			("miniList(): memory allocation failure");

	// insert n copies of value at the front of the list
	for (i=0;i < n;i++)
		dinsert(header->next, value);
}

// initialize listSize to 0
template <typename T>
miniList<T>::miniList(T* first, T* last): listSize(0)
{
	T *curr = first;

	// create an empty list
	header = new dnode<T>;
	if (header == NULL)
		throw memoryAllocationError("miniList(): memory allocation failure");

	// insert the values in the range [first, last) at the
	// back of the list. increment listSize in each iteration
	while (curr != last)
	{
		dinsert(header, *curr);
		curr++;
		listSize++;
	}
}

template <typename T>
miniList<T>::miniList(const miniList<T>& obj): listSize(obj.listSize)
{
	// curr moves through the nodes in obj, and end marks the finish
	// of a traversal through obj
	dnode<T> *curr = obj.header->next, *end = obj.header;

	// create an empty list
	header = new dnode<T>;
	if (header == NULL)
		throw memoryAllocationError
			("miniList(): memory allocation failure");

	// insert the values in the linked list obj.header
	// at the back of the current list
	while (curr != end)
	{
		dinsert(header, curr->nodeValue);
		curr = curr->next;
	}
}

template <typename T>
miniList<T>::~miniList()
{
	// erase the front of the list until it is empty
	while (header->next != header)
		derase(header->next);

	// the list has no nodes
	listSize = 0;

	// delete the header node
	delete header;
}

template <typename T>
miniList<T>& miniList<T>::operator=(const miniList<T>& rhs)
{
	// curr moves through the nodes in rhs, and end marks the finish
	// of a traversal through rhs
	dnode<T> *curr = rhs.header->next, *end = rhs.header;

   // can't assign list to itself
   if (this == &rhs)
		return *this;

	// erase the current list
	while (header->next != header)
		derase(header->next);

	// insert the elements of rhs at the back of the list
	while (curr != end)
	{
		dinsert(header, curr->nodeValue);
		curr = curr->next;
	}

	// list size is the size of rhs
	listSize = rhs.listSize;

   return *this;
}

template <typename T>
int miniList<T>::size() const
{
	return listSize;
}

template <typename T>
bool miniList<T>::empty() const
{
	return listSize == 0;
}

template <typename T>
void miniList<T>::push_front(const T& item)
{
	// insert at the front
	dinsert(header->next, item);

	// increment the list size
	listSize++;
}

template <typename T>
void miniList<T>::push_back(const T& item)
{
	// insert at the back
	dinsert(header, item);

	// increment the list size
	listSize++;
}

template <typename T>
miniList<T>::iterator miniList<T>::insert(iterator pos, const T& item)
{
	// record the current node's address in curr. newNode will be
	// the address of the node we insert
	dnode<T> *curr = pos.nodePtr, *newNode;

	// insert item before curr and capture the new node's address
	newNode = dinsert(curr, item);

	// increment the list size
	listSize++;

	// constructor converts newNode to an iterator
	return iterator(newNode);
}


template <typename T>
void miniList<T>::pop_front()
{
	if (listSize == 0)
		throw underflowError("miniList pop_front(): list is empty");

	// erase the front
	derase(header->next);

	// decrement the list size
	listSize--;
}

template <typename T>
void miniList<T>::pop_back()
{
	if (listSize == 0)
		throw underflowError("miniList pop_back(): list is empty");

	// erase the back
	derase(header->prev);

	// decrement the list size
	listSize--;
}

template <typename T>
void miniList<T>::erase(iterator pos)
{
	if (listSize == 0)
		throw underflowError("miniList erase(): list is empty");

	// retrieve the address of the node to be erased
	dnode<T> *curr = pos.nodePtr;

	// erase the node from the list
	derase(curr);

	// decrement the list size
	listSize--;
}

template <typename T>
T& miniList<T>::front()
{
	if (listSize == 0)
		throw underflowError("miniList front(): list is empty");

	return header->next->nodeValue;
}

template <typename T>
const T& miniList<T>::front() const
{
	if (listSize == 0)
		throw underflowError("miniList front(): list is empty");

	return header->next->nodeValue;
}

template <typename T>
T& miniList<T>::back()
{
	if (listSize == 0)
		throw underflowError("miniList back(): list is empty");

	return header->prev->nodeValue;
}

template <typename T>
const T& miniList<T>::back() const
{
	if (listSize == 0)
		throw underflowError("miniList back(): list is empty");

	return header->prev->nodeValue;
}

// note that in each of begin() and end(), a
// private iterator/const_iterator constructor converts
// the pointer into an iterator

template <typename T>
miniList<T>::iterator miniList<T>::begin()
{
	// private iterator constructor builds an iterator object
	// from the dnode pointer
	return iterator(header->next);
}

template <typename T>
miniList<T>::const_iterator miniList<T>::begin() const
{
	// private constructor builds a const_iterator object
	// from the dnode pointer
	return const_iterator(header->next);
}

template <typename T>
miniList<T>::iterator miniList<T>::end()
{
	// private constructor builds an iterator object
	// from the dnode pointer
	return iterator(header);
}

template <typename T>
miniList<T>::const_iterator miniList<T>::end() const
{
	// private constructor builds a const_iterator object
	// from the dnode pointer
	return const_iterator(header);
}

#endif   // LIST_CLASS