// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.



#include "stdpch.h"

#include <nel/misc/stop_watch.h>
#include <nel/misc/sheet_id.h>
#include <nel/misc/path.h>
#include <nel/misc/o_xml.h>
#include <nel/misc/thread.h>

#include <nel/net/unified_network.h>
#include <nel/net/login_server.h>

#include "game_share/action_factory.h"
#include "game_share/action_position.h"
#include "game_share/action_sync.h"
#include "game_share/action_disconnection.h"
#include "game_share/action_association.h"
#include "game_share/action_association.h"
#include "game_share/action_login.h"
#include "game_share/action_generic.h"
#include "game_share/action_generic_multi_part.h"
#include "game_share/action_sint64.h"
#include "game_share/action_dummy.h"
#include "game_share/action_target_slot.h"
#include "game_share/simlag.h"
#include "game_share/tick_event_handler.h"
#include "game_share/ryzom_version.h"
#include "game_share/entity_types.h"
#include "game_share/system_message.h"
#include "game_share/generic_xml_msg_mngr.h"

//#include "gpm_service/gpm_service.h"

#include "frontend_service.h"
#include "module_manager.h"
#include "client_host.h"
#include "fe_stat.h"

#include "id_impulsions.h"
#include "uid_impulsions.h"

#ifdef NL_OS_WINDOWS
#	define NOMINMAX
#	include <windows.h>
#endif // NL_OS_WINDOWS

using namespace std;
using namespace NLNET;
using namespace NLMISC;
using namespace CLFECOMMON;

// force admin module to link in
extern void admin_modules_forceLink();
void foo()
{
	admin_modules_forceLink();
}

//#define FE_MULTITHREADED

// callback for module security system
void cbEntityIdChanged(CClientHost *clienthost);

CGenericXmlMsgHeaderManager	GenericXmlMsgHeaderMngr;
NLNET::TServiceId SelfServiceId;

bool UseTickService = false;
uint32 Ticked = 0;

// Synchronization of flushing (sending) thread
volatile bool FlushInProgress = false;

// Allow beeping
bool AllowBeep = false;

// Client limit, to reduce memory usage
uint MaxNbClients = 1000;

// Size of UDP/IP/Ethernet headers: 8+20+14 = 42
const uint32 UDP_IP_ETH_HEADER_SIZE = 42;

CVariable<bool>		DontNeedBackend("FS", "DontNeedBackend", "Debug feature to allow client connection without backend (1=always allow connection , 0=backend must be up)", false, 0, true);

CVariable<bool>		UseSendThread("FS", "UseSendThread", "Use thread for sending", false, 0, true);

CVariable<bool>		UseWebPatchServer("FS", "UseWebPatchServer", "Use Web Server for patching", true, 0, true);
CVariable<bool>		AcceptClientsAtStartup("FS", "AcceptClientsAtStartup", "Set Frontend Accept mode (1=accept clients, 0=patching mode)", false, 0, true);
CVariable<string>	PatchingURLFooter("FS", "PatchingURLFooter", "Patching server listenning port + directory (default is ':43435/patch')", ":43435/patch", 0, true);
CVariable<string>	StartWebServerSysCommand("FS", "StartWebServerSysCommand", "System command to execute when to start Web Patch Server", "", 0, true);
CVariable<string>	StopWebServerSysCommand("FS", "StopWebServerSysCommand", "System command to execute when to stop Web Patch Server", "", 0, true);
CVariable<bool>		PublishFSHostAsIP("FS", "PublishFSHostAsIP", "Publish FSHost to the WS as IP:port instead of hostname:post", false, 0, true);
CVariable<uint32>	DelayBeforeUPDAlert("FS", "DelayBeforeUPDAlert", "Delay (in s) before raising an alert when the service has not received UPD packet", 10*60, 0, true);	// 10m, default

CVariable<bool>		VerboseFEStatsTime("fs", "VerboseFEStatsTime", "Verbose FESTATS and FETIME", false, 0, true);

std::string	getPatchingAddress()
{
	std::string	la;

	if (IService::getInstance()->haveArg('D'))
	{
		// use the command line param if set
		la = IService::getInstance()->getArg('D');
	}
	else if (IService::getInstance()->ConfigFile.exists ("ListenAddress"))
	{
		// use the config file param if set
		la = IService::getInstance()->ConfigFile.getVar ("ListenAddress").asString();
	}

	NLNET::CInetAddress	addr(la);

	return string("http://") + addr.ipAddress() + PatchingURLFooter.get();
}

/*
 * Conditional beep
 */
void beepIfAllowed( uint freq, uint duration )
{
	if ( AllowBeep )
		beep( freq, duration );
}


/***
 *** Global functions for easy multithreadization
 ***/


/*
 * Update task
 */

// Update entity container + Process vision + sort by distance + calculate priorities
void updatePriorities()
{
	H_AUTO(UpdatePriorities);
	//CFrontEndService::instance()->entityContainer().update(); // now called by the mirror notification callback

	CFrontEndService::instance()->PrioSub.update();
}


// Update clients states
void updateClientsStates()
{
	H_AUTO(RemoveDeadClients);
#ifndef SIMUL_CLIENTS
	CFrontEndService	*service = CFrontEndService::instance();
	service->updateClientsStates();
#endif
}


/*
 * Send task (see CFeSendSub::update())
 */

// Prepare headers
void prepareHeadersAndFillImpulses()
{
	H_AUTO(PrepareHeaders);

	CFrontEndService::instance()->SendWatch.start();

	CFrontEndService::instance()->sendSub()->prepareSendCycle();
	if ( ! CFrontEndService::instance()->receiveSub()->clientMap().empty() )
	{
		CFrontEndService::instance()->sendSub()->prepareHeadersAndFillImpulses();
	}
}


// Fill prioritized actions
void fillPrioritizedActionsToSend()
{
	H_AUTO(FillPrioritizedActions);
	if ( ! CFrontEndService::instance()->receiveSub()->clientMap().empty() )
	{
		CFrontEndService::instance()->sendSub()->fillPrioritizedActions();
	}
}


// Swap send buffers
void swapSendBuffers()
{
	H_AUTO(WaitAndSwapSendBuffers)
    // Wait for the end of flushMessagesToSend()
    while ( FlushInProgress )
	{
		nlSleep( 0 );
	}

	// Swap the buffers
	CFrontEndService::instance()->sendSub()->swapSendBuffers();
    FlushInProgress = true;

	CFrontEndService::instance()->SendWatch.stop();
}


// Flush messages
void flushMessagesToSend()
{
	CFrontEndService::instance()->sendSub()->flushMessages();
	FlushInProgress = false;
}

/*
 * Send thread & runnable
 */
class CSendRunnable : public IRunnable
{
public:

	CSendRunnable() : StopThread(false), SendBuffer(false)	{}

	volatile bool	StopThread;
	volatile bool	SendBuffer;

	virtual void	run()
	{
		while (!StopThread)
		{
			while (!StopThread && !SendBuffer)
				nlSleep(0);

			if (StopThread)
				break;

			SendBuffer = false;
			flushMessagesToSend();
		}

		StopThread = false;
	}

};

CSendRunnable	SendTask;
IThread*		SendThread = NULL;

/*
 * Receive task
 */

// Swap receive queues
void swapReadBuffers()
{
	H_AUTO(SwapReadBuffers);
	CFrontEndService::instance()->receiveSub()->swapReadQueues();
}


// Read incoming data from the current read queue
void readIncomingData()
{
	H_AUTO(ReadIncomingData);
	CFrontEndService::instance()->receiveSub()->readIncomingData();
}



/**************************
 *         INIT           *
 **************************/


/*
 * Send an impulsion message to a destination client (warning: channel is "level", in fact)
 */
