#include "StdAfx.h"
#include "Container.hpp"
const TCHAR* const CRanking::m_sClassName = _T("CRanking");


int CRankingItem::GetIndex()
{
	if(pParent ==NULL || !IsValid()) return -10000;
	return pParent->GetNodeIndex(this);
}


//设置某列的数据
void CRankingItem::SetSub(INT_PTR nIndex, LPCSTR sData)
{
	CHECK_RANK_ITEM_VALID()
	if (sCd && nIndex >=0 && nIndex < nColCount && sData)
	{
		size_t nLen = strlen(sData);
		if (!sCd[nIndex])
		{
			sCd[nIndex] = (char*)CRankingMgr::m_pAllocator->AllocBuffer(nLen+1);
		}else if (strlen(sCd[nIndex]) < nLen)
		{
			CRankingMgr::m_pAllocator->FreeBuffer(sCd[nIndex]);
			sCd[nIndex] = (char*)CRankingMgr::m_pAllocator->AllocBuffer(nLen+1);
		}
		strcpy(sCd[nIndex],sData);
		sCd[nIndex][nLen] = 0;

		if(pParent && pParent->IsValid())
		{
			pParent->SetModify(true);
		}
	}
}

void CRankingItem::SetSub(INT_PTR nIndex, unsigned int nValue){
	char buf[20];
	sprintf_s(buf,sizeof(buf),"%u",nValue);
	SetSub(nIndex, buf);
}

void CRankingItem::SetId(unsigned int id) 
{
	CHECK_RANK_ITEM_VALID()  
	
	nId = id;
	if(pParent && pParent->IsValid())
		pParent->SetModify(true);
}

void CRankingItem::SetPoint(int point)
{
	CHECK_RANK_ITEM_VALID() 
	nPoint = point; 
	if(pParent && pParent->IsValid())
		pParent->SetModify(true);
}


void CRankingItem::SetParam(int param)
{
	CHECK_RANK_ITEM_VALID() 
	nParam = param; 
	if(pParent && pParent->IsValid())
		pParent->SetModify(true);
}


void CRankingItem::SetParam1(int param1)
{
	CHECK_RANK_ITEM_VALID() 
	nParam1 = param1; 
	if(pParent && pParent->IsValid())
		pParent->SetModify(true);
}

void CRankingItem::RemoveColumn(INT_PTR nIndex)
{
	CHECK_RANK_ITEM_VALID()
	if (sCd && nIndex >=0 && nIndex < nColCount && nColCount > 0)
	{
		if (sCd[nIndex])
		{
			CRankingMgr::m_pAllocator->FreeBuffer(sCd[nIndex]);
		}
		memcpy(sCd+nIndex,sCd+nIndex+1,sizeof(char*)* (nColCount - nIndex - 1));//后面的数据往前移
		nColCount--;
		if (nColCount > 0)
		{
			sCd[nColCount-1] = NULL;
		}
		/*
		if(pParent && pParent->IsValid())
		{
			pParent->SetModify();
		}
		*/

	}
}



void CRankingItem::AddColumn(LPCSTR sData,INT_PTR nIndex, bool bUnique)
{
		CHECK_RANK_ITEM_VALID()
		if (bUnique)
		{
			for (INT_PTR i = 0; i < nColCount; i ++)
			{
				if (0 == strcmp(sCd[i],sData))
					return;
			}
		}
		if (nIndex == -1)
		{
			SetColCount(nColCount+1);
			SetSub(nColCount-1,sData);
		}
		else if (nIndex >= 0 && nIndex < nColCount)
		{
			SetColCount(nColCount+1);
			memmove(sCd+(nIndex+1),sCd+nIndex,sizeof(char*)*(nColCount-nIndex));//列往后移
			sCd[nIndex] = NULL;
			SetSub(nIndex,sData);
		}
		/*
		if(pParent && pParent->IsValid())
		{
			pParent->SetModify(true);
		}
		*/

}

void CRankingItem::SetColumnTitle(LPCSTR sData, INT_PTR nIndex)
{
		CHECK_RANK_ITEM_VALID()
		if (nIndex >= 0 && nIndex < nColCount)
		{
			SetSub(nIndex, sData);
		}
		else
		{
			OutputMsg(rmError, "SetColumnTitle Error, Index wrong!");
		}
		/*
		if(pParent && pParent->IsValid())
		{
			pParent->SetModify(true);
		}
		*/

}





////////////////////////////////////////////////    CRanking        /////////////////////////////////
#pragma warning(push)
#pragma warning(disable:4355) 
CRanking::CRanking( LPCSTR sFileName ,INT_PTR nMax,bool boDisp,INT_PTR nMaxBroadCount):m_Title(this)
#pragma warning(pop)

