#pragma once

#include "akNetworkLinker.h"
#include <WinSock2.h>
#include <queue>

class _packetData
{
public:
	_packetData()
	{
		m_nLen = 0;
		m_pData = NULL;
	};
	_packetData(const _packetData& rhs)
	{
		m_nLen = 0;
		m_pData = NULL;

		if(rhs.m_nLen > 0)
		{
			m_pData = new char[rhs.m_nLen+1];
			memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nLen));
			m_pData[rhs.m_nLen] = 0;
			m_nLen = rhs.m_nLen;
		}
	}
	~_packetData()
	{
		clear();
	};
	_packetData& operator=(const _packetData& rhs)
	{
		clear();
		if(rhs.m_nLen > 0)
		{
			m_pData = new char[rhs.m_nLen+1];
			memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nLen));
			m_pData[rhs.m_nLen] = 0;
			m_nLen = rhs.m_nLen;
		}
		return *this;
	};
	void clear()
	{
		if(m_nLen > 0)
		{
			delete [] m_pData;
			m_pData = NULL;
			m_nLen = 0;
		}
	}
	void setData(char* pData, long nLen)
	{
		clear();
		if(nLen <= 0 || pData == NULL)
		{
			return;
		}

		m_pData = new char[nLen+1];
		memcpy(m_pData, pData, sizeof(char)*nLen);
		m_pData[nLen] = 0;
		m_nLen = nLen;
	}
public:
	char* m_pData;
	long m_nLen;
};

class CPacketStorage
{
public:
	CPacketStorage(void);
	virtual ~CPacketStorage(void);

public:
	void clear(){while(!m_quePacketData.empty());m_quePacketData.pop();};

	void EnterSection(){EnterCriticalSection(&m_csSection);};
	void LeaveSection(){LeaveCriticalSection(&m_csSection);};

	void push(_packetData& data){m_quePacketData.push(data);};

	_packetData* front(){return &m_quePacketData.front();};
	void pop(){m_quePacketData.pop();};

	size_t size(){return m_quePacketData.size();};
	bool empty(){return m_quePacketData.empty();};
protected:
	CRITICAL_SECTION		m_csSection;
	std::queue<_packetData> m_quePacketData;
};

class _akPacketPoolData
{
public:
	_akPacketPoolData()
	{
		m_nMemorySize = m_nDataSize = 0;
		m_pData = NULL;
	};
	_akPacketPoolData(const _akPacketPoolData& rhs)
	{
		alloc(rhs.m_nMemorySize);
		if(rhs.m_nMemorySize > 0)
		{
			memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nMemorySize));
			m_nDataSize = rhs.m_nDataSize;
			m_nMemorySize = rhs.m_nMemorySize;
		}
	}
	~_akPacketPoolData()
	{
		clear();
	};
	_akPacketPoolData& operator=(const _akPacketPoolData& rhs)
	{
		alloc(rhs.m_nMemorySize);
		if(rhs.m_nMemorySize > 0)
		{
			memcpy(m_pData, rhs.m_pData, sizeof(char)*(rhs.m_nMemorySize));
			m_nDataSize = rhs.m_nDataSize;
			m_nMemorySize = rhs.m_nMemorySize;
		}
		return *this;
	};
	void clear()
	{
		if(m_nMemorySize > 0)
		{
			delete [] m_pData;
			m_pData = NULL;
			m_nMemorySize = m_nDataSize = 0;
		}
	}
	void alloc(long nSize)
	{
		if(nSize > m_nMemorySize)
		{
			delete [] m_pData, m_pData = NULL;
			m_nMemorySize = (nSize/1024+2)*1024;
			m_pData = new char[m_nMemorySize];
		}
	}
	void setData(char* pData, long nSize)
	{
		alloc(nSize);

		memcpy(m_pData, pData, sizeof(char)*nSize);
		m_pData[nSize] = 0;
		m_nDataSize = nSize;
	}
public:
	char* m_pData;
	long m_nDataSize;
	long m_nMemorySize;
};

class AKNETWORK_DLLSPEC CakPacketPool
{
public:
	CakPacketPool(void);
	virtual ~CakPacketPool(void);

public:
	void clear();

	void setPacketPoolAlloc(int nNum)
	{
		setPacketPoolClear();
		
		m_pPacketPoolBuf = new _akPacketPoolData[nNum];
		m_nPacketPoolBufNum = nNum;
		m_nPacketPoolIndex = 0;
	}
	void setPacketPoolClear()
	{
		if(m_nPacketPoolBufNum)
		{
			delete [] m_pPacketPoolBuf;
			m_nPacketPoolBufNum = 0;
			m_nPacketPoolIndex = 0;
		}
	}
	int getPacketPoolSize(){return m_nPacketPoolBufNum;};

	_akPacketPoolData* getPacketPool(){return &m_pPacketPoolBuf[m_nPacketPoolIndex];};
	int				 getPacketPoolNum(){return m_quePacketPoolOrder.size();};

	void EnterSection(){EnterCriticalSection(&m_csSection);};
	void LeaveSection(){LeaveCriticalSection(&m_csSection);};

	void push(_akPacketPoolData* pData)
	{
		m_quePacketPoolOrder.push(pData);
		m_nPacketPoolIndex = (m_nPacketPoolIndex+1)%m_nPacketPoolBufNum;
	};

	_akPacketPoolData* front(){return m_quePacketPoolOrder.front();};
	void pop(){m_quePacketPoolOrder.pop();};

	size_t size(){return m_quePacketPoolOrder.size();};
	bool empty(){return m_quePacketPoolOrder.empty();};

	BOOL checkPoolSpare(int nWaitTime = -1)
	{
		if(m_quePacketPoolOrder.size() < m_nPacketPoolBufNum)
			return TRUE;

		DWORD nTimeSt = GetTickCount();
		while(nTimeSt-GetTickCount() < nWaitTime)
		{
			if(m_quePacketPoolOrder.size() < m_nPacketPoolBufNum)
				return TRUE;

			Sleep(1);
		}
		return FALSE;
	};
protected:
	CRITICAL_SECTION		 m_csSection;
	std::queue<_akPacketPoolData*> m_quePacketPoolOrder;
	
	_akPacketPoolData*			m_pPacketPoolBuf;
	int						m_nPacketPoolBufNum;
	int						m_nPacketPoolIndex;
};