#include "stdafx.h"
#include <WBANetwork/Common.h>
#include <WBANetwork/WBANetwork.h>
#include <WBANetwork/Net/SessionManager.h>
#include <WBANetwork/util/Guard.h>

namespace WBANetwork
{

	SessionManager::SessionManager()
		:	m_pServerNetwork( NULL )
	{
	}

	SessionManager::~SessionManager()
	{
	}

	bool SessionManager::Create( int sessionCnt )
	{
		Guard	< Mutex >	guard( m_MutexPool );
		ServerSession*		session = NULL;

		for(int i = 0 ; i < sessionCnt ; i++ )
		{
			session						= CreateSession();
			session->m_pServerNetwork	= m_pServerNetwork;

			m_Pool.push_back( session );
		}

		return true;
	}

	void SessionManager::Destroy()
	{
		ServerSession* session = NULL;

		{
			Guard < Mutex > guard( m_MutexPool );

			while( !m_Pool.empty() )
			{
				session = m_Pool.front();
				m_Pool.pop_front();
				session->m_pServerNetwork = NULL;
				DeleteSession( session );
			}
		}

		{
			Guard < Mutex > guard( m_MutexActive );

			for(MapActive::iterator iter = m_mapActive.begin() ; iter != m_mapActive.end() ; iter++ )
			{
				session						= iter->second;
				session->m_pServerNetwork	= 0;

				DeleteSession( session );
			}

			m_mapActive.clear();
		}

		m_pServerNetwork = NULL;
	}

	ServerSession* SessionManager::Find( DWORD uid )
	{
		Guard < Mutex > guard( m_MutexActive );

		MapActive::iterator iter = m_mapActive.find( uid );
		if( iter != m_mapActive.end() )
			return iter->second;

		return 0;
	}

	ServerSession* SessionManager::BindSession( SOCKET s, Socket::SocketAddr* addr )
	{
		if( NULL == s ||
			NULL == addr )
		{
			//_ASSERTE(!"SessionManager::BindSession");
			return 0;
		}

		ServerSession* session = NULL;

		{
			Guard < Mutex > guard( m_MutexPool );

			if( m_Pool.size() == 0 )
				return 0;

			ListPool::iterator iter = m_Pool.begin();
			session = *iter;
			m_Pool.erase( iter );
		}

		session->Create( s, *addr );

		{
			Guard < Mutex > guard( m_MutexActive );

			DWORD uid			= session->GetUID();
			m_mapActive[uid]	= session;
		}

		return session;
	}

	bool SessionManager::ActiveSession( ServerSession* session )
	{
		if( NULL == session )
		{
			//_ASSERTE(!"SessionManager::ActiveSession");
			return 0;
		}

		{
			Guard < Mutex >	guard( m_MutexPool );
			bool isFind = false;

			for(ListPool::iterator iter = m_Pool.begin() ; iter != m_Pool.end() ; iter++ )
			{
				if( *iter == session )
				{
					m_Pool.erase( iter );
					isFind = true;
					break;
				}
			}

			if( false == isFind )
			{
				return false;
			}
		}

		{
			Guard	< Mutex >	guard( m_MutexActive );

			DWORD uid			= session->GetUID();
			m_mapActive[uid]	= session;
		}

		return true;
	}

	void SessionManager::InactiveSession( ServerSession* session )
	{
		if( NULL == session )
		{
			//_ASSERTE(!"SessionManager::InactiveSession");
			return;
		}

		{
			Guard < Mutex > guard( m_MutexActive );

			MapActive::iterator iter = m_mapActive.find( session->GetUID() );
			if( iter != m_mapActive.end() )
			{
				//  ActiveÀÇ sessionÀ» »èÁ¦ÇÏ°í Pool¿¡ ³Ö´Â´Ù.
				m_mapActive.erase( iter );

				{
					Guard < Mutex >	guard( m_MutexPool );

					m_Pool.push_back( session );
				}
			}
		}
	}

	void SessionManager::Update()
	{
		Guard < Mutex > guard( m_MutexActive );

		if( m_mapActive.size() == 0 )
		{
			return;
		}

		ServerSession* session = NULL;

		for(MapActive::iterator iter = m_mapActive.begin() ; iter != m_mapActive.end() ; iter++ )
		{
			session = iter->second;
			session->Update();
		}
	}

	void SessionManager::UpdateInactive()
	{
		Guard < Mutex > guard( m_MutexPool );

		if( m_Pool.size() == 0 )
		{
			return;
		}

		ServerSession* session = NULL;

		for(ListPool::iterator iter = m_Pool.begin() ; iter != m_Pool.end() ; iter++ )
		{
			session = *iter;
			session->Update();
		}
	}

	ServerSession* SessionManager::CreateSession()
	{
		return ( _new_dbg_ ServerSession( 8192, 8192 ) );
	}

	void SessionManager::DeleteSession( ServerSession* session )
	{
		if( NULL != session )
		{
			delete session, session = NULL;
		}
	}
}