{
	if (sFileName)
	{
		_asncpytA(m_szName,sFileName);
		if(strcmp(m_szName + strlen(m_szName) - 4, ".Rank"))
		{
			sprintf(m_szFile,"%s.Rank",m_szName);
		}
		else
		{
			_asncpytA(m_szFile, m_szName);
		}
	}else
	{
		m_szName[0];
		m_szFile[0] = 0;
	}
	m_szCnName[0] = 0;
	m_idTitle[0] = 0;
	m_pointTitle[0] = 0;

	m_RankMax				= (int)nMax;
	m_nMaxBroadCount		= (int)nMaxBroadCount;
	m_rankVisibleType		= enVisible_All;	
	ZeroMemory(&m_rankVisibleParam, sizeof(m_rankVisibleParam));
	m_Display				= boDisp;
	ZeroMemory(m_ColDisplay,sizeof(m_ColDisplay));
	m_boModify = false;
	m_bRmptySave =	false;
	m_columnCount =0;
	m_isRanked =true;
	m_nCheckSum = RANKING_CHECUSUM;
	m_saveTick = _getTickCount() + s_nDur;
	AtachRankProp(sFileName);	//初始化属性排行榜配置
	m_canSave = true;
}

CRanking::~CRanking()
{
	if (!IsValid())
	{
		return;
	}
	
	//保存数据并释放内存
	if(m_boModify)
	{
		Save(NULL,true);
	}

	for (INT_PTR i = 0; i < m_ItemList.count(); i++)
	{
		CRankingItem* item = m_ItemList[i];
		if(item && item->IsValid())
		{
			item->~CRankingItem();
			CRankingMgr::m_pAllocator->FreeBuffer(item);
		}
	}
	m_Title.Destroy();
	m_ItemList.empty();
	m_nCheckSum = 0;
	DetachhRankProp(m_szName);	
	m_boModify = false;
}

void CRanking::destroy()
{	
	//GetGlobalLogicEngine()->GetRankingMgr().Remove(m_szName);
}

void CRanking::clear()
{
	CHECK_RANK_VALID()
	for (INT_PTR i = 0; i < m_ItemList.count(); i++)
	{
		CRankingItem* item = m_ItemList[i];
		UpdateRankProp(item,i,true);
		if(item && item->IsValid())
		{
			item->~CRankingItem();
			CRankingMgr::m_pAllocator->FreeBuffer(item);
		}
	}

	m_ItemList.clear();
	SetEmptySave(true);
	m_boModify = true;

	Save(NULL, true);
}

