#ifndef _CLCDLIST_H_
#define _CLCDLIST_H_

#include "CLCDTextObject.h"
#include "CLCDBar.h"
#include <math.h>

enum EListEntryType { ROOT = 0, CONTAINER = 1, ITEM = 2 };

template <class T, class G = tstring> class CListEntry
{
public:
	CListEntry(CListEntry<T, G> *pParent)
	{
		m_iIndex = -1;
		m_iEntryCount = 0;
		m_Position = nullptr;
		m_pParent = pParent;
		if (pParent == nullptr) {
			m_iLevel = 0;
			m_eType = ROOT;
			m_pRoot = this;
		}
		else m_iLevel = m_pParent->GetLevel() + 1;
	}

	virtual ~CListEntry()
	{
	}

	int GetLevel()
	{
		return m_iLevel;
	}

	virtual CListEntry<T, G> *GetNextEntry()
	{
		if (m_pParent == nullptr)
			return nullptr;

		return m_pParent->GetNextEntry(this);
	}

	virtual CListEntry<T, G> *GetPreviousEntry()
	{
		if (m_pParent == nullptr)
			return nullptr;

		return m_pParent->GetPreviousEntry(this);
	}

	virtual CListEntry<T, G> *GetNextEntry(CListEntry<T, G>*)
	{
		return nullptr;
	}

	virtual CListEntry<T, G> *GetPreviousEntry(CListEntry<T, G>*)
	{
		return nullptr;
	}

	EListEntryType GetType()
	{
		return m_eType;
	}

	int GetEntryCount()
	{
		return m_iEntryCount;
	}

	virtual void UpdateEntryCount()
	{
		m_iEntryCount = 0;
	}

	void SetRoot(CListEntry<T, G>* pRoot)
	{
		m_pRoot = pRoot;
	}

	virtual void DeleteItem(T)
	{
	}

	virtual void DeleteGroup(G)
	{
	}

	CListEntry<T, G> *GetPosition()
	{
		return m_Position;
	}

	virtual void SetPosition(CListEntry<T, G> *pPosition)
	{
		m_Position = pPosition;
	}

	CListEntry<T, G> *GetParent()
	{
		return m_pParent;
	}

	int	GetIndex()
	{
		return m_iIndex;
	}

	void SetIndex(int iIndex)
	{
		m_iIndex = iIndex;
	}

protected:
	int			m_iIndex;
	int			m_iEntryCount;
	int			m_iLevel;
	EListEntryType m_eType;
	CListEntry<T, G> *m_pParent;
	CListEntry<T, G> *m_pRoot;
	CListEntry<T, G> *m_Position;
};

template <class T, class G = tstring> class CListItem : public CListEntry<T, G>
{
public:
	CListItem(CListEntry<T, G> *pParent, T Entry) : CListEntry<T, G>(pParent)
	{
		m_Item = Entry;
		m_eType = ITEM;
	}

	~CListItem()
	{
		m_pRoot->DeleteItem(GetItemData());
	}

	T GetItemData()
	{
		return m_Item;
	}
private:
	T	m_Item;
};

