/*
 Handle类通常是只读的无符号整数。虽然可以安全地将其设为空来重置句柄，但句柄一旦创建就不应该再修改。
 注意，Handle是参数化的类，需要一个TAG类型来完整定义。
 模板参数TAG除了区分句柄类型外不起任何作用,TAG类型的对象在系统任何地方都不会被用到。
 这么做的原因是为了保证类型安全。使用参数化的Handle类型可以确保，如果向期望获取某种类型句柄的
 函数传递另外一种类型的句柄，则不会被编译通过。
 因此为了保障类型安全，我们创建一个新的句柄类型，
 作为一个唯一符号并被用作Handle类型的参数。TAG类型可以是任何形式的类型.
*/
 
#ifndef _DEBUG
#include <new>
//#include <time.h>
#endif
//#include <vector>
//#include <cassert>
//实现对象的重用,而且管理实体
//参见: http://hi.baidu.com/zyb_debug/blog/item/eaf6ea8ce55f291bb21bba4c.html 

#pragma once

enum
{
	// sizes to use for bit fields 使用位域(bit fields)的大小
	MAX_BITS_INDEX = 21,
	MAX_BITS_MAGIC = 11,

	// sizes to compare against for asserting dereferences
	MAX_INDEX = ( 1 << MAX_BITS_INDEX) - 1,
	MAX_MAGIC = ( 1 << MAX_BITS_MAGIC) - 1,

	//INVALID_INDEX =( 1 << MAX_BITS_INDEX),   //非法的INDEX
};

//TAG在这里并没有什么用处,
template <typename TAG>
class Handle
{
	union
	{
		struct
		{
			unsigned m_Index : MAX_BITS_INDEX; // index into resource array 资源数组的索引
			unsigned m_Magic : MAX_BITS_MAGIC; // magic number to check     需要检查的魔术数
		};
		unsigned int m_Handle;
	};

public:
	
	// Lifetime.生命期

	Handle( void ) : m_Handle( 0 ) { }
	Handle( unsigned nHandle )  {m_Handle= nHandle ;} //

	void Init( unsigned int index )
	{
		
		DbgAssert( IsNull() );             // don't allow reassignment 不允许重新赋值
		DbgAssert( index <=MAX_INDEX );   // verify range 有限范围验证

		//魔数初始化修改为一个随机数，避免出现一些特殊情况，增加服务器重启后可靠性
		static unsigned int s_AutoMagic = rand();
		IncMagicNumImpl(s_AutoMagic);

		m_Index = index;
		m_Magic = s_AutoMagic;
	}

	inline void updateMagic() {
		unsigned int magic = m_Magic;
		IncMagicNumImpl(magic);
		m_Magic = magic;
	}

	// Query.查询

	inline unsigned int GetIndex ( void ) const { return ( m_Index ); }
	inline unsigned int GetMagic ( void ) const { return ( m_Magic ); }
	inline unsigned int GetHandle( void ) const { return ( m_Handle ); }
	
	bool         IsNull   ( void ) const { return ( !m_Handle ); }
	inline unsigned GetMaxIndex(){return MAX_INDEX;}
	operator unsigned int ( void ) const { return ( m_Handle ); }

protected:
	inline void IncMagicNumImpl(unsigned int &magic)
	{
		if ( ++magic > MAX_MAGIC )
			magic = 1;    // 0 is used for "null handle"
	}
};




template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT =1024>
class HandleMgr
{
public:
	typedef DATA	DataType;
	typedef HANDLE	HandleType;
	//typedef HandleMgrStat Inherited;

	 HandleMgr(LPCTSTR lpszDesc);

	~HandleMgr( ) 
	{
		Empty();
	}
	
	
	//申请一个数据指针
	DATA* Acquire( HANDLE& handle );
	
	//不使用指针,放到缓存池里去
	void Release( HANDLE handle );

	// 重新请求一个新句柄
	bool ReNew( HANDLE &handle);	

	// 通过handle返回数据的指针
	DATA*       GetDataPtr( HANDLE handle );
	const DATA* GetDataPtr( HANDLE handle ) const;