bool CRanking::Load(LPCSTR sFile)
{
   	DECLARE_TIME_PROF("CRanking::Load");
	char sPath[256];
	sprintf_s(sPath,sizeof(sPath),"./data/runtime/rank/");
	if (!FDOP::FileExists(sPath))
	{
		FDOP::DeepCreateDirectory(sPath);
	}
	if(!sFile || !strlen(sFile)){
		sFile = m_szFile;
	}
	strcat(sPath,sFile);
	if(strcmp(sPath + strlen(sPath) - 5, ".Rank"))strcat(sPath,".Rank");
	FILE* fp = fopen(sPath,"r");
	if (!fp)
	{
		return false;
	}
	if (sFile != m_szFile)
	{
		_asncpytA(m_szFile,sFile);//保存的文件名
	}
	/*
	if(strcmp(sFile,"wishValue.txt") ==0)
	{
		OutputMsg(rmTip,"LOAD");
	}
	*/

	//纯文本，tab隔开各个字段，每行一个记录,第一行是标题
	INT_PTR row = 0;
	const INT_PTR size = 128;
	char sBuf[size];//缓冲区,保存每列的字符串，128应该够了
	INT_PTR bufpos = 0;
	INT_PTR col = 0;
	m_Title.Destroy(); // 为了支持重新从文件加载，先清空标题栏的所有列，否则标题出现双倍列数，导致排行榜加载失败
	CRankingItem* pItem = &m_Title;
	pItem->SetParent(this);
	char ch = (char)fgetc(fp);
	while (!feof(fp))
	{
		if (ch == '\n')//
		{
			sBuf[bufpos] = 0;
			if(bufpos ==0 && row ==0)
			{
				OutputMsg(rmError,"[1]排行榜文件%s,添加列失败,行=%d!",sPath,(int)row);
				goto lb_load_fail;
			}
			pItem->AddColumn(sBuf,-1);//这是列的数据

			bufpos = 0;	
			col = 0;
			if (row > 0)
			{
				if(pItem->GetColCount() != m_Title.GetColCount())
				{
					OutputMsg(rmError,"[2]排行榜文件%s 第%d行出现列数错误,标题的列数为%d,实际为%d，清查看数据",sPath,(int)row,(int)m_Title.GetColCount(),(int)pItem->GetColCount());
					goto lb_load_fail;
					//Assert(0);
				}
				//m_ItemList.add(pItem);			
				//INT_PTR nPos=GetInsertPos(pItem->nPoint); //获取应该插入的位置

				//m_ItemList.insert(nPos,pItem);
				m_ItemList.add(pItem);

				pItem = NULL;
			}
			
			pItem = (CRankingItem*)CRankingMgr::m_pAllocator->AllocBuffer(sizeof(CRankingItem));//下一行的数据
			new (pItem)CRankingItem(this);
			//pItem->SetParent(this);
			row++;
		}
		else if (ch == '\t')
		{
			sBuf[bufpos] = 0;
			if (col < 2)
			{
				//前两个是数字
				unsigned int value = (unsigned int)atof(sBuf);
				if (col == 0) pItem->nId = value;//id和分值的数据
				else pItem->nPoint = value;
			}
			else
			{
				if(sBuf[0] ==0 && row ==0)
				{
					OutputMsg(rmError,"[3]排行榜文件%s,添加列失败,行=%d,行=0表示是标题!",sPath,(int)row);
					//Assert(0);
					goto lb_load_fail;
				}
				pItem->AddColumn(sBuf,-1);//这是列的数据
			}
			bufpos = 0;
			col++;
		}
		else
		{
			if (bufpos < (size-1))
			{
				sBuf[bufpos++] = ch;
			}
		}
		ch = (char)fgetc(fp);
	}
	fclose(fp);

	if(pItem)//还有数据没加到队列中
	{
		sBuf[bufpos] = 0;
		if(sBuf[0] ==0 && row ==0)
		{
			OutputMsg(rmError,"[4]排行榜文件%s,添加列失败,行=%d,行=0表示是标题!",sPath,(int)row);
			//Assert(0);
			goto lb_load_fail;
		}
		pItem->AddColumn(sBuf,-1);//这是列的数据
		bufpos = 0;
		col = 0;
		if (row > 0)
		{
			if(pItem->GetColCount() != m_Title.GetColCount())
			{
				OutputMsg(rmError,"排行榜文件%s 第%行出现列数错误,标题的列数为%d,实际为%d，清查看数据",sPath,(int)row,(int)m_Title.GetColCount(),(int)pItem->GetColCount());
				//Assert(0);
				goto lb_load_fail;
			}		
			//INT_PTR nPos=GetInsertPos(pItem->nPoint); //获取应该插入的位置
			//m_ItemList.insert(nPos,pItem);
			m_ItemList.add(pItem);
		}
		else
		{
			
		}
		row++;
	}
	//刚装载完认为没有修改
	SetModify(false);

	return true;

lb_load_fail:
	//增加了容错处理
	
	for (INT_PTR i = 0; i < m_ItemList.count(); i++)
	{
		CRankingItem* item = m_ItemList[i];

		if(item && item->IsValid())
		{
			item->~CRankingItem();
			CRankingMgr::m_pAllocator->FreeBuffer(item);
		}
	}
	//清掉这些列
	m_ItemList.clear();
	m_Title.Destroy();

	return false;


}

void CRanking::ForceSave(LPCSTR sFile)
{
	CHECK_RANK_VALID()
   	DECLARE_TIME_PROF("CRanking::ForceSave");
	FILE* fp =NULL;
	CStringBuff &buff =GetGlobalLogicEngine()->GetStringBuff();
#ifdef _USE_TRY_CATCH
#ifdef WIN32
	__try
#endif
#endif 
	{	
		// 没有项，不需要保存 且，空数据不保存文件
		if (!m_bRmptySave && GetItemCount() <= 0)
		{  
			return;
		}

		char sPath[256];
		sprintf_s(sPath,sizeof(sPath),"./data/runtime/rank/"/*, GetLogicServer()->getStrFilePath()*/);
		if (!FDOP::FileExists(sPath))
		{
			FDOP::DeepCreateDirectory(sPath);
		}

		LPCSTR szRealFile = sFile? sFile : m_szFile;
		if (szRealFile == NULL || szRealFile[0] == 0)
		{
			szRealFile = (m_szName);		
		}
		strcat(sPath,szRealFile);
		if(strcmp(sPath + strlen(sPath) - 4, ".txt"))strcat(sPath,".txt");// 末尾不是".txt"就添加
		fp = fopen(sPath,"w");
		if (!fp)
		{
			OutputMsg(rmError,"打开文件失败 %s",m_szFile);
			return;
		}

		if(buff.IsLock())
		{
			OutputMsg(rmError," Force Save rank %s, buff is lock",m_szFile);
			fclose(fp);
			return;
		}
		OutputMsg(rmTip,"Force Save rank%s",sPath);

		buff.Reset();
		buff.SetLock(true);

		SaveItem(&m_Title, buff);//保存标题先

		INT_PTR nCount = m_ItemList.count();
		if (nCount > 0)
		{
			//fputc('\n',fp);
			buff <<('\n');
		}
		for (INT_PTR i = 0; i < nCount; i++)
		{
			CRankingItem* pItem = m_ItemList[i];

			SaveItem(pItem,buff);
			if (i != (nCount-1))
			{
				buff <<('\n');
			}
		}

		fwrite(buff.Get(),strlen(buff.Get()),1,fp); //把存盘改下

		//fputs(buff.Get(),fp);
		fclose(fp);
		buff.SetLock(false);
	}

#ifdef _USE_TRY_CATCH
#ifdef WIN32
	__except(CustomExceptHandler(GetExceptionInformation()))
	{
		if(buff.IsLock())
		{
			buff.SetLock(false);
		}
		if(fp)
		{
			fclose(fp);
		}
	}
#endif 
#endif 
}