template <class T, class G = tstring> class CListContainer : public CListEntry<T, G>
{
public:
	typedef typename list<CListEntry<T, G>* >::iterator iterator;

	typename list<CListEntry<T, G>* >::iterator end()
	{
		return m_Entrys.end();
	}

	typename list<CListEntry<T, G>* >::iterator begin()
	{
		return m_Entrys.begin();
	}

	typename list<CListEntry<T, G>* >::size_type size()
	{
		return m_Entrys.size();
	}

	bool empty()
	{
		return m_Entrys.empty();
	}

	CListContainer(CListEntry<T, G> *pParent) : CListEntry<T, G>(pParent)
	{
		if (m_pParent != nullptr) {
			m_eType = CONTAINER;
			m_bOpen = false;
		}
		else
			m_bOpen = true;
	}

	~CListContainer()
	{
		if (m_pRoot != nullptr) {
			m_pRoot->DeleteGroup(GetGroupData());
		}
		Clear();
	}

	void Clear()
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();

		while (iter != m_Entrys.end()) {
			delete *iter;
			if (m_pRoot && m_pRoot->GetPosition() == *iter) {
				if (GetType() == ROOT)
					m_pRoot->SetPosition(nullptr);
				else
					m_pRoot->SetPosition(this);
			}

			iter++;
		}
		m_Entrys.clear();
	}

	void SetGroupData(G GroupData)
	{
		m_GroupData = GroupData;
	}

	bool IsEmpty()
	{
		return m_Entrys.empty();
	}

	CListEntry<T, G> *GetLastOwnEntry()
	{
		if (m_Entrys.empty())
			return nullptr;

		return *(--m_Entrys.end());
	}

	CListEntry<T, G> *GetLastEntry()
	{
		if (!m_Entrys.empty()) {

			CListEntry<T, G> *pEntry = *(--m_Entrys.end());
			if (pEntry->GetType() == ITEM || !((CListContainer<T, G>*)pEntry)->IsOpen() || ((CListContainer<T, G>*)pEntry)->IsEmpty())
				return pEntry;
			return ((CListContainer<T, G>*)pEntry)->GetLastEntry();
		}
		return nullptr;
	}

	CListEntry<T, G> *GetFirstEntry()
	{
		if (!m_Entrys.empty())
			return *(m_Entrys.begin());
		return nullptr;
	}

	CListEntry<T, G> *GetNextEntry()
	{
		if (!IsOpen() || m_Entrys.empty()) {
			if (!m_pParent)
				return nullptr;
			return m_pParent->GetNextEntry(this);
		}

		return *m_Entrys.begin();
	}

	CListEntry<T, G> *GetNextEntry(CListEntry<T, G> *pEntry)
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		while (iter != m_Entrys.end()) {
			if ((CListEntry<T, G>*)(*iter) == pEntry) {
				if (++iter == m_Entrys.end()) {
					if (m_pParent == nullptr)
						return nullptr;
					return m_pParent->GetNextEntry(this);
				}
				else
					return *iter;
			}
			iter++;
		}
		return nullptr;
	}

	CListEntry<T, G> *GetPreviousEntry(CListEntry<T, G> *pEntry)
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();

		while (iter != m_Entrys.end()) {
			if ((CListEntry<T, G>*)(*iter) == pEntry) {
				if (iter == m_Entrys.begin()) {
					if (m_pParent == nullptr)
						return nullptr;
					return this;
				}
				else {
					iter--;
					if ((*iter)->GetType() == CONTAINER) {
						CListContainer<T, G>* pContainer = (CListContainer<T, G>*)*iter;
						if (pContainer->IsOpen() && !pContainer->IsEmpty())
							return pContainer->GetLastEntry();
					}
					return *iter;
				}
			}
			iter++;
		}
		return nullptr;
	}

	virtual CListItem<T, G> *InsertItem(iterator _Where, T Entry)
	{
		CListItem<T, G> *pItem = new CListItem<T, G>(this, Entry);
		pItem->SetRoot(m_pRoot);
		m_Entrys.insert(_Where, pItem);

		m_pRoot->UpdateEntryCount();

		return pItem;
	}

	virtual CListContainer<T, G> *InsertGroup(iterator _Where, G Group)
	{
		CListContainer<T, G> *pGroup = new CListContainer<T, G>(this);
		pGroup->SetGroupData(Group);
		pGroup->SetRoot(m_pRoot);
		m_Entrys.insert(_Where, (CListEntry<T, G>*)pGroup);

		m_pRoot->UpdateEntryCount();

		return pGroup;
	}

	virtual CListItem<T, G> * AddItem(T Entry)
	{
		return InsertItem(end(), Entry);
	}

	virtual CListContainer<T, G> * AddGroup(G Group)
	{
		return InsertGroup(end(), Group);
	}



	virtual void RemoveGroup(G Group)
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		CListContainer<T, G> *pContainer = nullptr;
		while (iter != m_Entrys.end()) {
			if ((*iter)->GetType() == CONTAINER) {
				pContainer = (CListContainer<T, G>*)(*iter);
				if (pContainer->GetGroupData() == Group) {
					pContainer->Clear();
					if (m_pRoot && m_pRoot->GetPosition() == *iter) {
						CListEntry<T, G> *pPosition = (*iter)->GetPreviousEntry();
						if (!pPosition)
							pPosition = (*iter)->GetNextEntry();
						m_pRoot->SetPosition(pPosition);
					}
					delete *iter;
					m_Entrys.erase(iter);
					if (m_pRoot)
						m_pRoot->UpdateEntryCount();
					return;
				}
			}
			iter++;
		}
	}

	virtual void RemoveItem(T Entry)
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		CListItem<T, G> *pItem = nullptr;
		while (iter != m_Entrys.end()) {
			if ((*iter)->GetType() == ITEM) {
				pItem = (CListItem<T, G>*)(*iter);
				if (pItem->GetItemData() == Entry) {
					if (m_pRoot && m_pRoot->GetPosition() == *iter) {
						CListEntry<T, G> *pPosition = (*iter)->GetPreviousEntry();
						if (!pPosition)
							pPosition = (*iter)->GetNextEntry();
						m_pRoot->SetPosition(pPosition);
					}
					delete *iter;

					m_Entrys.erase(iter);
					if (m_pRoot)
						m_pRoot->UpdateEntryCount();
					return;
				}
			}
			iter++;
		}
	}

	CListContainer<T, G> *GetGroup(G Group)
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		CListContainer<T, G> *pContainer = nullptr;
		while (iter != m_Entrys.end()) {
			if ((*iter)->GetType() == CONTAINER) {
				pContainer = (CListContainer<T, G>*)(*iter);
				if (pContainer->GetGroupData() == Group)
					return pContainer;
			}
			iter++;
		}
		return nullptr;
	}

	G GetGroupData()
	{
		return m_GroupData;
	}

	bool IsOpen()
	{
		return m_bOpen;
	}

	void ToggleOpen()
	{
		m_bOpen = !m_bOpen;

		if (m_pRoot) {
			m_pRoot->UpdateEntryCount();
			m_pRoot->SetPosition(this);
		}
	}

	void SetOpen(bool bOpen = true)
	{
		if (bOpen == m_bOpen)
			return;

		m_bOpen = bOpen;

		if (m_pRoot) {
			m_pRoot->UpdateEntryCount();
			m_pRoot->SetPosition(this);
		}
	}

	void CollapseAll()
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		CListContainer<T, G>* pContainer = nullptr;
		while (iter != m_Entrys.end()) {
			if ((*iter)->GetType() == CONTAINER) {
				pContainer = (CListContainer<T, G>*)(*iter);
				pContainer->CollapseAll();
				pContainer->SetOpen(false);
			}
			iter++;
		}
	}

	void ExpandAll()
	{
		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		CListContainer<T, G>* pContainer = nullptr;
		while (iter != m_Entrys.end()) {
			if ((*iter)->GetType() == CONTAINER) {
				pContainer = (CListContainer<T, G>*)(*iter);
				pContainer->ExpandAll();
				pContainer->SetOpen(true);
			}
			iter++;
		}
	}

	void UpdateEntryCount()
	{
		m_iEntryCount = 0;

		int iIndex = GetIndex() + 1;

		if (!IsOpen())
			return;

		list< CListEntry<T, G>* >::iterator iter = m_Entrys.begin();
		while (iter != m_Entrys.end()) {
			(*iter)->SetIndex(iIndex + m_iEntryCount);
			(*iter)->UpdateEntryCount();
			m_iEntryCount += 1 + (*iter)->GetEntryCount();

			iter++;
		}

		if (GetType() == ROOT) {
			if (GetPosition() == nullptr && !m_Entrys.empty())
				SetPosition(*m_Entrys.begin());
			else
				SetPosition(GetPosition());
		}
	}

	template<class _Pr3>
	void sort(_Pr3 _Pred)
	{
		m_Entrys.sort(_Pred);
		UpdateEntryCount();
		m_pRoot->SetPosition(m_pRoot->GetPosition());
	}

