#pragma once

template <class T>
class CDynamicList;

////////////////////////////////////
///   CDynamicNode declaration   ///
////////////////////////////////////

template <class T>
class CDynamicNode
{
	friend class CDynamicList<T>;

public:
	CDynamicNode(T *pItem);
	virtual ~CDynamicNode(void);

	CDynamicNode<T> *GetNextNode() { return m_pNextNode; }
	T *GetValue() { return m_pItem; }

protected:
	T *m_pItem;
	void SetNextNode(CDynamicNode<T> *pNextNode) { m_pNextNode = pNextNode; }
	CDynamicNode<T> *m_pNextNode;

private:
	CDynamicNode(void) {}
};

///////////////////////////////////////
///   CDynamicList implementation   ///
///////////////////////////////////////

template <class T>
CDynamicNode<T>::CDynamicNode(T *_pItem)
{
	m_pItem = _pItem;
	m_pNextNode = NULL; 
}

template <class T>
CDynamicNode<T>::~CDynamicNode(void)
{
	delete m_pItem;
	m_pItem = NULL;
}

////////////////////////////////////
///   CDynamicList declaration   ///
////////////////////////////////////

template <class T>
class CDynamicList
{
public:
	CDynamicList(void);
	virtual ~CDynamicList(void);

	int ListCount() { return m_iItemCount; }
	int AddItem(T *pNewItem);
	bool RemoveItem(T *pNewItem);
	bool RemoveCurrentItem();
	void ClearList();
	
	CDynamicNode<T> *SelectFirst();
	CDynamicNode<T> *SelectNext();
	CDynamicNode<T> *GetCurrent();
	T *GetValue();
protected:
	int m_iItemCount;

	CDynamicNode<T> *m_pFirst;
	CDynamicNode<T> *m_pLast;
	CDynamicNode<T> *m_pCurrent;
};

///////////////////////////////////////
///   CDynamicList implementation   ///
///////////////////////////////////////

template <class T>
CDynamicList<T>::CDynamicList(void)
{
	m_iItemCount = 0;
	m_pFirst = NULL;
	m_pLast = NULL;
	m_pCurrent = NULL;
}

template <class T>
CDynamicList<T>::~CDynamicList(void)
{
	ClearList();
}

template <class T>
int CDynamicList<T>::AddItem(T *_pNewItem)
{
	CDynamicNode<T> *Item = new CDynamicNode<T>(_pNewItem);

	if (!m_pFirst)
		m_pFirst = Item;

	if (!m_pLast)
		m_pLast = Item;
	else
	{
		m_pLast->SetNextNode(Item);
		m_pLast = Item;
	}

	return ++m_iItemCount;
}

template <class T>
bool CDynamicList<T>::RemoveItem(T *_pItem)
{
	bool bRet = false;
	CDynamicNode<T> *Item, *PrevItem;

	Item = m_pFirst;
	if (_pItem)
	{
		while (Item)
		{
			if (Item->GetValue() == _pItem)
			{
				if (Item == m_pFirst)
					m_pFirst = Item->GetNextNode();
				else if (Item == m_pLast)
				{
					m_pLast = PrevItem;
					m_pLast->SetNextNode(NULL);
				}
				else
					PrevItem->SetNextNode(Item->GetNextNode());

				delete Item;
				m_iItemCount--;
				bRet = true;
				break;
			}
			PrevItem = Item;
			Item = Item->GetNextNode();
		}
	}

	return bRet;
}

template <class T>
bool CDynamicList<T>::RemoveCurrentItem()
{
	bool bRet = false;
	
	if (m_pCurrent)
	{
		bRet = RemoveItem(m_pCurrent->GetValue());
		if (bRet)
			m_pCurrent = m_pFirst;
	}

	return bRet;
}

template <class T>
void CDynamicList<T>::ClearList()
{
	CDynamicNode<T> *Item, *ItemNext = NULL;

	Item = SelectFirst();

	while (Item)
	{
		ItemNext = Item->GetNextNode();
		delete Item;
		Item = ItemNext;
	}

	m_pFirst = NULL;
	m_pLast = NULL;
	m_pCurrent = NULL;
	m_iItemCount = 0;
}

template <class T>
CDynamicNode<T> *CDynamicList<T>::SelectFirst()
{
	m_pCurrent = m_pFirst;
	return m_pCurrent;
}

template <class T>
CDynamicNode<T> *CDynamicList<T>::SelectNext()
{
	if (m_pCurrent)
	{
		m_pCurrent = m_pCurrent->GetNextNode();
		return m_pCurrent;
	}
	else
		return NULL;
}

template <class T>
CDynamicNode<T> *CDynamicList<T>::GetCurrent()
{
	return m_pCurrent;
}

template <class T>
T *CDynamicList<T>::GetValue()
{
	if (m_pCurrent)
		return m_pCurrent->GetValue();
	else
		return NULL;
}