void CRanking::Save(LPCSTR sFile,bool forceSave)
{
	if (!m_canSave)
	{
		return;
	}
	
	CHECK_RANK_VALID()
	if(!m_boModify) return; //没有改变
	
	//这里可能是不需要存盘
	if( !forceSave && m_saveTick > GetGlobalLogicEngine()->getTickCount() )
	{
		return;
	}
	DECLARE_TIME_PROF("CRanking::Save");

	FILE* fp =NULL;
	CStringBuff &buff =GetGlobalLogicEngine()->GetStringBuff();
#ifdef _USE_TRY_CATCH
#ifdef WIN32
	__try
#endif 
#endif
	{	
		// 没有项，不需要保存 且，空数据不保存文件
		//注意：m_bRmptySave还是要确保为true，否则榜一旦清空了会不保存，导致磁盘上的数据还在
		if (!m_bRmptySave && GetItemCount() <= 0)
		{  
			return;
		}
		
		char sPath[256];
		sprintf_s(sPath,sizeof(sPath),"./data/runtime/rank/"/*, GetLogicServer()->getStrFilePath()*/);
		if (!FDOP::FileExists(sPath))
		{
			FDOP::DeepCreateDirectory(sPath);
		}

		LPCSTR szRealFile = sFile? sFile : m_szFile;
		if (szRealFile == NULL || szRealFile[0] == 0)
		{
			szRealFile = (m_szName);		
		}
		strcat(sPath,szRealFile);
		if(strcmp(sPath + strlen(sPath) - 5, ".Rank"))strcat(sPath,".Rank");// 末尾不是".Rank"就添加
		fp = fopen(sPath,"w");
		if (!fp)
		{
			OutputMsg(rmError,"打开文件失败 %s",m_szFile);
			return;
		}

		if(buff.IsLock())
		{
			OutputMsg(rmError,"Save rank %s, buff is lock",m_szFile);
			fclose(fp);
			return;
		}
		OutputMsg(rmTip,"Save rank%s",sPath);

		buff.Reset();
		buff.SetLock(true);

		SaveItem(&m_Title, buff);//保存标题先

		INT_PTR nCount = m_ItemList.count();
		if (nCount > 0)
		{
			//fputc('\n',fp);
			buff <<('\n');
		}
		for (INT_PTR i = 0; i < nCount; i++)
		{
			CRankingItem* pItem = m_ItemList[i];
		
			SaveItem(pItem,buff);
			if (i != (nCount-1))
			{
				buff <<('\n');
			}
		}
		
		fwrite(buff.Get(),strlen(buff.Get()),1,fp); //把存盘改下

		//fputs(buff.Get(),fp);
		fclose(fp);
		m_boModify = false;
		m_saveTick =  GetGlobalLogicEngine()->getTickCount() + s_nDur; //存盘的间隔

		buff.SetLock(false);
}

#ifdef _USE_TRY_CATCH
#ifdef WIN32
	__except(CustomExceptHandler(GetExceptionInformation()))
	{
		if(buff.IsLock())
		{
			buff.SetLock(false);
		}
		if(fp)
		{
			fclose(fp);
		}
	}
#endif 
#endif
}

void CRanking::AddColumn( LPCSTR sTitle, INT_PTR nIndex, bool bUnique )
{
	CHECK_RANK_VALID()
	if(sTitle == NULL || sTitle[0] ==0)
	{
		OutputMsg(rmError,"AddColumn error, rank=%s, title is NULL",m_szFile);
		return;
	}
	m_Title.AddColumn(sTitle,nIndex,bUnique);
	INT_PTR nCount = m_ItemList.count();
	for (INT_PTR i = 0; i < nCount; i++)//所有排行榜项都要增加
	{
		CRankingItem* item = m_ItemList[i];
		item->AddColumn("-",nIndex,bUnique);//空的数据
	}
	m_boModify = true;
}

