// JList.cpp: implementation of the CJinList class.
//
// Original Written by Jin, YongChul 1999. 10. 5
// Reprogrammed For BlueWinz SDK
// anecia@unitel.co.kr
//
//////////////////////////////////////////////////////////////////////

#include "JListC.h"

/*
#ifdef _JDEBUG
extern void JinDebug(HWND hwnd, HRESULT result, char *format, ...);
#else
#define JinDebug
#endif
*/
#define JinDebug


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

LPMYLIST CreateList()
{
	LPMYLIST lpMyList;
	lpMyList = (LPMYLIST)MALLOC(sizeof(MYLIST));
	if ( lpMyList != NULL )
	{
		std_memset(lpMyList, 0, sizeof(MYLIST));
	}
	return lpMyList;
}

void ReleaseList(LPMYLIST* lppMyList, BOOL bDataDelete)
{
	if ( *lppMyList != NULL )
	{
		ListRemoveAll(*lppMyList, bDataDelete);
		FREE(*lppMyList);
		*lppMyList = NULL;
	}
}

// Return Value: The Data pointer previously at the head of the list.
JDataPtr ListRemoveHead(LPMYLIST lpMyList, BOOL bDataDelete)// const
{
	LPJNODE		tmpNode;
	JDataPtr	tmpData;
	if ( lpMyList->lpNodeHead == NULL )
		return NULL;

	tmpNode = lpMyList->lpNodeHead;
	tmpData = lpMyList->lpNodeHead->pData;

	lpMyList->lpNodeHead = tmpNode->pNext;
	if ( lpMyList->lpNodeHead != NULL )
	{
		lpMyList->lpNodeHead->pPrev = NULL;
	}
	else
	{
		lpMyList->lpNodeTail = NULL;
	}

	if ( bDataDelete ) 
	{
		if ( tmpData != NULL )
		{
			FREE(tmpData);
			tmpData = NULL;
		}
	}
	FREE(tmpNode);

	lpMyList->nNodeCount--;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::RemoveHead(BOOL bDataDelete) - lpMyList->nNodeCount is minus.");
	}
#endif
	return tmpData;
}

// Return Value: Newly NodeTail's Data.
void* ListRemoveTail(LPMYLIST lpMyList, BOOL bDataDelete) //const
{
	LPJNODE		tmpNode;
	JDataPtr	tmpData;
	if ( lpMyList->lpNodeTail == NULL )
		return NULL;

	tmpNode = lpMyList->lpNodeTail;
	tmpData = lpMyList->lpNodeTail->pData;

	lpMyList->lpNodeTail = tmpNode->pPrev;
	if ( lpMyList->lpNodeTail != NULL )
	{
		lpMyList->lpNodeTail->pNext = NULL;
	}
	else
	{
		lpMyList->lpNodeHead = NULL;
	}

	if ( bDataDelete ) 
	{
		if ( tmpData != NULL )
		{
			FREE(tmpData);
			tmpData = NULL;
		}
	}
	FREE(tmpNode);

	lpMyList->nNodeCount--;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::RemoveTail(BOOL bDataDelete) - lpMyList->nNodeCount is minus.");
	}
#endif
	return tmpData;
}

const
void* ListGetHead(LPMYLIST lpMyList)
{
	if ( lpMyList->lpNodeHead == NULL )
		return NULL;
	return lpMyList->lpNodeHead->pData;
}

const
void* ListGetTail(LPMYLIST lpMyList)
{
	if ( lpMyList->lpNodeTail == NULL )
		return NULL;
	return lpMyList->lpNodeTail->pData;
}

const
LPJNODE		ListGetHeadPosition(LPMYLIST lpMyList)
{
	return lpMyList->lpNodeHead;
}

const
LPJNODE		ListGetTailPosition(LPMYLIST lpMyList)
{
	return lpMyList->lpNodeTail;
}

int			ListGetCount(LPMYLIST lpMyList)
{
	return lpMyList->nNodeCount;
}