	// other query 其他查询

	inline unsigned int GetUsedHandleCount( void ) const
	{ 
		return ( m_nUsedCount ); 
	}
	inline UINT GetTotalHandleCount(void) 
	{
		return    (UINT)m_MagicNumbers.count() * ONE_CHUNK_COUNT;
	}

	inline int GetUserDataSize(void)
	{
		return m_nUsedCount * (sizeof(DATA) + ONE_CHUNK_COUNT);
	}

	inline bool HasUsedHandles( void ) const
	{ 
		return ( (GetTotalHandleCount() -GetUsedHandleCount()) >0 ); 
	}
	inline VOID GetChunkIdPos(UINT index, UINT &nChunkId, UINT  & nPos)
	{
		nPos = index % ONE_CHUNK_COUNT; //取在chunk里的位置; //取在chunk里的位置
		nChunkId = index / ONE_CHUNK_COUNT; //在第几个chunk
		
	}
	//通过数据指针释放
	void  ReleaseDataPtr( DATA * pData );
	
	//获取第1个有效的数据指针，结果的句柄要放在 hHandle,数据指针放在DATA*
	DATA * First(HANDLE & hHandle); 

	DATA * Next(HANDLE & hHandle); //hHandle 句柄 下一个有效数据的指针，DATA 为该数据指针
	
	//清空内存
	void Empty(); 
	
	// 输出统计信息到文件
	void dumpToFile()
	{

	}

private:
	// private types
	//
	typedef wylib::container::CBaseList<  wylib::container::CBaseList<DATA> >      UserVec; //数据
	typedef wylib::container::CBaseList<  wylib::container::CBaseList<HANDLE>  > MagicVec; //handle
	typedef wylib::container::CBaseList< unsigned int> ChunkFreeCountVec; //每个块还有多少个空闲的句柄

	UINT m_nFirstFreeIndex ; //第1个能用的index,这个用于指向释放了的第1个可用index
	UINT m_nLastChunkFirstFreeIndex;  //新申请的空闲列表的一个第1个可用的index
	UINT m_nUsedCount;         //
	
	// private data
	UserVec m_UserData;				// 数据
	MagicVec  m_MagicNumbers;		 // 存的是每个数据当前使用的句柄
	ChunkFreeCountVec m_FreeCounts; //每个块有多少个空闲的元素,这个保证每次查找可用的指针最多查找1024个对象
	const static UINT INVALID_INDEX = ~0 ; //非法的指针
	//const static  int  ONE_CHUNK_COUNT =1024 ;			//每次申请1024个空间,这个要是2的n次幂
	//const static  int CHUNK_SHIFT_BIT_COUNT =10;          //移位ONE_CHUNK_COUNT 需要移位运送多少位
	//const static  int  CHUNK_MASK=0x3ff  ;                  //取在1024块里的位置
};




template <typename TAG>
inline bool operator != ( Handle <TAG> l, Handle <TAG> r )
{ 
	return ( l.GetHandle() != r.GetHandle() ); 
}

template <typename TAG>
inline bool operator == ( Handle <TAG> l, Handle <TAG> r )
{ 
	return ( l.GetHandle() == r.GetHandle() ); 
}

template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT> :: HandleMgr(LPCTSTR lpszDesc = NULL)
{ 
	m_nFirstFreeIndex = INVALID_INDEX;
	m_nLastChunkFirstFreeIndex   = INVALID_INDEX;
	m_nUsedCount =0;
}
template <typename DATA, typename HANDLE, int ONE_CHUNK_COUNT>
void HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT> ::Empty()
{
	for(INT_PTR i=0; i<m_UserData.count(); i++)
	{
		for(INT_PTR j=0; j< ONE_CHUNK_COUNT ; j ++)
		{
			HANDLE hd = m_MagicNumbers[i][j];
			if(! hd.IsNull() )
			{
				DATA *pdata =&( m_UserData[i][j]);
				if(pdata)
				{
					pdata->~DATA();
				}
				TRACE(_T("Node not releaseed on HanderMgr destroy,DataSize =%d, hander=%d,index=%d\n"),sizeof(DATA),hd.GetHandle(),hd.GetIndex());
				//OutputMsg(rmError,_T("Node not releaseed on HanderMgr destroy,DataSize =%d, hander=%d,index=%d"),sizeof(DATA),hd.GetHandle(),hd.GetIndex());
			}
		}
		m_UserData[i].empty();	
	}

	for(INT_PTR i=0; i<m_UserData.count(); i++)
	{
		m_MagicNumbers[i].empty();
	}
	m_UserData.empty();
	m_MagicNumbers.empty();
}