void CRanking::SetColumnTitle(LPCSTR sTitle, INT_PTR nIndex)
{
	CHECK_RANK_VALID()
	m_Title.SetColumnTitle(sTitle, nIndex);	//设置列标题
}

void CRanking::RemoveColumn( INT_PTR nIndex )
{
	CHECK_RANK_VALID()
	m_Title.RemoveColumn(nIndex);
	INT_PTR nCount = m_ItemList.count();
	for (INT_PTR i = 0; i < nCount; i++)//所有排行榜项都要增加
	{
		CRankingItem* item = m_ItemList[i];
		item->RemoveColumn(nIndex);
	}
	m_boModify = true;
}



CRankingItem* CRanking::Update( INT_PTR nId, INT_PTR nPoint )
{
	if(!IsValid())return NULL;
	INT_PTR index = GetIndexFromId(nId);
	if ((index >= 0) && (index < m_ItemList.count()))
	{
		CRankingItem* item = m_ItemList[index];
		if ( item && nPoint != 0)
		{
			INT_PTR newPoint = item->nPoint + nPoint; //新的分数

			item->SetPoint((int)newPoint);
			

			INT_PTR nNewPos= GetInsertPos((int)newPoint);

			//如果让插入到最后的话，在后面的分数都一样的情况下，加个判断，防止自己删除又加上去的无用的操作
			if(nNewPos != index && nNewPos >=0 && nNewPos < m_ItemList.count())
			{
				m_ItemList.remove(index); //先删除这个项

				nNewPos= GetInsertPos((int)newPoint);
				m_ItemList.insert(nNewPos,item);
				UpdateRankProp(item,nNewPos);
			}
				
			m_boModify = true;
	
		}
		return item;
	}
	else
	{
		return NULL;
	}
}


CRankingItem* CRanking::Set( INT_PTR nId, INT_PTR nPoint )
{
	if(!IsValid())return NULL;
	INT_PTR index = GetIndexFromId(nId);
	if ((index >= 0) && (index < m_ItemList.count()))
	{
		CRankingItem* item = m_ItemList[index];
		if ( item && item->nPoint != nPoint)
		{
			//先删除原来的，再找个新位置添加进去就可以了
			item->SetPoint((int)nPoint);

			if(m_isRanked)
			{
				INT_PTR nNewPos= GetInsertPos((int)nPoint);
				if(nNewPos != index)
				{
					m_ItemList.remove(index); //先删除这个项

					nNewPos= GetInsertPos((int)nPoint);
					m_ItemList.insert(nNewPos,item);
					UpdateRankProp(item,nNewPos);
				}
			}
			
			m_boModify = true;
		}
		return item;
	}
	else
	{
		return NULL;
	}
}

void CRanking::RemoveId( INT_PTR nId )
{
	CHECK_RANK_VALID()
	INT_PTR index = GetIndexFromId(nId);
	if ((index >= 0) && (index < m_ItemList.count()))
	{
		CRankingItem* pItem = m_ItemList[index];
		if (pItem &&pItem->IsValid())
		{
			UpdateRankProp(pItem,index,true);
			m_ItemList.remove(index);
			pItem->~CRankingItem();
			CRankingMgr::m_pAllocator->FreeBuffer(pItem);
		}
		m_boModify = true;
	}
}

CRankingItem* CRanking::GetPtrFromId( INT_PTR nId ,INT_PTR& nIndex)
{
	if(!IsValid())return NULL;
	nIndex= GetIndexFromId(nId);
	if (nIndex < 0 || nIndex >= m_ItemList.count()) return NULL;
	return m_ItemList[nIndex];
}


CRankingItem*  CRanking::GetPtrFromId(UINT_PTR nId)
{
	if(!IsValid())return NULL;
	INT_PTR nIndex= GetIndexFromId(nId);
	if (nIndex < 0 || nIndex >= m_ItemList.count()) return NULL;
	return m_ItemList[nIndex];
}




INT_PTR CRanking::GetIndexFromId( UINT_PTR nId )
{
	if(!IsValid())return -1;
	if(nId ==0) return -1;
	for(INT_PTR i=m_ItemList.count() -1; i >=0 ; i-- )
	{
		if(m_ItemList[i]->nId == nId)
		{
			return i;
		}
	}
	return -1;
}