// Return Value: Newly Nodehead.
LPJNODE ListAddHead(LPMYLIST lpMyList, void* pData)// const
{
	LPJNODE tmpNode = (LPJNODE)MALLOC(sizeof(JNODE));
    tmpNode->pData = pData;
	tmpNode->pPrev = NULL;
	tmpNode->pNext = lpMyList->lpNodeHead;

    if ( lpMyList->lpNodeHead != NULL )
	    lpMyList->lpNodeHead->pPrev = tmpNode;
    else
        lpMyList->lpNodeTail = tmpNode;

	lpMyList->lpNodeHead = tmpNode;

	lpMyList->nNodeCount++;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::AddHead(void* pData) - lpMyList->nNodeCount is minus.");
	}
#endif
	return lpMyList->lpNodeHead;
}

// Return Value: Newly NodeTail.
LPJNODE ListAddTail(LPMYLIST lpMyList, void* pData)// const
{
	LPJNODE tmpNode = (LPJNODE)MALLOC(sizeof(JNODE));
    tmpNode->pData = pData;
	tmpNode->pNext = NULL;
	tmpNode->pPrev = lpMyList->lpNodeTail;

    if ( lpMyList->lpNodeTail != NULL )
        lpMyList->lpNodeTail->pNext = tmpNode;
    else
        lpMyList->lpNodeHead = tmpNode;
    
	lpMyList->lpNodeTail = tmpNode;

	lpMyList->nNodeCount++;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::AddTail(void* pData) - lpMyList->nNodeCount is minus.");
	}
#endif
	return lpMyList->lpNodeTail;
}

void ListRemoveAll(LPMYLIST lpMyList, BOOL bDataDelete)
{
	LPJNODE Node = lpMyList->lpNodeHead;
	LPJNODE NextNode;

	while ( Node != NULL )
	{
		NextNode = Node->pNext;
		if ( Node != NULL )
		{
			if ( Node->pData != NULL && bDataDelete )
			{
				FREE(Node->pData);
				Node->pData = NULL;
			}
		}
		FREE(Node);
		Node = NextNode;
	}
	lpMyList->lpNodeHead = lpMyList->lpNodeTail = NULL;
	lpMyList->nNodeCount = 0;
}

const
LPJNODE ListFind(LPMYLIST lpMyList, JDataPtr searchValue, LPJNODE startAfter)
{
	LPJNODE tmpNode = ( startAfter == NULL ) ? (LPJNODE)lpMyList->lpNodeHead : (LPJNODE)startAfter;

	for ( ; tmpNode != NULL; tmpNode = tmpNode->pNext )
	{
		if ( tmpNode->pData == searchValue ) return (LPJNODE)tmpNode;
	}
	return NULL;
}

const
int ListGetNo(LPMYLIST lpMyList, JDataPtr searchValue, LPJNODE startAfter)
{
    int nNo = 0;
	LPJNODE tmpNode = ( startAfter == NULL ) ? (LPJNODE)lpMyList->lpNodeHead : (LPJNODE)startAfter;

	for ( ; tmpNode != NULL; tmpNode = tmpNode->pNext )
	{
        nNo++;
		if ( tmpNode->pData == searchValue ) return nNo;
	}
	return 0;
}

const
LPJNODE ListFindIndex(LPMYLIST lpMyList, int nIndex)
{
	LPJNODE tmpNode;
	if ( nIndex >= lpMyList->nNodeCount || nIndex < 0 ) return NULL;

	tmpNode = lpMyList->lpNodeHead;
	while( nIndex-- )
	{
		tmpNode = tmpNode->pNext;
	}

	return (LPJNODE)tmpNode;
}

const
JDataPtr ListGetAt(LPMYLIST lpMyList, LPJNODE position)
{
	if ( position == NULL ) return NULL;
	return position->pData;
}

const
JDataPtr ListGetNext(LPMYLIST lpMyList, LPJNODE* lppPosition) 
{
	LPJNODE tmpNode = (LPJNODE)*lppPosition;
	if ( tmpNode == NULL ) return NULL;

	*lppPosition = tmpNode->pNext;
	return tmpNode->pData;
}

const
JDataPtr ListGetPrev(LPMYLIST lpMyList, LPJNODE* lppPosition)
{
	LPJNODE tmpNode = (LPJNODE)*lppPosition;
	if ( tmpNode == NULL ) return NULL;

	*lppPosition = tmpNode->pPrev;
	return tmpNode->pData;
}