template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
DATA* HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT> :: Acquire( HANDLE& handle )
{
	// if free list is empty, add a new one otherwise use first one found 如果空闲列表为空，则新增一个，否则使用第一个可用表项
	UINT index =INVALID_INDEX;
	UINT nChunkId =0,nPos=0;

	//如果前面有空闲的位置,优先使用空闲的对象
	if (m_nFirstFreeIndex != INVALID_INDEX) 
	{
		index = m_nFirstFreeIndex;
		GetChunkIdPos(m_nFirstFreeIndex,nChunkId,nPos);	// 获取当前空闲句柄的位置（在第几块的第几个槽）
		m_nFirstFreeIndex = INVALID_INDEX;				// 设置当前空闲有效句柄为INVALID_INDEX

		//查找一个空闲的
		for(INT i =nChunkId ; i < (INT)m_MagicNumbers.count(); i++)	// m_MagicNumbers.count() 是数据块的数目
		{
			//只有在这个块有空闲的才去查找,避免了无效的查询,最多1024个
			bool bFindNextFreeItem = false;
			INT nFreeCount =  m_FreeCounts[i];
			if( nFreeCount > 0 )
			{
				INT j =0;
				if( nChunkId == i ) //如果是本块,那么从后一个查起
				{
					j = nPos +1;
					if(nFreeCount ==1) //本块只有1块,那肯定用过了阿
					{
						continue;
					}
				}
				CBaseList<HANDLE> & pHandChunk = m_MagicNumbers[i];	// 第i块的句柄数据
				for (; j < ONE_CHUNK_COUNT; j++)
				{
					//HANDLE hTemp = ;
					if( pHandChunk[j].GetMagic() ==0)
					{
						m_nFirstFreeIndex = (i * ONE_CHUNK_COUNT) + j;// 下一个空闲句柄位置
						bFindNextFreeItem = true;
						break;
					}
				}
			}

			if (bFindNextFreeItem)
				break;
		}
		//如果其已经到了空闲列表的最后一个了,那么说明前面已经没有可用使用的了
		if (m_nFirstFreeIndex == m_nLastChunkFirstFreeIndex)
		{
			m_nFirstFreeIndex = INVALID_INDEX;
		}
	}
	else
	{
		if(m_nLastChunkFirstFreeIndex  == INVALID_INDEX ) //if no chunk
		{
			//已经无法申请了
			UINT nTotalCount =  GetTotalHandleCount();
			Assert(nTotalCount == GetUsedHandleCount());
			if ( (unsigned int) nTotalCount >= handle.GetMaxIndex()) return NULL; //已经无法申请了,超过了最大数量
	
			CBaseList<DATA> dataChunk;
			CBaseList<HANDLE> handleChunk;
			m_UserData.addArray(&dataChunk,1); //添加到列表
			m_MagicNumbers.addArray(&handleChunk,1);
			INT_PTR nBackIndex = m_UserData.count();	// m_UserData.count() 是当前数据块的块数目
			if (nBackIndex <1) return NULL;
			nBackIndex --;	// 最后一个块的索引			
			m_UserData[nBackIndex].reserve(ONE_CHUNK_COUNT);	// 保证每个块都是同样长度
			m_UserData[nBackIndex].trunc(ONE_CHUNK_COUNT);
		
			m_MagicNumbers[nBackIndex].reserve(ONE_CHUNK_COUNT);
			m_MagicNumbers[nBackIndex].trunc(ONE_CHUNK_COUNT);
			HANDLE *pHandle = m_MagicNumbers[nBackIndex];		// 最后一个句柄块
			
			memset(pHandle,0,sizeof(HANDLE) *ONE_CHUNK_COUNT );	// 初始化最后一个句柄块
			//使用placement new 调用构造函数
		
			m_nLastChunkFirstFreeIndex = nTotalCount; //当前的最大数量,指向下一个
		
			m_FreeCounts.add(ONE_CHUNK_COUNT); //这个块还有多少个没有使用
			//m_nAllocedChunkCount++;
		}
		if(m_nLastChunkFirstFreeIndex != INVALID_INDEX)
		{
			index = m_nLastChunkFirstFreeIndex;
			m_nLastChunkFirstFreeIndex ++; //指向下一个

			if(m_nLastChunkFirstFreeIndex >= (unsigned) GetTotalHandleCount()) //如果这个块使用完了,就需要重新申请空间了
			{
				m_nLastChunkFirstFreeIndex = INVALID_INDEX;
			}
		}
	}
	
	
	//实在是找不到可以使用的了
	if ( index == INVALID_INDEX)	return NULL;
	handle.Init( index );
	GetChunkIdPos(index,nChunkId,nPos);
	unsigned int nFreeCount =  m_FreeCounts[nChunkId];
	if (nChunkId < (UINT)m_MagicNumbers.count() && nFreeCount >0 )
	{
		m_MagicNumbers[nChunkId][nPos] =handle;
	}
	else
	{		
		return NULL;
	}

	m_FreeCounts[nChunkId]--; //这个列表空闲的数量 	

	DATA *pData = &(m_UserData[nChunkId][nPos]);
	new(pData)DATA();//placement new
	m_nUsedCount++;
	//m_nUsedHdlCount++;
	//if (m_nUsedHdlCount > m_nMaxUsedHandleCount)
	//	m_nMaxUsedHandleCount = m_nUsedHdlCount;
	return pData;
}