bool CRanking::SwapItem(INT_PTR nPos1,INT_PTR nPos2 )
{
	if(!IsValid())return false;

	/*
	if(m_isRanked)
	{
		OutputMsg(rmError,"Rank %sis Raned,can not swapitem",m_szFile);
		return false;
	}
	*/

	if(nPos1 == nPos2 ) return false;
	if(nPos1 <0 || nPos1 >= m_ItemList.count() ||  nPos2 <0 || nPos2 >= m_ItemList.count() )
	{
		return false;
	}
	CRankingItem *pItem1= m_ItemList[nPos1];
	CRankingItem *pItem2= m_ItemList[nPos2];
	if(pItem1->IsValid() && pItem2->IsValid())
	{
		m_ItemList[nPos1]=pItem2;
		m_ItemList[nPos2]=pItem1;
		m_boModify =true;
		m_isRanked =false;
		return true;
	}
	else
	{
		return false;
	}
}
bool CRanking::JumpQueue(CRankingItem *pItem,INT_PTR nNewPos)
{
	if(!IsValid())return false;

	INT_PTR nPos = pItem->GetIndex();
	if(nPos <0 || nPos >= m_ItemList.count()) return false;
	
	//已经排序好的不需要重新排列
	if(isRanked())
	{
		OutputMsg(rmError,"Ranked rank %scan not jump queue",m_szFile);
		return false;
	}
	if(nPos ==nNewPos )return false;
	if(nNewPos <0 || nNewPos >= m_ItemList.count()) return false;

	m_ItemList.remove(nPos);
	m_ItemList.insert(nNewPos,pItem); //插队
	m_boModify =true;
	return true;
}
//降序去查找一个位置
INT_PTR CRanking::GetInsertPos(int nPoint)
{
	if(!IsValid())
	{
		return 0;
	}
	if(m_ItemList.count() <=0) return 0;

	for(INT_PTR i=0 ; i< m_ItemList.count() ;i ++)
	{
		int nComp = m_ItemList[i]->nPoint;
		if(nPoint > nComp) //如果分数大于这个点了
		{
			return i;
		}
	}
	return  m_ItemList.count() ;
}

CRankingItem* CRanking::AddItem( UINT_PTR nId,INT_PTR nPoints/* = 0*/,bool bRankFlag)
{
	if(!IsValid())
		return NULL;
	INT_PTR nIdIndex = GetIndexFromId(nId);

	if ( nIdIndex>= 0)
	{
		return NULL;
	}
	
	CRankingItem* item = (CRankingItem*)CRankingMgr::m_pAllocator->AllocBuffer(sizeof(CRankingItem));
	new (item)CRankingItem(this);
	item->SetPoint((int)nPoints);
	item->SetId((unsigned int)nId);	// 
	item->SetColCount(m_Title.GetColCount());
	//item->SetParent(this);

	//如果需要排序的话就排序下，否则直接放后面
	if(bRankFlag)
	{
		INT_PTR nPos = GetInsertPos((int)nPoints); //获取需要插入的位置
		
		m_ItemList.insert(nPos,item);
		UpdateRankProp(item,nPos);		
	}
	else
	{
		m_ItemList.add(item);  
		UpdateRankProp(item,m_ItemList.count() -1);
		SetRanked(false); //这已经不是排序好的表了
	}
	

	m_boModify = true;

	return item;
}

CRankingItem* CRanking::GetItem( INT_PTR nIndex )
{
	if(!IsValid())return NULL;
	if (nIndex >= 0 && nIndex < m_ItemList.count())
	{
		return m_ItemList[nIndex];
	}
	return NULL;
}


/*
CRankingItem* CRanking::FindMaxItem()
{
	if(!IsValid())return NULL;

	INT_PTR nCount = m_ItemList.count();
	if ( nCount <=0 )
	{
		return NULL;
	}
	if(isRanked()) //如果是排序好的话，直接取第1个
	{
		return m_ItemList[0];
	}
	else  //没有排序好，需要便利查找
	{
		int nPoint =-1;
		int nIndex =-1;
		for(INT_PTR i=0;i < m_ItemList.count(); i++)
		{
			CRankingItem *pItem = m_ItemList[i];
			if(pItem->IsValid() && pItem->GetPoint() > nPoint)
			{
				nIndex = i;
				nPoint = pItem->GetPoint();
			}
		}
		//找个最大的索引出去
		if(nIndex >=0)
		{
			return m_ItemList[nIndex];
		}
		
	}
	return NULL;
}
*/