void sendImpulsion( TClientId clientid, CMessage& msgin, uint8 channel, const char *extendedMsg, bool forceSingleShot )
{
	uint32 bytelen;
	msgin.serial( bytelen ); // sent with serialBufferWithSize(), the following is the buffer

	CActionGeneric *ag = (CActionGeneric *)CActionFactory::getInstance()->create( INVALID_SLOT, ACTION_GENERIC_CODE );
	ag->setFromMessage( msgin, bytelen );
	ag->AllowExceedingMaxSize = forceSingleShot;
	sint32 impulseBitSize = (sint32)CActionFactory::getInstance ()->size( ag );
	sint32 maxImpulseBitSize = CFrontEndService::instance()->getImpulseMaxBitSize( channel );
	if ( forceSingleShot || (impulseBitSize < maxImpulseBitSize) )
	{
		// Simple impulsion
#ifdef TRACE_SHARD_MESSAGES
		LOG_IMPULSION_INFO("FETRACE:%u: Preparing simple impulsion %p for C%hu, %s (len=%u, %d/%d bits)", CTickEventHandler::getGameCycle(), ag, clientid, extendedMsg, bytelen, impulseBitSize, maxImpulseBitSize);
#endif
		CFrontEndService::instance()->addImpulseToClient (clientid, ag, channel);
	}
	else
	{
		// MultiPart impulsion
		CActionFactory::getInstance()->remove((CActionImpulsion*&)ag);
		CActionGenericMultiPart *agmp = (CActionGenericMultiPart *)CActionFactory::getInstance ()->create (INVALID_SLOT, ACTION_GENERIC_MULTI_PART_CODE);
		sint32 minimumBitSizeForMP = CActionFactory::getInstance ()->size (agmp);

		sint32 availableSize = (maxImpulseBitSize - minimumBitSizeForMP) / 8; // (in bytes)
#ifdef NL_DEBUG
		nlassert( availableSize > 0 ); // the available size must be larger than the 'empty' size
#endif
		sint32 nbBlock = (bytelen + availableSize - 1) / availableSize;

		TClientIdCont	&cont = CFrontEndService::instance()->receiveSub()->clientIdCont();
		if (clientid >= cont.size() || cont[clientid] == NULL)
		{
			nlwarning ("Can't send impulse to client %u (doesn't exist)", clientid);
			CActionFactory::getInstance()->remove((CActionImpulsion*&)agmp);
			return;
		}
		uint8 num = cont[clientid]->ImpulseMultiPartNumber++;

#ifdef TRACE_SHARD_MESSAGES
		LOG_IMPULSION_INFO("FETRACE:%u: Preparing multipart impulsion %p for C%hu, %s (len=%u, num %d, nbpart %d, size per block %d)", CTickEventHandler::getGameCycle(), agmp, clientid, extendedMsg, bytelen, num, nbBlock, availableSize);
#endif
		for (sint32 i = 0; i < nbBlock; i++)
		{
			if (i != 0)
				agmp = (CActionGenericMultiPart *)CActionFactory::getInstance ()->create (INVALID_SLOT, ACTION_GENERIC_MULTI_PART_CODE);

			agmp->set(num, (uint16)i, msgin.buffer() + msgin.getPos(), bytelen, availableSize, (uint16)nbBlock);
//			nldebug ("num %d part %d avail %d nbblock %d", num, i, availableSize, nbBlock);
			CFrontEndService::instance()->addImpulseToClient (clientid, agmp, channel);
		}
	}
	//nldebug( "Contents of impulsion: '%s'", toHexaString(ImpulseBMS.bufferAsVector()).c_str() );
}


/*
 * Callback called when the input service gives a login mapping
 */
void cbMapIdToUid( CMessage& msgin, const string& serviceName, NLNET::TServiceId serviceId )
{
	// Serial in the CEntityId and the Uid
	TUid uid;
	CEntityId id;
	msgin.serial( uid );
	msgin.serial( id );
	
	// Search the Uid in client hosts
	CFrontEndService *fe = CFrontEndService::instance();
	CClientHost *clienthost = fe->receiveSub()->findClientHostByUid( uid );
	if ( clienthost != NULL )
	{
		nlinfo( "%u: Mapping CEntityId %s to uid %u for client %u", CTickEventHandler::getGameCycle(), id.toString().c_str(), uid, clienthost->clientId() );
		if( clienthost->eId() != CEntityId::Unknown )
		{
			nlwarning( "Client %u had already a CEntityId: %s !", uid, clienthost->eId().toString().c_str() );
			return;
		}
		clienthost->setEId( id );
		// update security for client module
		cbEntityIdChanged(clienthost);
		
		if ( fe->receiveSub()->EntityToClient.findEntityId( id ) )
		{
			nlwarning( "The CEntityId %s is already owned by another client!", id.toString().c_str() );
			return;
		}
		fe->receiveSub()->EntityToClient.addId( id, clienthost->clientId() );

		// The entity index will be set later, in CVisionProvider::processVision()
		// The forwarding to the client is done by an impulsion from the back-end

		// Send its discrete properties to the client. It is necessary because
		// before the FE knows the CEntityId of the client, the vision provider
		// cannot update its properties
		/*for ( uint32 p = FIRST_DISCREET_PROPINDEX; p < fe->PrioSub.PropTranslator.nbPropertiesByEntityId( id ); ++p )
		{
			clienthost->PropDispatcher.setPriority( 0, (TPropIndex)p, fe->PrioSub.VisionArray.prioLoc( clienthost->clientId(), 0, (TPropIndex)p ), (TPriority)HIGHEST_PRIORITY );
		}*/
	
	}
	else
	{
		nlwarning( "Uid not found for client login (%s %u)", id.toString().c_str(), uid );
	}
}


/*
 * Receive an impulsion to send to a client, using a uid (user account id).
 * This is used for messages sent to a client before he has choosen his id (entity id).
 */
void cbImpulsionUid (CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
	// Serialize in Uid
	TUid uid;
	msgin.serial(uid);

	CFeReceiveSub *frs = CFrontEndService::instance()->receiveSub();
	CClientHost *clienthost;

	// Find the client using the Uid (either in limbo or in online clients)
	clienthost = frs->findClientHostByUid( uid, true );
	if ( clienthost != NULL )
	{
		// Send message to the client
		sendImpulsion( clienthost->clientId(), msgin, 1, toString( "from %s to UId %u", serviceName.c_str(), uid ).c_str(), false );
	}
	else
	{
		// The client has left
		nldebug( "Invalid recipient client uid for impulsion (%u) from %s", uid, serviceName.c_str() );
	}
}


/*
 * Receive an impulsion to send to a client, using a id
 */
void cbImpulsionId (CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
	// Serialize in CEntityId
	CEntityId id;
	msgin.serial(id);

	// Find the client using the id
	TClientId clientid = CFrontEndService::instance()->receiveSub()->EntityToClient.getClientId( id );
	if ( clientid != INVALID_CLIENT )
	{
		// Send message
		sendImpulsion( clientid, msgin, 1, toString( "from %s to Id %s", serviceName.c_str(), id.toString().c_str() ).c_str(), false );
	}
	else
	{
		// The client has left
		nldebug( "Invalid recipient client id for impulsion (%s)", id.toString().c_str() );
	}
}


/*
 * Receive an impulsion, to send to a client, using a id and level (abusively called channel)
 */
void cbImpulsionIdChannel (CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
	// Serialize in CEntityId
	CEntityId id;
	uint8 channel;
	msgin.serial(id);
	msgin.serial(channel);

	// Find the client using the id
	TClientId clientid = CFrontEndService::instance()->receiveSub()->EntityToClient.getClientId( id );
	if ( clientid != INVALID_CLIENT )
	{
		if ( channel > 2 )
			nlwarning( "Invalid level %hu for impulsion from %s", (uint16)channel, serviceName.c_str() );
		// Send message
		sendImpulsion( clientid, msgin, channel, toString( "with level %hu from %s to Id %s", (uint16)channel, serviceName.c_str(), id.toString().c_str() ).c_str(), false );
	}
	else
	{
		nldebug( "Invalid recipient client id for impulsion (level %hu) (%s)", (uint16)channel, id.toString().c_str() );
	}
}


/*
 * Receive an impulsion, to send to a client, for a database update
 */
void cbImpulsionDatabase (CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
	// Serialize in CEntityId
	CEntityId id;
	msgin.serial(id);

	// Find the client using the id
	TClientId clientid = CFrontEndService::instance()->receiveSub()->EntityToClient.getClientId( id );
	if ( clientid != INVALID_CLIENT )
	{
		// Send database message into level 2.
		// The level 2 has 4 subchannels => subsequents sendings are not garanteed to be delivered
		// in the same order.
		//
		// Warning: the channel has a limited size. If the database if flooded by updates, further
		// database impulsions will be blocked.
		sendImpulsion( clientid, msgin, 2, toString( "for database from %s to Id %s", serviceName.c_str(), id.toString().c_str() ).c_str(), false ); // TEMP: multipart allowed (because first sending with no constraints)
	}
	else
	{
		nldebug( "Invalid recipient client id for database impulsion (%s)", id.toString().c_str() );
	}
}