private:
	typename list< CListEntry<T, G>* > m_Entrys;
	G m_GroupData;
	bool m_bOpen;
};


template <class T, class G = tstring> class CLCDList : public CLCDTextObject, public CListContainer<T, G>
{
	friend CListContainer<T, G>;
	friend CListItem<T, G>;

public:
	//************************************************************************
	// Constructor
	//************************************************************************
	CLCDList() : CListContainer<T, G>(nullptr)
	{
		m_pScrollbar = nullptr;
		m_iIndention = 10;
		m_iColumns = 1;
		m_bDrawTreeLines = true;
		m_iEntryHeight = 10;
	}

	//************************************************************************
	// Destructor
	//************************************************************************
	~CLCDList()
	{
	}

	//************************************************************************
	// Initializes the list
	//************************************************************************
	bool Initialize()
	{
		if (!CLCDTextObject::Initialize())
			return false;

		return true;
	}

	//************************************************************************
	// Deinitializes the list
	//************************************************************************
	bool Shutdown()
	{
		if (!CLCDTextObject::Shutdown())
			return false;

		Clear();
		return true;
	}

	//************************************************************************
	// updates the list
	//************************************************************************
	bool Update()
	{
		if (!CLCDTextObject::Update())
			return false;

		return true;
	}

	//************************************************************************
	// draws the list
	//************************************************************************
	bool Draw(CLCDGfx *pGfx)
	{
		if (!CLCDTextObject::Draw(pGfx))
			return false;

		SelectObject(pGfx->GetHDC(), m_hFont);

		POINT ptPrevViewportOrg = {0, 0};
		int iHeight = 0;
		int iYOffset = 0, iXOffset = 0;
		int iColWidth = (GetWidth() - (m_iColumns - 1) * 3) / m_iColumns;
		int iSpace = GetHeight() - (GetHeight() / m_iEntryHeight)*m_iEntryHeight;
		int iPerPage = (GetHeight() / m_iEntryHeight)*m_iColumns;

		int iEntriesDrawn = 0;
		CListEntry<T, G> *pPosition = m_Position;

		// if nothing is selected, skip drawing
		if (pPosition == nullptr)
			return true;

		bool bDrawGroup = false;
		bool bSelected = false;

		// calculate the start offset

		if (m_iStartIndex < pPosition->GetIndex()) {
			while (pPosition && pPosition->GetIndex() != m_iStartIndex)
				pPosition = pPosition->GetPreviousEntry();
		}

		if (m_iStartIndex > 0 && pPosition->GetIndex() > 0)
			pPosition = pPosition->GetPreviousEntry();

		for (int iCol = 0; iCol < m_iColumns; iCol++) {
			iHeight = 0;
			if (iCol == 0) {
				if (pPosition->GetIndex() < m_iStartIndex)
					iHeight -= m_iEntryHeight - iSpace;
				else if (GetEntryCount() >= (iPerPage / m_iColumns) + 1)
					iHeight = iSpace;
			}

			// bottom selection
			while (pPosition != nullptr) {
				iYOffset = iHeight;

				bSelected = m_Position == pPosition;
				bDrawGroup = pPosition->GetType() == CONTAINER;

				// ~~~~~~~~~~~~~~~~~~~~~~
				// Draw tree lines
				// ~~~~~~~~~~~~~~~~~~~~~~

				// set the clip region for the entry
				int iClipHeight = m_iEntryHeight;
				if (GetOrigin().y + iYOffset + iClipHeight > GetOrigin().y + GetHeight())
					iClipHeight = GetHeight() - iYOffset;

				pGfx->SetClipRegion(GetOrigin().x + iXOffset, GetOrigin().y + iYOffset,
					iColWidth, iClipHeight);

				// offset the control at its origin so entry use (0,0)
				SetViewportOrgEx(pGfx->GetHDC(),
					GetOrigin().x + iXOffset,
					GetOrigin().y + iYOffset,
					&ptPrevViewportOrg);

				if (m_bDrawTreeLines) {
					for (int i = 1; i < pPosition->GetLevel(); i++) {
						if (i == pPosition->GetLevel() - 1) {
							// -
							pGfx->DrawLine((i - 1)*m_iIndention + m_iIndention / 2, m_iEntryHeight / 2, i*m_iIndention, m_iEntryHeight / 2);
							// |
							if (pPosition == ((CListContainer<T, G>*)pPosition->GetParent())->GetLastOwnEntry())
								pGfx->DrawLine((i - 1)*m_iIndention + m_iIndention / 2, 0, (i - 1)*m_iIndention + m_iIndention / 2, m_iEntryHeight / 2);
							// |
							// |
							else
								pGfx->DrawLine((i - 1)*m_iIndention + m_iIndention / 2, 0, (i - 1)*m_iIndention + m_iIndention / 2, m_iEntryHeight);
						}
						else {
							CListEntry<T, G> *pPosition2 = pPosition;
							for (int j = pPosition->GetLevel(); j > i + 1; j--)
								pPosition2 = pPosition2->GetParent();
							// |
							// |
							if (pPosition2 != ((CListContainer<T, G>*)pPosition2->GetParent())->GetLastOwnEntry())
								pGfx->DrawLine((i - 1)*m_iIndention + m_iIndention / 2, 0, (i - 1)*m_iIndention + m_iIndention / 2, m_iEntryHeight);
						}
					}
				}

				// ~~~~~~~~~~~~~~~~~~~~~~
				// Draw the entry
				// ~~~~~~~~~~~~~~~~~~~~~~
				pGfx->SetClipRegion(GetOrigin().x + (pPosition->GetLevel() - 1)*m_iIndention + iXOffset,
					GetOrigin().y + iYOffset,
					iColWidth - (pPosition->GetLevel() - 1)*m_iIndention,
					iClipHeight);
				// set the offset
				SetViewportOrgEx(pGfx->GetHDC(),
					GetOrigin().x + (pPosition->GetLevel() - 1)*m_iIndention + iXOffset,
					GetOrigin().y + iYOffset,
					&ptPrevViewportOrg);

				// draw the entry
				if (!bDrawGroup)
					DrawEntry(pGfx, ((CListItem<T, G>*)pPosition)->GetItemData(), bSelected);
				else
					// draw the group
					DrawGroup(pGfx, ((CListContainer<T, G>*)pPosition)->GetGroupData(), ((CListContainer<T, G>*)pPosition)->IsOpen(), bSelected);

				// ~~~~~~~~~~~~~~~~~~~~~~

				if (pPosition->GetIndex() >= m_iStartIndex && iHeight + m_iEntryHeight <= GetHeight())
					iEntriesDrawn++;

				iHeight += m_iEntryHeight;
				pPosition = pPosition->GetNextEntry();

				if (iHeight >= GetHeight())
					break;
			}
			if (iCol != m_iColumns - 1) {
				pGfx->SetClipRegion(GetOrigin().x,
					GetOrigin().y,
					GetWidth(),
					GetHeight());
				// set the offset
				SetViewportOrgEx(pGfx->GetHDC(),
					GetOrigin().x,
					GetOrigin().y,
					&ptPrevViewportOrg);

				pGfx->DrawLine(iCol * 3 + iColWidth + 1, 0, iCol * 3 + iColWidth + 1, GetHeight());
			}
			iXOffset += 3 + iColWidth;
		}

		if (m_pScrollbar) {
			m_pScrollbar->ScrollTo(m_iStartIndex);
			m_pScrollbar->SetSliderSize(iEntriesDrawn);
		}
		return true;
	}


	void SetPosition(CListEntry<T, G> *pEntry)
	{
		CListContainer<T, G>::SetPosition(pEntry);

		if (pEntry == nullptr)
			return;

		int iPerPage = (GetHeight() / m_iEntryHeight)*m_iColumns;
		m_iStartIndex = pEntry->GetIndex();
		if (m_iStartIndex + (iPerPage - 1) > GetEntryCount() - 1)
			m_iStartIndex = (GetEntryCount() - 1) - (iPerPage - 1);
		if (m_iStartIndex < 0)
			m_iStartIndex = 0;
	}

	//************************************************************************
	// scrolls up
	//************************************************************************
	bool ScrollUp()
	{
		if (m_Position != nullptr) {
			CListEntry<T, G> *pEntry = m_Position->GetPreviousEntry();
			if (pEntry != nullptr) {
				m_Position = pEntry;

				if (m_Position->GetIndex() < m_iStartIndex)
					m_iStartIndex--;
				return true;
			}
		}
		return false;
	}

	//************************************************************************
	// scrolls down
	//************************************************************************
	bool ScrollDown()
	{
		if (m_Position != nullptr) {
			CListEntry<T, G> *pEntry = m_Position->GetNextEntry();
			if (pEntry != nullptr) {
				m_Position = pEntry;

				int iPerPage = (GetHeight() / m_iEntryHeight)*m_iColumns;
				if (m_Position->GetIndex() >= m_iStartIndex + iPerPage)
					m_iStartIndex++;
				return true;
			}
		}
		return false;
	}

	//************************************************************************
	// returns the selected list entry
	//************************************************************************
	CListEntry<T, G> *GetSelectedEntry()
	{
		return m_Position;
	}

	//************************************************************************
	// associates a scrollbar with the list
	//************************************************************************
	void SetScrollbar(CLCDBar *pScrollbar)
	{
		m_pScrollbar = pScrollbar;
		if (m_pScrollbar) {
			m_pScrollbar->SetRange(0, m_iEntryCount - 1);
			m_pScrollbar->ScrollTo(m_Position != nullptr ? m_Position->GetIndex() : 0);

			m_pScrollbar->SetAlignment(TOP);
		}
	}

	//************************************************************************
	// sets the group indention in pixels
	//************************************************************************
	void SetIndention(int iIndention)
	{
		m_iIndention = iIndention;
	}

	//************************************************************************
	// sets the lists entry height
	//************************************************************************
	void SetEntryHeight(int iEntryHeight)
	{
		m_iEntryHeight = iEntryHeight;
	}

	//************************************************************************
	// returns the lists entry height
	//************************************************************************
	int GetEntryHeight()
	{
		return m_iEntryHeight;
	}

	//************************************************************************
	// enables/disables drawing of treelines
	//************************************************************************
	void SetDrawTreeLines(bool bDraw)
	{
		m_bDrawTreeLines = bDraw;
	}

	//************************************************************************
	// sets the amount of columns the list uses
	//************************************************************************
	void SetColumns(int iColumns)
	{
		if (m_iColumns == iColumns)
			return;
		m_iColumns = iColumns;
		SetPosition(GetPosition());
	}

protected:
	//************************************************************************
	// called when the lists size has changed
	//************************************************************************
	void OnSizeChanged()
	{
		SetPosition(GetPosition());
	}

	//************************************************************************
	// updates the list's entry count
	//************************************************************************
	void UpdateEntryCount()
	{
		CListContainer<T, G>::UpdateEntryCount();
		if (m_pScrollbar) {
			m_pScrollbar->SetRange(0, m_iEntryCount - 1);
			if (GetPosition() != nullptr)
				m_pScrollbar->ScrollTo(GetPosition()->GetIndex());
		}
	}

	//************************************************************************
	// Called to delete the specified entry
	//************************************************************************
	virtual void DeleteEntry(T)
	{
	}

	//************************************************************************
	// Called to delete the specified group
	//************************************************************************
	virtual void DeleteGroup(G)
	{
	}

	//************************************************************************
	// Called to draw the specified entry
	//************************************************************************
	virtual void DrawEntry(CLCDGfx*, T, bool)
	{
	}

	//************************************************************************
	// Called to draw the specified entry
	//************************************************************************
	virtual void DrawGroup(CLCDGfx*, G, bool, bool)
	{
	}

protected:
	int		m_iStartIndex;
	int		m_iColumns;

	bool	m_bDrawTreeLines;
	int		m_iIndention;
	int		m_iEntryHeight;
	CLCDBar	*m_pScrollbar;
};

#endif