template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
void HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT> :: ReleaseDataPtr( DATA * pData )
{
	UINT_PTR count =m_UserData.count();
	SIZE_T nChunkSize = ONE_CHUNK_COUNT * sizeof(DATA);  //每一块Chunk的大小,每次申请1024个
	UINT_PTR nEndIndex = ONE_CHUNK_COUNT -1; //1023
	for (UINT_PTR i= 0;i< count; i++)
	{
		DATA * pStart = &m_UserData[i][0];
		DATA * pEnd =  &m_UserData[i][nEndIndex];
		
		INT_PTR nDataIndex = pData -pStart;  //第多少个数据
		if(nDataIndex >= 0 && pData <=  pEnd) //找到了这个内存块
		{
			INT_PTR nByteDis = (char *)pData -  (char *)pStart;
			if( nByteDis  % sizeof(DATA) != 0) //内存长度错误
			{
				return; 
			}
			Release( m_MagicNumbers[i][nDataIndex] );
			return;
		}
	}
}


template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
void HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT> :: Release( HANDLE handle )
{
	// which one? 哪一个
	if ( handle.IsNull() )return;
	unsigned int index = handle.GetIndex();
	UINT nChunkId =0,nPos=0;
	GetChunkIdPos(index,nChunkId,nPos);

	if( nChunkId  >= (UINT)m_MagicNumbers.count() ) return ; //有问题,已经超过了
	if (m_MagicNumbers[nChunkId][nPos].GetMagic() != handle.GetMagic()) return; //重复释放

	// ok remove it - tag as unused and add to free list 可以删除了--表及其没有使用并加到空闲列表
	
	if (index < m_nFirstFreeIndex )
	{
		m_nFirstFreeIndex = index;
	}
	HANDLE hTemp;
	m_MagicNumbers[nChunkId][nPos] =hTemp;
	

	//调用析构函数
	DATA *pdata =&( m_UserData[nChunkId][nPos]);
	if(pdata)
	{
		pdata->~DATA();
	}

	m_FreeCounts[nChunkId] ++; //这个块的空闲的个数 -1
	m_nUsedCount--;	
	//m_nUsedHdlCount--;
}