/*
 *
 */
void cbImpulsionMultiDatabase (CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId)
{
	enum {
		SendDeltasToAll = 1,			// From class CCDBGroup; must match ;)
	};

	uint nbSent = 0;

	// Read message flag
	uint8	sendFlags = 0;				// Make warning C4700 silent
	msgin.serial (sendFlags);

	if ((sendFlags & SendDeltasToAll) == SendDeltasToAll)
	{
		// Broadcast to every connected client to this frontend
		// Store current position in input message
		sint32 msgPosBeforeData = msgin.getPos();

		// All connected clients
		THostMap::iterator ihm;
		for (ihm =CFrontEndService::instance()->receiveSub()->clientMap().begin();
			 ihm!=CFrontEndService::instance()->receiveSub()->clientMap().end(); ++ihm )
		{
			// See cbImpulsionDatabase
			CClientHost *destClient = GETCLIENTA(ihm);

			// Check if client is still online and has chosen a player to play with
			if (!destClient->isDisconnected () &&
				!destClient->eId ().isUnknownId())
			{
				// Set message position back
				msgin.seek( msgPosBeforeData, NLMISC::IStream::begin );


				sendImpulsion( destClient->clientId(), msgin, 2, "", false ); // multipart allowed
				// One more...
				++nbSent;
			}
		}
	}
	else
	{
		// Explicit list of clients is specified
		// Read recipient list
		vector<CEntityId> recipientIds;
		msgin.serialCont( recipientIds );

		// Store current position in input message
		sint32 msgPosAfterRecipients = msgin.getPos();

		for ( vector<CEntityId>::const_iterator itr=recipientIds.begin(); itr!=recipientIds.end(); ++itr )
		{
			// Find the client using the id
			const CEntityId& id = *itr;
			TClientId clientid = CFrontEndService::instance()->receiveSub()->EntityToClient.getClientId( id );
			if ( clientid != INVALID_CLIENT )
			{
				// Set message position back
				msgin.seek( msgPosAfterRecipients, NLMISC::IStream::begin );

				// See cbImpulsionDatabase
				sendImpulsion( clientid, msgin, 2, "", false ); // multipart allowed

				++nbSent;
			}
			// Skip recipients that are not connected on this front-end
		}
	}

	//if ( nbSent != 0 )
	//	nldebug( "Sent CDB_MULTI_IMPULSION to %u clients", nbSent );
}


/*
 * Set the names requested to the IOS
 */