void CRanking::SaveItem( CRankingItem* pItem,  CStringBuff &buff )
{
	CHECK_RANK_VALID()
	if(pItem ==NULL || pItem->IsValid() ==false) return;
	//DECLARE_FUN_TIME_PROF()
	char sBuf[2048];   //注意title列数过多
	sprintf_s(sBuf,sizeof(sBuf),"%u\t%d",pItem->nId,pItem->nPoint);
	//fputs(sBuf,fp);
	//buff.Append(sBuf);
	
	for (INT_PTR i = 0; i < pItem->GetColCount(); i++)
	{
		//fputc('\t',fp);
		//buff << ('\t');
		strcat(sBuf,"\t");

		LPCSTR sData = pItem->GetSubData(i);
		//buff.Append(sData?sData:"-");
		strcat(sBuf,sData);
		//fputs(sData?sData:"-",fp);
	}
	buff.Append(sBuf);
}

void CRanking::SetColDisplay( INT_PTR nIndex, bool disp )
{
	if (nIndex >= 0 && nIndex < m_Title.GetColCount())
	{
		m_ColDisplay[nIndex] = !disp;//1是不显示
	}
}

bool CRanking::isColDisplay( INT_PTR nIndex )
{
	if (nIndex >= 0 && nIndex < m_Title.GetColCount())
	{
		return !m_ColDisplay[nIndex];
	}
	return false;
}


void CRanking::SetRankPropConfig(int nRankPropIndex)
{
	DataList<RANKPROP>& rankProps = GetLogicServer()->GetDataProvider()->GetMiscConfig().GetRankProps();

	if (nRankPropIndex < 0 || nRankPropIndex >= rankProps.count)
	{
		OutputMsg(rmError, "Set Rank Prop Error! config index=%d, config count=%d", nRankPropIndex,rankProps.count);
		return;
	}

	RANKPROP *pProps = rankProps.pData + nRankPropIndex;
	if (pProps == NULL) return;

	m_nRankPropIndex = nRankPropIndex;			//从0算起
	m_nRankPropMax = (int)pProps->props.count;	//保存数量

}

void CRanking::UpdateRankProp(CRankingItem *pItem,INT_PTR nIndex, bool bClear)
{
	if (m_nRankPropIndex < 0) return;
	DECLARE_TIME_PROF("CRanking::UpdateRankProp");
	
	if(pItem ==NULL ) return;
	CActor *pActor = GetGlobalLogicEngine()->GetEntityMgr()->GetEntityPtrByActorID(pItem->nId);
	if (pActor == NULL) return;
	
	int nRankIndex = -1;
	//如果清空榜单操作则绝对删除
	if (!bClear)	
	{
		if (nIndex < m_nRankPropMax && pItem->nPoint >= m_nRankPropValue)
		{
			nRankIndex = (int)nIndex;
		}
	}

	pActor->GetMiscSystem().UpdateRankPropData(m_nRankPropIndex, nRankIndex, pItem->nPoint);
	

}

void CRanking::AtachRankProp(LPCSTR sName)
{
	m_nRankPropIndex = -1;
	m_nRankPropMax = 0;

	if (!sName) return;
	DataList<RANKPROP>& rankProps = GetLogicServer()->GetDataProvider()->GetMiscConfig().GetRankProps();
	for (INT_PTR i = 0; i < rankProps.count; i++)
	{
		RANKPROP *pProps = rankProps.pData + i;
		if (pProps == NULL || pProps->rankName[0] == '\0') continue;

		if (strcmp(sName, pProps->rankName) == 0)
		{
			if(pProps->pRanking)
			{
				OutputMsg(rmError,"%s, sName=%s,pProps->pRanking !=NULL",__FUNCTION__,sName);
			}
			pProps->pRanking = this;
			m_nRankPropIndex = (int)i;
			m_nRankPropMax = (int)pProps->props.count;
			m_nRankPropValue = pProps->nValue;
			return;
		}
	}
}

void CRanking::DetachhRankProp(LPCSTR sName)
{
	if (!sName) return;
	RANKPROP *pProps = GetLogicServer()->GetDataProvider()->GetMiscConfig().GetRankPropByRankName(sName);
	if (pProps)
	{
		if(pProps->pRanking ==NULL)
		{
			OutputMsg(rmError,"%s, sName=%s,pProps->pRanking ==NULL",__FUNCTION__,sName);
		}
		pProps->pRanking = NULL;
	}
}