template<typename DATA, typename HANDLE, int ONE_CHUNK_COUNT>
bool HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT> :: ReNew( HANDLE &handle)
{
	if (handle.IsNull())
		return false;

	// check handle validity
	unsigned int index = handle.GetIndex();
	UINT nChunkId =0,nPos=0;
	GetChunkIdPos(index,nChunkId,nPos);
	if (nChunkId > (UINT)m_MagicNumbers.count() || m_MagicNumbers[nChunkId][nPos].GetMagic() != handle.GetMagic())
		return false;

	handle.updateMagic();
	m_MagicNumbers[nChunkId][nPos] = handle;
	return true;
}


template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
inline DATA* HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT>
	:: GetDataPtr( HANDLE handle )
{
	if ( handle.IsNull() ) return ( 0 );
	unsigned int index = handle.GetIndex();
	UINT nChunkId =0,nPos=0;
	GetChunkIdPos(index,nChunkId,nPos);

	// check handle validity - $ this check can be removed for speed 检查句柄有效性-为提供性能可以去掉这个检查
	// if you can assume all handle references are always valid. 如果你假设索引句柄解引用都总是有效

	if( nChunkId  >=(UINT)m_MagicNumbers.count()) return NULL; //有问题,
	if (m_MagicNumbers[nChunkId][nPos].GetMagic() != handle.GetMagic()) 
		return NULL; //重复释放

	return (& m_UserData[nChunkId][nPos] );
}

template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
inline const DATA* HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT>
	:: GetDataPtr( HANDLE handle ) const
{
	// this lazy cast is ok - non-const version does not modify anything
	typedef HandleMgr <DATA, HANDLE> ThisType;
	return ( const_cast <ThisType*> ( this )->GetDataPtr( handle ) );
}


//获取第1个有效的数据指针，结果的句柄要放在 hHandle,数据指针放在DATA*
template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
 DATA* HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT>
 ::First(HANDLE & hHandle)
{
	
	INT_PTR count=	m_FreeCounts.count();
	for(int i=0; i< count; i++)
	{
		if(ONE_CHUNK_COUNT- m_FreeCounts[i] >0 ) //如果一个块里有数据，那么就在这个块里找
		{
			
			for(INT_PTR j=0; j< ONE_CHUNK_COUNT; j++)
			{
				if(m_MagicNumbers[i][j] != 0)
				{
					hHandle = m_MagicNumbers[i][j];
					return &m_UserData[i][j];
				}
			}
		}
	}
	return NULL;
}

//hHandle 句柄 下一个有效数据的指针，DATA 为该数据指针
 template <typename DATA, typename HANDLE,int ONE_CHUNK_COUNT>
 DATA* HandleMgr <DATA, HANDLE,ONE_CHUNK_COUNT>
:: Next(HANDLE & hHandle)
{
	if(hHandle ==0) return NULL; //压根就没有输入
	UINT index = hHandle.GetIndex();
	UINT nChunkId =0,nPos=0;
	GetChunkIdPos(index,nChunkId,nPos);

	for(INT_PTR i =nChunkId ; i < m_MagicNumbers.count(); i++)
	{
		//只有在这个块有空闲的才去查找,避免了无效的查询,最多1024个
		INT_PTR nFreeCount =  m_FreeCounts[i];
		if( ONE_CHUNK_COUNT- nFreeCount >0   )
		{
			INT_PTR j =0;
			if( nChunkId == i ) //如果是本块,那么从后一个查起
			{
				j = nPos +1;
				if(nFreeCount ==1) //本块只有1块,那肯定用过了阿
				{
					continue;
				}
			}
			CBaseList<HANDLE> & pHandChunk = m_MagicNumbers[i];
			for (; j < ONE_CHUNK_COUNT; j++)
			{
				//HANDLE hTemp = ;
				if( pHandChunk[j].GetMagic() !=0)
				{
					hHandle = pHandChunk[j];
					return  &m_UserData[i][j];
				}
			}
		}
	}
	return NULL;
}