void cbSetEntityNames( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
{
	uint32 len;
	msgin.serial( len );
	for ( uint32 i=0; i!=len; ++i )
	{
		TDataSetRow entityIndex;
		string name;
		msgin.serial( entityIndex );
		msgin.serial( name );
		CFrontEndService::instance()->EntityNames[ entityIndex.getIndex() ] = name;
	}
	nlinfo( "Got %u names from service %hu", len, serviceId.get() );
}


/*
 * Server request frontend to disconnect a client
 */
void cbServerDisconnectClient( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
{
	uint32	userId;
	msgin.serial(userId);

	cbDisconnectClient(userId, serviceName);
}

/*
 * Server request frontend to disconnect a client
 */
void cbDisconnectAllClients( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
{
	for (THostMap::iterator it = CFrontEndService::instance()->receiveSub()->clientMap().begin (); it != CFrontEndService::instance()->receiveSub()->clientMap().end (); it++)
	{
		// Ask the client to disconnect
		CActionDisconnection *act = (CActionDisconnection*)(CActionFactory::getInstance()->create(INVALID_SLOT, ACTION_DISCONNECTION_CODE));
		GETCLIENTA(it)->ImpulseEncoder.add(act, 0);

		// Prepare removal of client on the front-end
		CFrontEndService::instance()->receiveSub()->removeFromRemoveList( GETCLIENTA(it)->clientId() ); // prevent to insert it twice
		CFrontEndService::instance()->receiveSub()->addToRemoveList( GETCLIENTA(it)->clientId() );
	}
}

/*
 * Return the name of an entity (if previously retrieved or "" if no name)
 */
std::string				getEntityName( const TDataSetRow& entityIndex ) 
{
	TEntityNamesMap::const_iterator itn = CFrontEndService::instance()->EntityNames.find( entityIndex.getIndex() );
	if ( itn != CFrontEndService::instance()->EntityNames.end() )
	{
		return (*itn).second;
	}
	else
	{
		return string("");
	}
}


/*
 * Welcome Service request frontend to switch to Accept Clients mode
 */
void setAcceptClients()
{
	CFrontEndService::instance()->AcceptClients = true;
	NLMISC::ICommand::execute("stopWebPatchServer", *InfoLog);
}

/*
 * Welcome Service request frontend to switch to Accept Clients mode
 */
void cbAcceptClients( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
{
	nlinfo("cbAcceptClients: asked by service %s %d to accept clients (patching is no longer available on this server)", serviceName.c_str(), serviceId.get());
	setAcceptClients();
}



/*
 *
 */
TUnifiedCallbackItem cbFrontEndArray [] =
{
	{ "IMPULSION_ID", cbImpulsionId },
	{ "IMPULS_CH_ID", cbImpulsionIdChannel },
	{ "CDB_IMPULSION", cbImpulsionDatabase },
	{ "CDB_MULTI_IMPULSION", cbImpulsionMultiDatabase },
	{ "IMPULSION_UID", cbImpulsionUid },
	{ "CL_ID", cbMapIdToUid },
	{ "ENTITY_NAMES", cbSetEntityNames },
	{ "DISCONNECT_CLIENT", cbServerDisconnectClient },		// Called by server to disconnect a client
	{ "DISCONNECT_ALL_CLIENTS", cbDisconnectAllClients },	// Called by server to disconnect all clients at once

	{ "FS_ACCEPT", cbAcceptClients }
};



//
void cfcbPriorityMode( CConfigFile::CVar& var )
{
	uint8 pm = var.asInt();
	if ( pm == 0 )
	{
		nlwarning( "PriorityMode 0 (DistanceOnly) is not obsolete and not supported!" );
	}
	//CFrontEndService::instance()->PrioSub.Prioritizer.setPrioStrategy( (CPrioritizer::TPrioStrategy)1 );
	//nlinfo( "\tPriorityMode is now %hu", (uint16)pm );
	nlinfo( "Priority strategy is DistanceDelta" );
}


//
void cfcbTotalBandwidth( CConfigFile::CVar& var )
{
	uint32 tb = var.asInt();
	CFrontEndService::instance()->_SendSub.setTotalBandwidth( tb );
	// Not implemented anymore
	//nlinfo( "\tTotalBandwidth is now %u", tb );
	/*if ( CFrontEndService::instance()->_SendSub.clientBandwidth() != 0 )
	    nlinfo( "\tTotalbandwidth corresponds to %0.2f client buffers",
		    (float)CFrontEndService::instance()->_SendSub.totalBandwidth()/(float)CFrontEndService::instance()->_SendSub.clientBandwidth() );
	*/
}


//
void cfcbClientBandwidth( CConfigFile::CVar& var )
{
	uint32 cb = var.asInt();
	if ( cb != 0 )
	{
#ifdef INCLUDE_FE_STATS_IN_PACKETS
		cb += STAT_HEADER_SIZE - UDP_IP_ETH_HEADER_SIZE;
#else
		cb -= UDP_IP_ETH_HEADER_SIZE;
#endif
	    CFrontEndService::instance()->_SendSub.setClientBandwidth( cb );
	    nlinfo( "\tClientBandwidth is now %u bytes per game cycle, including UDP/IP/Ethernet headers (%u)", cb + UDP_IP_ETH_HEADER_SIZE, UDP_IP_ETH_HEADER_SIZE );
#ifdef INCLUDE_FE_STATS_IN_PACKETS
		nlinfo( "\t(also including stat header of %u bytes)", STAT_HEADER_SIZE );
#endif
	}
}


//
void cfcbClientTimeOut( CConfigFile::CVar& var )
{
	uint32 ct = var.asInt();
	CFrontEndService::instance()->_ClientTimeOut = ct;
	nlinfo( "\tClientTimeOut is now %u", ct );
}


//
void cfcbLimboTimeOut( CConfigFile::CVar& var )
{
	uint32 ct = var.asInt();
	CFrontEndService::instance()->_LimboTimeOut = ct;
	nlinfo( "\tLimboTimeOut is now %u", ct );
}


//
void cfcbDisplayInfo( CConfigFile::CVar& var )
{
	nlinfo ("\tDisplayInfo is now %s", var.asInt()!=0?"on":"off");
	if ( var.asInt() != 0 )
	{
		InfoLog->removeFilter ("FE:");
	}
	else
	{
		InfoLog->addNegativeFilter ("FE:");
	}
}


void cfcbClientMonitor( CConfigFile::CVar& var )
{
	TClientId clientid = var.asInt();
	CFrontEndService::instance()->monitorClient( clientid );
	if ( clientid != 0 )
	{
		if ( clientid <= MAX_NB_CLIENTS )
			nlinfo( "\tNow monitoring client %hu", clientid );
		else
			nlinfo( "Invalid client id for monitoring" );
	}
	else
	{
		nlinfo( "\tClient monitoring is now off" );
	}
}


void cfcbAllowBeep( CConfigFile::CVar& var )
{
	AllowBeep = (var.asInt() == 1);
	nlinfo( "\tAllowBeep is now %hu", (uint16)AllowBeep );
}


void cfcbGameCycleRatio( CConfigFile::CVar& var )
{
	sint gcratio = var.asInt();
	CFrontEndService::instance()->setGameCycleRatio( gcratio );
	nlinfo( "\tGameCycleRatio is now %d", gcratio );
}


void cfcbCalcDistanceExecutionPeriod( CConfigFile::CVar& var )
{
	sint period = var.asInt();
	CFrontEndService::instance()->PrioSub.VisionProvider.DistanceSpreader.ExecutionPeriod = period;
	nlinfo( "\tCalcDistanceExecutionPeriod is now %d", period );
}


void cfcbSortPrioExecutionPeriod( CConfigFile::CVar& var )
{
	sint period = var.asInt();
	CFrontEndService::instance()->PrioSub.Prioritizer.SortSpreader.ExecutionPeriod = period;
	nlinfo( "\tSortPrioExecutionPeriod is now %d", period );
}


void cfcbDistanceDeltaRatioForPos( CConfigFile::CVar& var )
{
	uint32 ddratio = var.asInt();
	CFrontEndService::instance()->PrioSub.Prioritizer.setDistanceDeltaRatioForPos( ddratio );
	nlinfo( "\tDistanceDeltaRatioForPos is now %u", ddratio );
}

//

/*void cfcbPositionPrioExecutionPeriod( CConfigFile::CVar& var )
{
	sint period = var.asInt();
	CFrontEndService::instance()->PrioSub.Prioritizer.PositionSpreader.ExecutionPeriod = period;
	nlinfo( "\tPositionPrioExecutionPeriod is now %d", period );
}


void cfcbOrientationPrioExecutionPeriod( CConfigFile::CVar& var )
{
	sint period = var.asInt();
	CFrontEndService::instance()->PrioSub.Prioritizer.OrientationSpreader.ExecutionPeriod = period;
	nlinfo( "\tOrientationPrioExecutionPeriod is now %d", period );
}


void cfcbDiscreetPrioExecutionPeriod( CConfigFile::CVar& var )
{
	sint period = var.asInt();
	CFrontEndService::instance()->PrioSub.Prioritizer.DiscreetSpreader.ExecutionPeriod = period;
	nlinfo( "\tDiscreetPrioExecutionPeriod is now %d", period );
}*/


/*
 * Init variable from config file, at startup
 */
void initConfigVar( CConfigFile& cf, const char *varname, uint& var, const uint maxvalue )
{
	var = cf.getVar( varname ).asInt();
	if ( var > maxvalue )
	{
		nlwarning( "%s=%u exceeding maximum", varname, var );
		var = maxvalue;
	}
	nlinfo( "\t%s = %u", varname, var );
}


/*
 * Install callback and init variable from config file
 */
void installConfigVar( CConfigFile& cf, const char *varname, void (*callback) (CConfigFile::CVar&) )
{
	cf.setCallback( varname, callback );
	callback( cf.getVar( varname ) );
}


/*
 *  Login system callback
 */
void cbDisconnectClient (TUid userId, const std::string &reqServiceName)
{
	for (THostMap::iterator it = CFrontEndService::instance()->receiveSub()->clientMap().begin (); it != CFrontEndService::instance()->receiveSub()->clientMap().end (); it++)
	{
		if ( GETCLIENTA(it)->Uid == userId)
		{
			// Ask the client to disconnect
			CActionDisconnection *act = (CActionDisconnection*)(CActionFactory::getInstance()->create(INVALID_SLOT, ACTION_DISCONNECTION_CODE));
			GETCLIENTA(it)->ImpulseEncoder.add(act, 0);
			nlinfo( "%s asked to remove player %hu (uid %u)", 
				reqServiceName.c_str(), 
				GETCLIENTA(it)->clientId(), 
				userId );

			// Prepare removal of client on the front-end
			CFrontEndService::instance()->receiveSub()->removeFromRemoveList( GETCLIENTA(it)->clientId() ); // prevent to insert it twice
			CFrontEndService::instance()->receiveSub()->addToRemoveList( GETCLIENTA(it)->clientId() );
			
			return;
		}
	}
	nlwarning( "%s asked to remove an unknown player (uid %u)", reqServiceName.c_str(), userId );
}


/*
 * Get the last target entity position that was sent to a client at a specified tick in the past
 */
void cbGetTargetPosAtTick( CMessage& msgin, const string &serviceName, NLNET::TServiceId serviceId )
{
	// Read input
	TDataSetRow clientEntityIndex;
	TGameCycle tick;
	msgin.serial( clientEntityIndex );
	msgin.serial( tick );

	// Search
	bool found = false;
	TCoord x,y;
	TClientId clientId = CFrontEndService::instance()->receiveSub()->EntityToClient.getClientId( clientEntityIndex );
	if ( clientId != INVALID_CLIENT )
	{
		CFrontEndService::instance()->history()->getTargetPosAtTick( clientId, tick, x, y );
		found = (x != 0); // && (y != 0); // not needed
	}

	// Write output
	CMessage msgout( "TG_POS_AT" );
	msgout.serial( found );
	if ( found )
		msgout.serial( x, y );
	CUnifiedNetwork::getInstance()->send( serviceId, msgout ); // direct (reply)
}


static bool IosUp = false, EgsUp = false;

/*
 * Callback called at service connexion
 */
void cbServiceUp( const string& serviceName, NLNET::TServiceId serviceId, void * )
{
	if ( serviceName == "IOS" )
		IosUp = true;
	else if ( serviceName == "EGS" )
		EgsUp = true;
	else if ( serviceName == "WS" )
	{
		if (UseWebPatchServer)
		{
			// send patch server address
			CMessage			msgAddr("FEPA");

			// serial address as string
			std::string			patchAddress = getPatchingAddress();
			msgAddr.serial(patchAddress);

			// serial current frontend state
			bool				acceptClients = CFrontEndService::instance()->AcceptClients;
			msgAddr.serial(acceptClients);

			// send it to incoming WS
			CUnifiedNetwork::getInstance()->send(serviceId, msgAddr);

			nldebug("WS %d welcome service is up, sent server patch URI '%s'", serviceId.get(), patchAddress.c_str());
			if (CFrontEndService::instance()->AcceptClients)
			{
				nldebug("Note: frontend is yet in accept clients mode, patching is no longer available unless frontend is restarted", serviceId.get(), patchAddress.c_str());
			}
		}


		// send number of players on FS
		CMessage			msgPlr("NBPLAYERS2");
		uint32				nbClients = (uint32)CFrontEndService::instance()->receiveSub()->clientMap().size();
		uint32				nbPendingClients = CLoginServer::getNbPendingUsers();
		
		msgPlr.serial(nbClients);
		msgPlr.serial(nbPendingClients);

		// send it to incoming WS
		CUnifiedNetwork::getInstance()->send(serviceId, msgPlr);

		nldebug("WS %d welcome service is up, reported %d online users", serviceId.get(), nbClients);
	}

	if ( EgsUp )
	{
		CFrontEndService::instance()->ShardDown = false;
		nlinfo( "Leaving SERVER_DOWN mode" );
	}
}


/*
 * Callback called when service becomes down
 */
void cbServiceDown( const string& serviceName, NLNET::TServiceId serviceId, void * )
{
	if ( serviceName == "GPMS" )
	{
		// Reset the slots of the clients before the property_receiver deletes the entities
		CFrontEndService::instance()->PrioSub.VisionProvider.resetVision();
	}
	else if ( serviceName == "IOS" )
	{
		IosUp = false;
	}
	else if ( serviceName == "EGS" )
	{
		EgsUp = false;
	}

	if ( ! (EgsUp) ) // now the IOS shutdown is tolerated
	{
		if ( ! CFrontEndService::instance()->ShardDown ) // prevent from doing it several times
		{
			/*while( (ihm=CFrontEndService::instance()->receiveSub()->clientMap().begin()) != CFrontEndService::instance()->receiveSub()->clientMap().end() )
			{
				// Cannot use cbDisconnect() because we need the client to be removed at once, otherwise
				// the property receiver could raise an assert in assignIndexToId(clientsid)
				//CFrontEndService::instance()->receiveSub()->removeFromRemoveList( GETCLIENTA(ihm)->clientId() ); 
				//CFrontEndService::instance()->receiveSub()->removeClientById( GETCLIENTA(ihm)->clientId() );
			}*/
			
			CFrontEndService::instance()->ShardDown = true;
			nlinfo( "Entering SERVER_DOWN mode" );

			// remove all limbo clients
			uint	clientsInLimbo = (uint)CFrontEndService::instance()->receiveSub()->LimboClients.size();
			CFrontEndService::instance()->receiveSub()->LimboClients.clear();
			nlinfo("Removed %d clients in limbo mode", clientsInLimbo);
		}
	}

	beepIfAllowed( 440, 150 );
	beepIfAllowed( 400, 150 );
}


/*
 * Impulse ack callbacks
 */
void	cbAckUnknown(CClientHost *client, CAction *action)
{
	nldebug("FERECV: client %d acked action %d", client->clientId(), action->Code);
}


void	cbAckDummy(CClientHost *client, CAction *action)
{
	CActionDummy	*dummy = (CActionDummy*)(action);
	nldebug("FERECV: Client %d acked dummy %d", client->clientId(), dummy->Dummy1);
}


/*
 * Init module manager
 */

const sint FE_MAIN = 0;
const sint FE_FLUSH = 1;

void	CFrontEndService::initModuleManagers()
{
/*
	CModuleManager::init(16);

	// Warning: with several modules, the front-end service shows 100% of CPU in the
	// Windows Task Manager. This is normal, and the service is still nice to other programs.
	// For more information, see comment in CModuleManager::waitAllReady().

	CModuleManager	*mainMgr = new CModuleManager("FE_MAIN", false);
	CModuleManager  *flushMgr = new CModuleManager("FE_FLUSH", true);
	_ModuleManagers.push_back(mainMgr);
	_ModuleManagers.push_back(flushMgr);

#ifdef MEASURE_SENDING
	nlinfo( "MEASURE_SENDING enabled" );
	mainMgr->addModule(0, swapReadBuffers);
	mainMgr->addModule(1, readIncomingData);
	mainMgr->addModule(2, swapSendBuffers);
	flushMgr->addWait(2);
	flushMgr->addModule(3, flushMessagesToSend);
#else
	mainMgr->addModule(0, swapReadBuffers);
	mainMgr->addModule(1, readIncomingData);
	mainMgr->addModule(2, ::updateClientsStates);
	mainMgr->addModule(3, updatePriorities);
	mainMgr->addModule(4, prepareHeadersAndFillImpulses);
	mainMgr->addModule(5, fillPrioritizedActionsToSend);
	mainMgr->addModule(6, swapSendBuffers); // waits for the end of flushMessagesToSend using the boolean FlushInProgress (with addWait there would be a deadlock at the beginning)
	flushMgr->addWait(6);
	flushMgr->addModule(7, flushMessagesToSend);
#endif // MEASURE_SENDING
*/
}


/*
 *
 */
inline void cbUpdate()
{
	CFrontEndService::instance()->onTick();
}


/*
 *
 */
inline void	CFrontEndService::onTick()
{
	LastTickTime = CTime::getLocalTime();

	if (StalledMode)
	{
		setClientsToSynchronizeState();
	}

	if ( _GCCount == 0 )
	{
		// Run manager's task
		UserLWatch.start();
		//H_BEFORE(UserUpdate);
		if ( CFrontEndService::instance()->entityContainer().mirrorIsReady() )
		{
			//_ModuleManagers[0]->runOnce();

			swapReadBuffers();
			readIncomingData();
			::updateClientsStates();
			updatePriorities();
			prepareHeadersAndFillImpulses();
			fillPrioritizedActionsToSend();
			swapSendBuffers(); // waits for the end of flushMessagesToSend using the boolean FlushInProgress (with addWait there would be a deadlock at the beginning)

			SendTask.SendBuffer = true;

			if (SendThread == NULL)
			{
				H_AUTO(FlushMessagesToSend);
				flushMessagesToSend();
			}
		}
		//H_AFTER(UserUpdate);
		UserLWatch.stop();
		TMsDuration userduration = UserLWatch.getDuration();
		UserDurationPAverage = UserLWatch.getPartialAverage();
		//nlinfo( "Sent actions: %u", CFrontEndService::instance()->SentActionsLastCycle );

		_GCCount = _GCRatio;
	}

	--_GCCount;
}


/*
 * Initialization
 */

//CDebugDisplayer	FEDebugDisplayer("frontend_service_straight.log", true, "FE_DD");

void CFrontEndService::init()
{
	setVersion (RYZOM_VERSION);

	nlinfo( "Initializing front-end service..." );

	try
	{
		// Load config
		nlinfo( "Loading configuration from %s", ConfigFile.getFilename().c_str() );
		initConfigVar( ConfigFile, "ClientLimit", MaxNbClients, MAX_NB_CLIENTS );
		installConfigVar( ConfigFile, "ClientTimeOut", cfcbClientTimeOut );
		installConfigVar( ConfigFile, "LimboTimeOut", cfcbLimboTimeOut );
		installConfigVar( ConfigFile, "DisplayInfo", cfcbDisplayInfo );
		installConfigVar( ConfigFile, "ClientMonitor", cfcbClientMonitor );
		installConfigVar( ConfigFile, "AllowBeep", cfcbAllowBeep );
		installConfigVar( ConfigFile, "GameCycleRatio", cfcbGameCycleRatio );
		installConfigVar( ConfigFile, "CalcDistanceExecutionPeriod", cfcbCalcDistanceExecutionPeriod );
		installConfigVar( ConfigFile, "SortPrioExecutionPeriod", cfcbSortPrioExecutionPeriod );
		installConfigVar( ConfigFile, "DistanceDeltaRatioForPos", cfcbDistanceDeltaRatioForPos );
		/*installConfigVar( ConfigFile, "PositionPrioExecutionPeriod", cfcbPositionPrioExecutionPeriod );
		installConfigVar( ConfigFile, "OrientationPrioExecutionPeriod", cfcbOrientationPrioExecutionPeriod );
		installConfigVar( ConfigFile, "DiscreetPrioExecutionPeriod", cfcbDiscreetPrioExecutionPeriod );*/

#ifdef NL_OS_WINDOWS
		CConfigFile::CVar *lowerCPUPriority = ConfigFile.getVarPtr( "LowerCPUPriority" );
		if ( lowerCPUPriority && (lowerCPUPriority->asInt() == 1) )
		{
			SetPriorityClass( GetCurrentProcess(), /*BELOW_NORMAL_PRIORITY_CLASS*/ 0x00004000 ); // not the constant because I don't have the latest version of the Platform SDK!
			nlinfo( "Starting with LowerCPUPriority" );
		}
#endif

		CSheetId::init( false );

		// The filename is used with george's sheets to know which properties correspond to the entity types
		//	nlinfo( "Loading georges forms..." );
		//CFrontEndPropertyReceiver::init( string("single"), &PrioSub.PropTranslator, &_ReceiveSub.EntityToClient );
		nlinfo( "Initializing entity container and mirror..." );
		_EntityContainer.init( &_ReceiveSub.EntityToClient, cbUpdate );

		// Init the login system
		nlinfo( "Initializing login subsystem..." );
		CLoginServer::init( "", cbDisconnectClient ); 

//		// Init front end listening port
		CInetAddress listenAddr(CLoginServer::getListenAddress());
		uint16 frontendPort = listenAddr.port();

		if (frontendPort == 0)
		{
			// set a default listen port
			frontendPort = 47851;
		}
//		if (IService::getInstance()->haveArg('p'))
//		{
//			// use the command line param if set
//			frontendPort = NLMISC::fromString(IService::getInstance()->getArg('p').c_str());
//		}
//		else
//		{
//			// use the config file param otherwise
//			frontendPort = ConfigFile.getVar( "FrontendPort" ).asInt();
//		}

		CConfigFile::CVar *plafp = ConfigFile.getVarPtr( "LastAcceptableFSUDPPort" );
		uint16 lastAcceptableFrontendPort = frontendPort + 10; // default: try up to 10 ports
		if ( plafp )
		{
			if ( plafp->asInt() >= frontendPort )
				lastAcceptableFrontendPort = plafp->asInt(); 
			else
				nlwarning( "Invalid LastAcceptableFSUDPPort: %u (port from ListenAddress: %hu); using %hu", plafp->asInt(), frontendPort, lastAcceptableFrontendPort );
		}

		// Initialize the receiving subsystem and find an available port
		_DgramLength = ConfigFile.getVar( "DatagramLength" ).asInt();
		nlinfo( "\tDatagramLength = %u bytes", _DgramLength );
		nlinfo( "Initializing receiving subsystem..." );
		_ReceiveSub.init( frontendPort, lastAcceptableFrontendPort, _DgramLength, &_History, &_SendSub.clientIdCont() );
		frontendPort = _ReceiveSub.dataSock()->localAddr().port();
		listenAddr.setPort( frontendPort );
		CLoginServer::setListenAddress( PublishFSHostAsIP.get() ? listenAddr.asIPString() : (listenAddr.hostName() + ":" + NLMISC::toString( listenAddr.port() )) ); // note: asString() returns more information
		CInetAddress::RetrieveNames = false;

		StalledMode = false;
		LastTickTime = 0;
		ShardDown = true; // waiting for connection of the EGS
		CUnifiedNetwork::getInstance()->setServiceUpCallback( "*", cbServiceUp, NULL );
		CUnifiedNetwork::getInstance()->setServiceDownCallback( string("*"), cbServiceDown, 0);
		SelfServiceId = getServiceId();

		std::string	patchAddress = getPatchingAddress();
		nlinfo("Patch Server base address is '%s'", patchAddress.c_str());

		// set accept mode
		AcceptClients = AcceptClientsAtStartup.get();
		if (!AcceptClients)
		{
			nlinfo("FS doesn't accept client at startup, must be told to do so (default patching mode)");
			NLMISC::ICommand::execute("startWebPatchServer", *InfoLog);
		}
		else
		{
			nlinfo("FS accepts client at startup (patching mode unavailable)");
			NLMISC::ICommand::execute("stopWebPatchServer", *InfoLog);
		}

		// Register actions
		CActionFactory::getInstance()->registerAction( ACTION_POSITION_CODE, CActionPosition::create );
		CActionFactory::getInstance()->registerAction( ACTION_SYNC_CODE, CActionSync::create );
		CActionFactory::getInstance()->registerAction( ACTION_DISCONNECTION_CODE, CActionDisconnection::create );
		CActionFactory::getInstance()->registerAction( ACTION_ASSOCIATION_CODE, CActionAssociation::create );
		CActionFactory::getInstance()->registerAction( ACTION_LOGIN_CODE, CActionLogin::create );
		CActionFactory::getInstance()->registerAction( ACTION_GENERIC_CODE, CActionGeneric::create );
		CActionFactory::getInstance()->registerAction( ACTION_GENERIC_MULTI_PART_CODE, CActionGenericMultiPart::create );
		CActionFactory::getInstance()->registerAction( ACTION_SINT64, CActionSint64::create );
		CActionFactory::getInstance()->registerAction( ACTION_TARGET_SLOT_CODE, CActionTargetSlot::create );
//#ifdef DISABLE_PRIOTABLE
		CActionFactory::getInstance()->registerAction( ACTION_DUMMY_CODE, CActionDummy::create );
//#endif

		// Init send subsystem
		nlinfo( "Initializing sending subsystem..." );
#ifdef HALF_FREQUENCY_SENDING_TO_CLIENT
		nlinfo( " Half-frequency mode" );
#else
		nlinfo( " Full-frequency mode" );
#endif
		_SendSub.init( _ReceiveSub.dataSock(), &_ReceiveSub.clientMap(), &_History, &PrioSub );
		installConfigVar( ConfigFile, "ClientBandwidth", cfcbClientBandwidth );
		installConfigVar( ConfigFile, "TotalBandwidth", cfcbTotalBandwidth );

		// Init history
		nlinfo( "Initializing history..." );
		_History.init( MaxNbClients+1 ); // clientids begin at 1

		// Init priority table
		nlinfo( "Initializing priority tables..." );
		PrioSub.init( /*&_SendSub.clientIdCont()*/ &_History, &_ReceiveSub.EntityToClient );
		installConfigVar( ConfigFile, "PriorityMode", cfcbPriorityMode );

		// Register property nbbits
		CActionSint64::registerNumericPropertiesRyzom();
		CActionFactory::getInstance()->initVolatileProperties();

		setUpdateTimeout(100);

		// Init the XML message manager
		nlinfo( "Initializing XML message manager..." );
		const string& pathXmlMsg = CPath::lookup( "msg.xml" );
		GenericXmlMsgHeaderMngr.init( pathXmlMsg );
		initImpulsionId();
		initImpulsionUid();

		// Init module manager
		nlinfo( "Initializing module manager..." );
		initModuleManagers();

		if (UseSendThread)
		{
			// Init send thread
			nlinfo("UseSendThread on, initialise send thread");
			SendThread = IThread::create(&SendTask);
			SendThread->start();
		}

		// add a callback in the LoginServer to be warned when a cookie become acceptable
		CLoginServer::addNewCookieCallback(newCookieCallback);

		nlinfo( "Waiting for the local Mirror Service..." );

		CActionGeneric::ServerSide = true;
	}
	catch (const Exception &e)
	{
		nlerror( "Error: %s", e.what() );
	}
}



/*
 * After mirror system is ready
 */
void	CFrontEndService::postInit()
{
	nlinfo( "Subscribing to mirror properties..." );
	_EntityContainer.initMirror();

	// Init modules
	nlinfo( "Starting modules..." );
	//CModuleManager::startAll();

	// Init impulse encoder callbacks
	CImpulseEncoder::setReceivedCallback(cbAckUnknown, -1);
	CImpulseEncoder::setReceivedCallback(cbAckDummy, ACTION_DUMMY_CODE);

	// and the remaining ones...
	setSimlagValues (ConfigFile.getVar("Lag").asInt(), ConfigFile.getVar("PacketLoss").asInt(), ConfigFile.getVar("PacketDuplication").asInt(), ConfigFile.getVar("PacketDisordering").asInt());
}


/**************************
 *       RELEASE          *
 **************************/



/*
 *
 */
void CFrontEndService::release()
{
	SendTask.StopThread = true;

	_ReceiveSub.release();

	//CModuleManager::stopAll();

	//
	//uint	i;
	//for (i=0; i<_ModuleManagers.size(); ++i)
	//	delete _ModuleManagers[i];

	//_ModuleManagers.clear();
	//CModuleManager::release();

	CActionFactory::release();

	InfoLog->removeFilter( "FEHTIMER" );
	InfoLog->removeFilter( "FE" );

	if (SendThread != NULL)
	{
		nlinfo("Release send thread, waiting for task to terminate");
		// stop send thread
		while (SendTask.StopThread)
			nlSleep(1);

		delete SendThread;
		SendThread = NULL;
	}
}



/**************************
 *        UPDATE          *
 **************************/


//#define LOOP_IN_MAIN_THREAD
//#define TEST_THREAD_CPU_USAGE

// This variable helps testing the bug that produced the warning
// "handleReceivedMsg : FERECV: client %d sent messages dated in future"
// after a Stall Mode recovery.
//CVariable<bool> SimulateStalled("fs", "SimulateStalled", "", false );


/*
 * Update
 */
bool CFrontEndService::update()
{
#ifdef LOOP_IN_MAIN_THREAD
	while ( true );
#endif
#ifdef TEST_THREAD_CPU_USAGE
	double sum=0.0;
	uint32 n = 0;
	while ( true )
	{
		++n;
		TTicks ticks = CTime::getPerformanceTime();
		uint32 k;
		for ( uint32 i=0; i!=0x10000000; ++i )
		{
			k=i*2;
		}
		double t = CTime::ticksToSecond( CTime::getPerformanceTime()-ticks );
		sum += t;
		nlinfo( "Time: %.3f ms, average: %.3f ms, k=%u", t*1000.0, 1000.0*sum/(double)n, k );
	}
#endif

/*
	map<TUid,CLimboClient>::iterator	it;
	TTime								timeout = CTime::getLocalTime()-_LimboTimeOut;
	for (it=_ReceiveSub.LimboClients.begin(); it!=_ReceiveSub.LimboClients.end(); )
	{
		map<TUid,CLimboClient>::iterator	itr = it++;
		// removes limbo client if it timed out
		if ((*it).second.Timeout < timeout)
			_ReceiveSub.LimboClients.erase(itr);
	}
*/

	// If the back-end is down, set all clients to "server down" state
	// (this breaks the tick synchronisation of the clients, anyway the clients disconnect after receiving "server down")
	if ( !DontNeedBackend && ShardDown )
	{
		static TTime lastSent = CTime::getLocalTime();
		TTime now = CTime::getLocalTime();
		if ( now - lastSent > 2000 )
		{
			sendServerProblemStateToClients( CClientHost::ServerDown );
			lastSent = now;
		}
	}

	// If not received a tick for 2 seconds, set all clients to stalled state
	// (this breaks the tick synchronisation of the clients, they will need a SYNC afterwards)
	if ((CTime::getLocalTime() - LastTickTime > 2000) /*|| (SimulateStalled.get() == 1)*/)
	{
		if (!StalledMode)
		{
			nlinfo( "Entering STALLED mode" );
			StalledMode = true;
			LastStallTime = 0;
		}

		if ((CTime::getLocalTime() - LastStallTime > 1000) /*|| (SimulateStalled.get() == 1)*/)
		{
			LastStallTime = CTime::getLocalTime();
			sendServerProblemStateToClients( CClientHost::Stalled );
		}
	}

	// update the pending user list
	CLoginServer::refreshPendingList();

	// Display statistics
	CycleWatch.stop();
	static TTime lastdisplay = CTime::getLocalTime();
	if ( VerboseFEStatsTime.get() && (CTime::getLocalTime() - lastdisplay > 1000) )
	{
		TMsDuration cyclepartialaverage = CycleWatch.getPartialAverage();
		nlinfo( "FETIME: Time in ms: Receive=%u Send=%u UserLoop=%u Cycle=%u (%.1f cps)",
				ReceiveWatch.getPartialAverage(), SendWatch.getPartialAverage(), UserDurationPAverage,
				cyclepartialaverage, 1000.0f/(float)cyclepartialaverage );
		lastdisplay = CTime::getLocalTime();
	}
	CycleWatch.start();


	uint32 now = CTime::getSecondsSince1970();
	bool noRecentComm = now - CFEReceiveTask::LastUDPPacketReceived > DelayBeforeUPDAlert;
	// check for potential communication problem
	if (CLoginServer::getNbPendingUsers() != 0
		|| this->_ReceiveSub.getNbClient() != 0)
	{
		if (noRecentComm)
		{
			// raise the alert for a limited time
			addStatusTag("CheckUDPComm");
		}
	}

	if (!noRecentComm)
	{
		// clear the UDP alert tag (if set)
		removeStatusTag("CheckUDPComm");
	}

	return true;
}


/*
 * Add an impulse to a specific client
 */
void	CFrontEndService::addImpulseToClient(TClientId client, CActionImpulsion *action, uint level)
{
	TClientIdCont	&cont = _ReceiveSub.clientIdCont();

	if (client >= cont.size() || cont[client] == NULL)
	{
		nlwarning ("Can't send impulse to client %d (doesn't exist)", client);
		return;
	}

	cont[client]->ImpulseEncoder.add(action, level);
}

/*
 * Add an impulse to a specific entity provided it is a client
 */
void	CFrontEndService::addImpulseToEntity( const TEntityIndex& entity, CActionImpulsion *action, uint level )
{
	TClientId	client = _ReceiveSub.EntityToClient.getClientId( entity );

	if (client != INVALID_CLIENT)
	{
		addImpulseToClient(client, action, level);
	}
	else
	{
		nlwarning ("Can't send impulse to E%u (doesn't exist or not a client)", entity.getIndex());
		return;
	}
}


/*
 * Remove clients that do not send datagrams anymore
 */
void CFrontEndService::updateClientsStates()
{
	TTime	ctime = CTime::getLocalTime();

	THostMap::iterator iclient, icremove;
	for ( iclient=_ReceiveSub.clientMap().begin(); iclient!=_ReceiveSub.clientMap().end(); )
	{
		CClientHost	*client = GETCLIENTA(iclient);
		// Check if receive time is not too old
		TTime	cltime = ctime - client->receiveTime();
/*
		// TEMP BEN
		CActionDummy	*dummy = (CActionDummy*)(CActionFactory::getInstance()->create(ACTION_DUMMY_CODE));
		dummy->Dummy1 = ++(client->LastSentDummy);
		addImpulseToClient(client->clientId(), dummy, 1);
		// TEMP BEN
*/
		switch (client->ConnectionState)
		{
		default:
			if (cltime > _ClientLagTime)
			{
				//nlwarning( "Client %u lags (no incoming data for %u ms), setting probe mode", GETCLIENTA(iclient)->clientId(), _ClientLagTime );
				client->setProbeState();
			}
			else
			{
				++iclient;
			}
			break;
		case CClientHost::Probe:
			if ( cltime > _ClientTimeOut )
			{
				nlinfo( "Client %u %s seems dead (no incoming data for %u ms)", GETCLIENTA(iclient)->clientId(), GETCLIENTA(iclient)->address().asString().c_str(), _ClientTimeOut );
				icremove = iclient;
				++iclient;
				_ReceiveSub.removeFromRemoveList( GETCLIENTA(icremove)->clientId() ); 
				_ReceiveSub.removeClientById( GETCLIENTA(icremove)->clientId() );
			}
			else
			{
				++iclient;
			}
			break;
		}
	}
}


/*
 * Set clients to stalled or "server down" mode (and send stalled msg immediately)
 */
void CFrontEndService::sendServerProblemStateToClients( uint connectionState )
{
	uint8 systemMsgCode;
	switch ( connectionState )
	{
	case CClientHost::ServerDown:
		systemMsgCode = SYSTEM_SERVER_DOWN_CODE;
		break;
	case CClientHost::Stalled:
		systemMsgCode = SYSTEM_STALLED_CODE;
		break;
	default:
		nlstop;
	}
	//nldebug( "Sending %s to clients", SystemMessagesNames[systemMsgCode] );
	//uint numClients = 0;
	THostMap::iterator iclient;
	for ( iclient=_ReceiveSub.clientMap().begin(); iclient!=_ReceiveSub.clientMap().end(); ++iclient )
	{
		// Send the stalled or server down code. Note: client->setupSystemHeader() calls getNextSendNumber().
		// If this is called more than once per tick (or less), the client's CurrentServerTick will get shifted,
		// leading to the warning "handleReceivedMsg : FERECV: client %d sent messages dated in future".
		// To avoid this, the FS *must* resynchronize the clients when exiting from stalled mode
		// (see setClientsToSynchronizeState()).
		CClientHost	*client = GETCLIENTA(iclient);
		client->ConnectionState = connectionState;
		_SendSub.enableSendBuffer( client->clientId() );
		TOutBox& outbox = _SendSub.outBox( client->clientId() );
		outbox.resetBufPos();
		client->setupSystemHeader( outbox, systemMsgCode );
		
		//outbox.displayStream(toString("STALLED:displayOutbox for %u:", client->clientId()).c_str());
		//++numClients;
	}
	swapSendBuffers(); // waits for the end of the previous background flushing
	flushMessagesToSend(); // flushes (blocking operation in the main thread)
	
	//nldebug( "Sent %s to %u clients", SystemMessagesNames[systemMsgCode], numClients );
}


/*
 * Set clients to synchronize state
 */
void CFrontEndService::setClientsToSynchronizeState()
{
	nlinfo( "Leaving STALLED mode" );
	StalledMode = false;

	THostMap::iterator iclient;
	for ( iclient=_ReceiveSub.clientMap().begin(); iclient!=_ReceiveSub.clientMap().end(); ++iclient )
	{
		CClientHost	*client = GETCLIENTA(iclient);

		// Set to Force Synchronize state to ensure an ack_sync received from client
		// will not overwrite the state with Connected
		client->setForceSynchronizeState();
	}
}

void CFrontEndService::newCookieCallback(const NLNET::CLoginCookie &cookie)
{
	// update the last UPD packet date 
	if (CFEReceiveTask::LastUDPPacketReceived == 0)
	{
		// set the date to 'now'. If no UPD traffic is detected after
		// a predetermined timer, an alert is set in the service status line.
		CFEReceiveTask::LastUDPPacketReceived = CTime::getSecondsSince1970();
	}
}



/*
 *
 */

NLMISC_DYNVARIABLE( bool, StalledMode, "true if no tick for 2 seconds" )
{
	if ( get )
		*pointer = CFrontEndService::instance()->StalledMode;
}


NLMISC_DYNVARIABLE( uint32, UserTime, "User duration partial average" )
{
	if ( get )
		*pointer = CFrontEndService::instance()->UserDurationPAverage;
}


NLMISC_DYNVARIABLE( uint32, SentActions, "User duration partial average" )
{
	if ( get )
		*pointer = CFrontEndService::instance()->SentActionsLastCycle;
}


bool Stats = false;

// This assumes the negative filter "FESTATS" is in the config file
NLMISC_COMMAND( switchStats, "Switch stats", "" )
{
	Stats = ! Stats;
	if ( Stats )
		InfoLog->removeFilter( "FESTATS" );
	else
		InfoLog->addNegativeFilter( "FESTATS" );
	return true;
}


NLMISC_COMMAND( monitorClient, "Set the client id to monitor", "<clientid>" )
{
	if (args.size() != 1) return false;
	TClientId clientid;
	NLMISC::fromString(args[0], clientid);
	if ( clientid <= MAX_NB_CLIENTS )
		CFrontEndService::instance()->monitorClient( clientid );
	return true;
}


NLMISC_COMMAND( disconnectClient, "Disconnect a client", "<clientid>" )
{
	if (args.size() != 1) return false;
	
	TClientId clientid;
	NLMISC::fromString(args[0], clientid);
	
	CClientHost *clienthost;
	if ( (clientid <= MaxNbClients) && ((clienthost = CFrontEndService::instance()->sendSub()->clientIdCont()[clientid]) != NULL) )
	{
		cbDisconnectClient( clienthost->Uid, "FS user command" );
	}
	else
	{
		log.displayNL( "There is no such a client id" );
	}
	return true;
}


NLMISC_COMMAND( verboseImpulsions, "Turn on/off or check the state of verbose logging of impulsions", "" )
{
	if ( args.size() == 1 )
	{
		if ( args[0] == string("on") || args[0] == string("1") )
			verboseImpulsions=true;
		else if ( args[0] == string("off") || args[0] == string("0") )
			verboseImpulsions=false;
	}

	log.displayNL( "verboseImpulsions is %s", verboseImpulsions ? "on" : "off" );
	return true;
}


NLMISC_COMMAND( getTargetPosAtTick, "Get the last target entity position that was sent to a client at a specified tick in the past", "<clientId> <tick>" )
{
	if ( args.size() < 2 )
		return false;
	TClientId clientId;
	NLMISC::fromString(args[0], clientId);
	NLMISC::TGameCycle tick;
	NLMISC::fromString(args[1], tick);

	// Search
	bool found = false;
	TCoord x,y;
	if ( (clientId != INVALID_CLIENT) && (clientId <= MAX_NB_CLIENTS) )
	{
		CFrontEndService::instance()->history()->getTargetPosAtTick( clientId, tick, x, y );
		log.displayNL( "Position of target of C%hu was %d %d", clientId, x, y );
	}
	else
	{
		log.displayNL( "Invalid client id" );
	}

	return true;
}


class CImpulseStatPred
{
public:

	typedef	std::pair<float, CClientHost*>	TItem;
	bool	operator () (const TItem& a, const TItem& b) const
	{
		return a.first < b.first;
	}

};

NLMISC_COMMAND( dumpImpulseStats, "Dump Impulse stat to XML log", "<logfile> [[-]<num> [efficiency|queue]]")
{
	if (args.size() < 1)
		return false;

	sint	maxdump = -1;
	if (args.size() >= 2)
	{
		NLMISC::fromString(args[1], maxdump);
		maxdump = abs(maxdump);
	}

	bool	reverse = (args.size() >= 2 && args[1][0] == '-');

	std::string	criterion;
	if (args.size() >= 3)
		criterion = args[2];

	uint	ucriterion = 0;
	if (criterion == "efficiency")
		ucriterion = 1;
	if (criterion == "queue")
		ucriterion = 2;

	std::vector<std::pair<float, CClientHost*> >	result;

	THostMap&	clientmap = CFrontEndService::instance()->receiveSub()->clientMap();
	for (THostMap::iterator it = clientmap.begin (); it != clientmap.end (); it++)
	{
		CClientHost*	client = GETCLIENTA(it);
		float			comp = 0.0f;

		if (ucriterion == 1)
		{
			comp = client->ImpulseEncoder.leastEfficiencyRatio();
		}
		else if (ucriterion == 2)
		{
			comp = -(float)client->ImpulseEncoder.biggestQueueSize();
		}

		if (reverse)
			comp = -comp;

		result.push_back(std::make_pair<float, CClientHost*>(comp, client));
	}

	if (ucriterion != 0 && !result.empty())
	{
		std::sort(result.begin(), result.end(), CImpulseStatPred());
	}


	std::string	filename = args[0];
	COFile	file;
	COXml	xml;

	if (!file.open(filename) || !xml.init(&file))
		return false;

	xml.xmlPush("ImpulseDump");

	uint	num;
	for (num=0; num<result.size() && (maxdump <= 0 || num < uint(maxdump)); ++num)
	{
		CClientHost*	client = result[num].second;
		client->ImpulseEncoder.dump(xml);
	}

	xml.xmlPop();

	return true;
}



/*
 * Patching setup
 * Apache start/stop commands
 */

// Start Apache server
NLMISC_COMMAND( startWebPatchServer, "start Web server for patching", "")
{
	if (!UseWebPatchServer.get())
		return true;

	nlinfo("Execute startWebPatchServer...");

	if (!StartWebServerSysCommand.get().empty())
	{
		system(StartWebServerSysCommand.get().c_str());
	}

	return true;
}

// Stop Apache server
NLMISC_COMMAND( stopWebPatchServer, "stop Web server for patching", "")
{
	if (!UseWebPatchServer.get())
		return true;

	nlinfo("Execute stopWebPatchServer...");

	if (!StopWebServerSysCommand.get().empty())
	{
		system(StopWebServerSysCommand.get().c_str());
	}

	return true;
}

// Stop Apache server
NLMISC_COMMAND( acceptClients, "tells manually frontend to accept clients", "")
{
	setAcceptClients();
	return true;
}

NLMISC_CLASS_COMMAND_IMPL(CFrontEndService, dump)
{
	if (args.size() != 0)
		return false;

	log.displayNL("Frontend internal state :");
	log.displayNL("Listen address: %s", CLoginServer::getListenAddress().c_str() );
	log.displayNL("UDP sock listening on %s", _ReceiveSub.dataSock()->localAddr().asString().c_str() );
	return true;
}


/*
 * Declare a service with the class CFrontEndService, the names "FS" (short) and "frontend_service" (long).
 * The port is set to 37000 and the main callback array is CallbackArray.
 * Note: this is the port towards the other services of the shard (TCP communication).
 */
NLNET_SERVICE_MAIN( CFrontEndService, "FS", "frontend_service", 0, cbFrontEndArray, "", "" )