void CRanking::PushToPack(CActor* pActor, int nNum, CDataPacket* pDataPack)
{
	if (pDataPack==NULL || pActor == NULL)
	{
		return;
	}

	CDataPacket& pack = *pDataPack;
	
	int nItemCount = GetList().count();
	if (nNum < nItemCount)
	{
		nItemCount = nNum;
	}

	// 排行榜数据
	pack << BYTE(nItemCount);
	for (size_t i = 0; i < nItemCount; i++)
	{
		CRankingItem * pItem = GetItem(i);
		if (pItem)
		{
			int nActorid= (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetPoint();
			pack.writeString(pItem->GetSubData(0));//ACTORNAME
			pack << (unsigned int)pItem->GetParam();
			pack << (unsigned int)pItem->GetParam1();//yy超玩
			pack.writeString(pItem->GetSubData(1));//sexjob
			pack.writeString(pItem->GetSubData(2));//
			pack.writeString(pItem->GetSubData(3));//vip
		}
	}

	// 我的数据
	CRankingItem * pItem = GetPtrFromId(pActor->GetId());
	if (pItem)
	{
		pack << (unsigned int)pItem->GetPoint();
		int index = pItem->GetIndex()+1;
		pack << (short)index;
	}
	else
	{
		pack << (unsigned int)0;
		pack << (short)0;
	}
}


bool CRanking::CheckActorIdInRank(unsigned int nActorId)
{
	int nItemCount = GetList().count();
	for (size_t i = 0; i < nItemCount; i++)
	{
		CRankingItem * pItem = GetItem(i);
		if (pItem)
		{
			if ((unsigned int)pItem->GetId() == nActorId)
				return true;
		}
	}

	return false;
}

unsigned int CRanking::GetActorIdBySexJob(LPCSTR nCondition)
{
	int nItemCount = GetList().count();
	for (size_t i = 0; i < nItemCount; i++)
	{
		CRankingItem * pItem = GetItem(i);
		if (pItem)
		{
			LPCSTR sData = pItem->GetSubData(1);

			if(strcmp(sData, nCondition) == 0)
				return pItem->GetId();
	
		}
	}

	return 0;
}



void CRanking::PushRankToPack(int nNum, CDataPacket* pDataPack)
{
	if (pDataPack==NULL)
	{
		return;
	}

	CDataPacket& pack = *pDataPack;
	
	int nItemCount = GetList().count();
	if (nNum < nItemCount)
	{
		nItemCount = nNum;
	}

	// 排行榜数据
	pack << BYTE(nItemCount);
	for (size_t i = 0; i < nItemCount; i++)
	{
		CRankingItem * pItem = GetItem(i);
		if (pItem)
		{
			int nActorid= (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetPoint();
			pack.writeString(pItem->GetSubData(0));//ACTORNAME
			pack << (unsigned int)pItem->GetParam();
			pack << (unsigned int)pItem->GetParam1();//yy超玩
			pack.writeString(pItem->GetSubData(1));//sexjob
			pack.writeString(pItem->GetSubData(2));//
			// pack.writeString(pItem->GetSubData(3));//vip
			// pack.writeString("");//
			if (CActor* pUser = GetGlobalLogicEngine()->GetEntityMgr()->GetEntityPtrByActorID(nActorid))
			{
				pack << (BYTE)1;
				GetGlobalLogicEngine()->GetOfflineUserMgr().viewOnlineUserData(pUser, pack);
			}
			// 再从离线玩家找
			else if(COfflineUser *pUser = GetGlobalLogicEngine()->GetOfflineUserMgr().GetUserByActorId(nActorid))
			{
				pack << (BYTE)1;
				GetGlobalLogicEngine()->GetOfflineUserMgr().viewOfflineUserData(pUser, pack);
			}
			else
			{
				pack << (BYTE)0;
			}
			
		}
	}
}



void CRanking::PushEspecialRankToPack(int nNum, CDataPacket* pDataPack)
{
	if (pDataPack==NULL)
	{
		return;
	}

	CDataPacket& pack = *pDataPack;
	
	int nItemCount = GetList().count();
	if (nNum < nItemCount)
	{
		nItemCount = nNum;
	}

	// 排行榜数据
	pack << BYTE(nItemCount);
	for (size_t i = 0; i < nItemCount; i++)
	{
		CRankingItem * pItem = GetItem(i);
		if (pItem)
		{
			int nActorid= (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetPoint();
			pack.writeString(pItem->GetSubData(0));//ACTORNAME
		}
	}
}

void CRanking::SendCrossServerToPack(int nNum, CDataPacket& pack)
{
	int nItemCount = GetList().count();
	if (nNum < nItemCount)
	{
		nItemCount = nNum;
	}

	// 排行榜数据
	pack << BYTE(nItemCount);
	for (size_t i = 0; i < nItemCount; i++)
	{
		CRankingItem * pItem = GetItem(i);
		if (pItem)
		{
			int nActorid= (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetId();
			pack << (unsigned int)pItem->GetPoint();
			pack.writeString(pItem->GetSubData(0));//ACTORNAME
			pack << (unsigned int)pItem->GetParam();
			pack << (unsigned int)pItem->GetParam1();//yy超玩
			pack.writeString(pItem->GetSubData(1));//sexjob
			pack.writeString(pItem->GetSubData(2));//
			pack.writeString(pItem->GetSubData(3));// //vip
		}
	}
}