LPJNODE ListInsertBefore(LPMYLIST lpMyList, LPJNODE pos, JDataPtr newElement)
{
	LPJNODE tmpNode;
	if ( pos == NULL ) return ListAddHead(lpMyList, newElement);
	tmpNode = (LPJNODE)MALLOC(sizeof(JNODE));

	tmpNode->pData = newElement;
	tmpNode->pNext = pos;
	tmpNode->pPrev = pos->pPrev;

	if ( pos->pPrev == NULL )
	{
#ifdef _JDEBUG
		if ( pos != lpMyList->lpNodeHead )
		{
			JinDebug(NULL, NULL, "CJinList::InsertBefore(LPJNODE pos, JDataPtr newElement) - pos != lpMyList->lpNodeHead.");
		}
#endif
		lpMyList->lpNodeHead = tmpNode;
	}
	else
	{
		pos->pPrev->pNext = tmpNode;
	}

	pos->pPrev = tmpNode;

	lpMyList->nNodeCount++;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::InsertBefore(LPJNODE pos, JDataPtr newElement) - lpMyList->nNodeCount is minus.");
	}
#endif
	return tmpNode;
}

LPJNODE ListInsertAfter(LPMYLIST lpMyList, LPJNODE pos, JDataPtr newElement)
{
	LPJNODE tmpNode;
	if ( pos == NULL ) return ListAddTail(lpMyList, newElement);
	tmpNode = (LPJNODE)MALLOC(sizeof(JNODE));

	tmpNode->pData = newElement;
	tmpNode->pPrev = pos;
	tmpNode->pNext = pos->pNext;	

	if ( pos->pNext == NULL )
	{
#ifdef _JDEBUG
		if ( pos != lpMyList->lpNodeTail )
		{
			JinDebug(NULL, NULL, "CJinList::InsertAfter(LPJNODE pos, JDataPtr newElement) - pos != lpMyList->lpNodeTail.");
		}
#endif
		lpMyList->lpNodeTail = tmpNode;
	}
	else
	{
		pos->pNext->pPrev = tmpNode;
	}

	pos->pNext = tmpNode;

	lpMyList->nNodeCount++;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::InsertAfter(LPJNODE pos, JDataPtr newElement) - lpMyList->nNodeCount is minus.");
	}
#endif
	return tmpNode;
}

void ListSetAt(LPMYLIST lpMyList, LPJNODE pos, JDataPtr newElement, BOOL bDeleteData)
{
#ifdef _JDEBUG
	if ( pos == NULL )
	{
		JinDebug(NULL, NULL, "CJinList::SetAt(LPJNODE pos, JDataPtr newElement) - position is NULL.");
		return;
	}
#endif

	if ( bDeleteData )
	{
		FREE(pos->pData);
		pos->pData = NULL;
	}
	pos->pData = newElement;
}

void ListRemoveAt(LPMYLIST lpMyList, LPJNODE position, BOOL bDeleteData)
{
#ifdef _JDEBUG
	if ( position == NULL )
	{
		JinDebug(NULL, NULL, "CJinList::RemoveAt(LPJNODE position) - position is NULL.");
		return;
	}
#endif

	LPJNODE tmpNode = (LPJNODE) position;

	if ( tmpNode == lpMyList->lpNodeHead )
	{
        ListRemoveHead(lpMyList, bDeleteData);
        return;
	}
	if ( tmpNode == lpMyList->lpNodeTail )
	{
        ListRemoveTail(lpMyList, bDeleteData);
        return;
	}

	tmpNode->pPrev->pNext = tmpNode->pNext;
	tmpNode->pNext->pPrev = tmpNode->pPrev;

	if ( bDeleteData )
	{
		if ( tmpNode->pData != NULL )
		{
			FREE(tmpNode->pData);
			tmpNode->pData = NULL;
		}
	}
	FREE(tmpNode);
	lpMyList->nNodeCount--;
#ifdef _JDEBUG
	if ( lpMyList->nNodeCount < 0 )
	{
		JinDebug(NULL, NULL, "CJinList::RemoveAt(LPJNODE position) - lpMyList->nNodeCount is minus.");
	}
#endif
}