// NeLNS - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// 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/>.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif // HAVE_CONFIG_H

#ifndef NELNS_CONFIG
#define NELNS_CONFIG ""
#endif // NELNS_CONFIG

#ifndef NELNS_LOGS
#define NELNS_LOGS ""
#endif // NELNS_LOGS


//
// Includes
//

#include "nel/misc/types_nl.h"

#include <list>
#include <string>

#include "nel/misc/debug.h"
#include "nel/misc/command.h"
#include "nel/misc/variable.h"
#include "nel/misc/displayer.h"

#include "nel/net/callback_server.h"
#include "nel/net/service.h"
#include "nel/net/module_manager.h"

//
// Namespaces
//

using namespace std;

using namespace NLMISC;
using namespace NLNET;


NLMISC_COMMAND(test, "none", "none")
{
	log.displayNL("Raw cmd line : '%s'", rawCommandString.c_str());
	log.displayNL("Dumping %u parameters :", args.size());
	for (uint i=0; i<args.size(); ++i)
	{
		log.displayNL("  %u : '%s'", i, args[i].c_str());
	}
	return true;
}


//
// Structures
//

struct CServiceEntry
{
	CServiceEntry (TSockId sock, const vector<CInetAddress> &a, const string &n, TServiceId s) : SockId(sock), Addr(a), Name(n), SId (s), WaitingUnregistration(false) { }

	TSockId						SockId;			// the connection between the service and the naming service
	vector<CInetAddress>		Addr;			// address to send to the service who wants to lookup this service
												// it s possible to have more than one addr, anyway, the naming service
												// will send good address depending of the sub net address of the service
	string						Name;			// name of the service
	TServiceId					SId;			// id of the service

	bool				WaitingUnregistration;			// true if this service is in unregistration process (wait other service ACK)
	TTime				WaitingUnregistrationTime;		// time of the beginning of the inregistration process
	list<TServiceId>	WaitingUnregistrationServices;	// list of service that we wait the answer
};



// Helper that emulates layer5's send()
//void sendToService( uint16 sid, CMessage& msgout );

// Helper that emulate layer5's getServiceName()
string getServiceName( TServiceId  sid );

// Helper that returns the first address of a service
CInetAddress getHostAddress( TServiceId  sid );

// Asks a service to stop and tell every one
void doUnregisterService (TServiceId sid);


/**
 * Manager for services instances
 * (Moved from the TICKS to the NS)
 * Implementable with layer 5, here implemented in NS (layer 3)
 * \author Olivier Cado
 * \author Nevrax France
 * \date 2003
 */
class CServiceInstanceManager
{
public:
	
	/// Constructor
	CServiceInstanceManager();

	/** Add the name of a service which must not be duplicated
	 * If uniqueOnShard is true, only one service is allowed.
	 * If uniqueOnShard is false, one service is allowed by physical machine.
	 */
	void		addUniqueService( const std::string& serviceName, bool uniqueOnShard )
	{
		_UniqueServices.insert( std::make_pair( serviceName, uniqueOnShard ) );
	}

	/// Check if a service is allowed to start (if so, add it)
	bool		queryStartService( const std::string& serviceName, TServiceId  serviceId, const std::vector<NLNET::CInetAddress> &addr, string& reason );

	/// Release a service instance
	void		releaseService( NLNET::TServiceId serviceId );

	/// Display information
	void		displayInfo( NLMISC::CLog *log = NLMISC::InfoLog ) const;

	/// Make all controlled services quit
	void		killAllServices();

private:

	/// List of restricted services
	std::map< std::string, bool >	_UniqueServices;

	/// List of granted (online) services
	std::set< TServiceId >				_OnlineServices;
};


CServiceInstanceManager *SIMInstance = NULL;


/*
 * Constructor
 */
CServiceInstanceManager::CServiceInstanceManager()
{
	nlassert( ! SIMInstance );
	SIMInstance = this;

	// Note: addCallbackArray() done in CRangeMirrorManager::init()
}


/*
 * Check if a service is allowed to start. Answer with a GSTS (Grant Start Service) message
 */
bool		CServiceInstanceManager::queryStartService( const std::string& serviceName, TServiceId  serviceId, const vector<CInetAddress> &addr, string& reason )
{
	bool grantStarting = true;
	std::map< std::string, bool >::iterator ius = _UniqueServices.find( serviceName );
	if ( ius != _UniqueServices.end() )
	{
		// Service is restricted
		set< TServiceId >::iterator ios;
		bool uniqueOnShard = (*ius).second;
		for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
		{
			string name = getServiceName( *ios );
			if ( name == serviceName )
			{
				if ( uniqueOnShard )
				{
					// Only one service by shard is allowed => deny
					grantStarting = false;
					reason = toString( "Service %s already found as %hu, must be unique on shard", serviceName.c_str(), ios->get() );
					nlinfo( reason.c_str() );
					break;
				}
				else
				{
					// Only one service by physical machine is allowed

					// Implementation for layer5
					//TSockId hostid1, hostid2;
					/*CCallbackNetBase *cnb1 = CUnifiedNetwork::getInstance()->getNetBase( serviceId, hostid1 );
					CCallbackNetBase *cnb2 = CUnifiedNetwork::getInstance()->getNetBase( *ios, hostid2 );
					if ( cnb1->hostAddress( hostid1 ).internalIPAddress() == cnb2->hostAddress( hostid2 ).internalIPAddress() )*/

					// Implementation for NS
					if ( addr[0].internalIPAddress() == getHostAddress( *ios ).internalIPAddress() )
					{
						grantStarting = false;
						reason = toString( "Service %s already found as %hu on same machine", serviceName.c_str(), ios->get() );
						nlinfo( reason.c_str() );
						break;
					}
				}
			}
		}
	}

	if ( grantStarting )
	{
		_OnlineServices.insert( serviceId );
	}
	return grantStarting;
}


/*
 * Release a service instance
 */
void		CServiceInstanceManager::releaseService( NLNET::TServiceId serviceId )
{
	_OnlineServices.erase( serviceId ); // not a problem if not found
}


/*
 * Display information
 */
void		CServiceInstanceManager::displayInfo( NLMISC::CLog *log ) const
{
	log->displayNL( "Restricted services:" );
	std::map< std::string, bool >::const_iterator ius;
	for ( ius=_UniqueServices.begin(); ius!=_UniqueServices.end(); ++ius )
	{
		log->displayNL( "%s -> only one per %s", (*ius).first.c_str(), (*ius).second?"shard":"machine" );
	}
	log->displayNL( "Online registered services:" );
	std::set< TServiceId >::const_iterator ios;
	for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
	{
		log->displayNL( "%s", CUnifiedNetwork::getInstance()->getServiceUnifiedName( *ios ).c_str() );
	}
}


/*
 * Make all controlled services quit
 */
void		CServiceInstanceManager::killAllServices()
{
	// Send to all known online services
	std::set< TServiceId >::const_iterator ios;
	for ( ios=_OnlineServices.begin(); ios!=_OnlineServices.end(); ++ios )
	{
		doUnregisterService( (TServiceId)(*ios) );
	}
}



//
// Variables
//

list<CServiceEntry>	RegisteredServices;		/// List of all registred services

uint16				MinBasePort = 51000;	/// Ports begin at 51000
uint16				MaxBasePort = 52000;	/// (note: in this implementation there can be no more than 1000 services)

const TServiceId	BaseSId(128);			/// Allocated SIds begin at 128 (except for Agent Service)

const TTime			UnregisterTimeout = 10000;	/// After 10s we remove an unregister service if every server didn't ACK the message

CCallbackServer		*CallbackServer = NULL;

//
// Functions
//

bool canAccess (const vector<CInetAddress> &addr, const CServiceEntry &entry, vector<CInetAddress> &accessibleAddr)
{
	accessibleAddr.clear ();
	
	if (entry.WaitingUnregistration)
		return false;

	for (uint i = 0; i < addr.size(); i++)
	{
		uint32 net = addr[i].internalNetAddress();
		for (uint j = 0; j < entry.Addr.size(); j++)
		{
			if (net == entry.Addr[j].internalNetAddress())
			{
				accessibleAddr.push_back (entry.Addr[j]);
			}
		}
	}

	if (accessibleAddr.empty())
	{
		nldebug ("service %s-%hu is not accessible by '%s'", entry.Name.c_str(), entry.SId.get(), vectorCInetAddressToString (addr).c_str ());
	}
	else
	{
		nldebug ("service %s-%hu is accessible by '%s'", entry.Name.c_str(), entry.SId.get(), vectorCInetAddressToString (accessibleAddr).c_str ());
	}

	return !accessibleAddr.empty ();
}

void displayRegisteredServices (CLog *log = InfoLog)
{
	log->displayNL ("Display the %d registered services :", RegisteredServices.size());
	for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		TSockId id = (*it).SockId;
		if (id == NULL)
		{
			log->displayNL ("> %s-%hu %s '%s' %s %d addr", (*it).Name.c_str(), it->SId.get(), "<NULL>", "<NULL>", (*it).WaitingUnregistration?"WaitUnreg":"", (*it).Addr.size());
			for(uint i = 0; i < (*it).Addr.size(); i++)
				log->displayNL ("              '%s'", (*it).Addr[i].asString().c_str());
		}
		else
		{
			log->displayNL ("> %s-%hu %s '%s' %s %d addr", (*it).Name.c_str(), it->SId.get(), (*it).SockId->asString().c_str(), CallbackServer->hostAddress((*it).SockId).asString().c_str(), (*it).WaitingUnregistration?"WaitUnreg":"", (*it).Addr.size());
			for(uint i = 0; i < (*it).Addr.size(); i++)
				log->displayNL ("              '%s'", (*it).Addr[i].asString().c_str());
		}
	}
	log->displayNL ("End of the list");
}


list<CServiceEntry>::iterator effectivelyRemove (list<CServiceEntry>::iterator &it)
{
	// remove the service from the registered service list
	nlinfo ("Effectively remove the service %s-%hu", (*it).Name.c_str(), it->SId.get());
	return RegisteredServices.erase (it);
}

/*
 * Helper procedure for cbLookupAlternate and cbUnregister.
 * Note: name is used for a LOGS.
 */
list<CServiceEntry>::iterator doRemove (list<CServiceEntry>::iterator it)
{
	nldebug ("Unregister the service %s-%hu '%s'", (*it).Name.c_str(), it->SId.get(), (*it).Addr[0].asString().c_str());
	
	// tell to everybody that this service is unregistered

	CMessage msgout ("UNB");
	msgout.serial ((*it).Name);
	msgout.serial ((*it).SId);

	vector<CInetAddress> accessibleAddress;
	nlinfo ("Broadcast the Unregistration of %s-%hu to all registered services", (*it).Name.c_str(), it->SId.get());
	for (list<CServiceEntry>::iterator it3 = RegisteredServices.begin(); it3 != RegisteredServices.end (); it3++)
	{
		if (canAccess((*it).Addr, (*it3), accessibleAddress))
		{
			CallbackServer->send (msgout, (*it3).SockId);
			//CNetManager::send ("NS", msgout, (*it3).SockId);
			nldebug ("Broadcast to %s-%hu", (*it3).Name.c_str(), it3->SId.get());
		}
	}

	// new system, after the unregistation broadcast, we wait ACK from all services before really remove
	// the service, before, we tag the service as 'wait before unregister'
	// if everybody didn't answer before the time out, we remove it

	(*it).SockId = NULL;

	(*it).WaitingUnregistration = true;
	(*it).WaitingUnregistrationTime = CTime::getLocalTime();

	// we remove all services awaiting his ACK because this service is down so it'll never ACK
	for (list<CServiceEntry>::iterator itr = RegisteredServices.begin(); itr != RegisteredServices.end (); itr++)
	{
		for (list<TServiceId>::iterator itw = (*itr).WaitingUnregistrationServices.begin(); itw != (*itr).WaitingUnregistrationServices.end ();)
		{
			if ((*itw) == (*it).SId)
			{
				itw = (*itr).WaitingUnregistrationServices.erase (itw);
			}
			else
			{
				itw++;
			}
		}
	}

	string res;
	for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
	{
		if (!(*it2).WaitingUnregistration)
		{
			(*it).WaitingUnregistrationServices.push_back ((*it2).SId);
			res += toString((*it2).SId.get()) + " ";
		}
	}

	nlinfo ("Before removing the service %s-%hu, we wait the ACK of '%s'", (*it).Name.c_str(), (*it).SId.get(), res.c_str());
	
	if ((*it).WaitingUnregistrationServices.empty())
	{
		return effectivelyRemove (it);
	}
	else
	{
		return ++it;
	}

	// Release from the service instance manager
	SIMInstance->releaseService( (*it).SId );
}

void doUnregisterService (TServiceId sid)
{
	list<CServiceEntry>::iterator it;
	for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).SId == sid)
		{
			// found it, remove it
			doRemove (it);
			return;
		}
	}
	nlwarning ("Service %hu not found", sid.get());
}

void doUnregisterService (TSockId from)
{
	list<CServiceEntry>::iterator it;
	for (it = RegisteredServices.begin(); it != RegisteredServices.end ();)
	{
		if ((*it).SockId == from)
		{
			// it's possible that one "from" have more than one registred service, so we have to find in all the list
			// found it, remove it
			it = doRemove (it);
		}
		else
		{
			it++;
		}
	}
}

/*void doUnregisterService (const CInetAddress &addr)
{
	list<CServiceEntry>::iterator it;
	for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).Addr == addr)
		{
			// found it, remove it
			doRemove (it);
			return;
		}
	}
	nlwarning ("Service %s not found", addr.asString().c_str());
}*/

/*
 * Helper function for cbRegister.
 * If alloc_sid is true, sid is ignored
 * Returns false in case of failure of sid allocation or bad sid provided
 * Note: the reply is included in this function, because it must be done before things such as syncUniTime()
 */
bool doRegister (const string &name, const vector<CInetAddress> &addr, TServiceId sid, TSockId from, CCallbackNetBase &netbase, bool reconnection = false)
{
	// Find if the service is not already registered
	string reason;
	uint8 ok = true;
	bool needRegister = true;
	/*for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).Addr.asIPString() == addr.asIPString() )
		{
			// we already have a service on this address, remplace it if it's the same name
			if ((*it).Name == name)
			{
				// it's the same service, replace it
				(*it).SockId = from;
				sid = (*it).SId;
				nlinfo ("Replace the service %s", name.c_str());
			}
			else
			{
				nlwarning ("Try to register %s to %s but the service %s already on this address. ignore it!", name.c_str(), addr.asIPString().c_str(), (*it).Name.c_str());
				ok = false;
			}
			needRegister = false;
			break;
		}
	}*/

	if (needRegister)
	{
		if (sid.get() == 0)
		{
			// we have to find a sid
			sid = BaseSId;
			bool found = false;
			while (!found)
			{
				list<CServiceEntry>::iterator it;
				for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
				{
					if ((*it).SId == sid)
					{
						break;
					}
				}
				if (it == RegisteredServices.end ())
				{
					// ok, we have an empty sid
					found = true;
				}
				else
				{
					sid.set(sid.get()+1);
					if (sid.get() == 0) // round the clock
					{
						nlwarning ("Service identifier allocation overflow");
						ok = false;
						break;
					}
				}
			}

		}
		else
		{
			// we have to check that the user provided sid is available
			list<CServiceEntry>::iterator it;
			for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
			{
				if ((*it).SId == sid)
				{
					nlwarning ("Sid %d already used by another service", sid.get());
					ok = false;
					break;
				}
			}
			if (it != RegisteredServices.end ())
			{
				ok = true;
			}
		}

		// if ok, register the service and send a broadcast to other people
		if (ok)
		{
			// Check if the instance is allowed to start, according to the restriction in the config file			
			if ( SIMInstance->queryStartService( name, sid, addr, reason ) )
			{
				// add him in the registered list
				RegisteredServices.push_back (CServiceEntry(from, addr, name, sid));

				// tell to everybody but not him that this service is registered
				if (!reconnection)
				{
					CMessage msgout ("RGB");
					TServiceId::size_type s = 1;
					msgout.serial (s);
					msgout.serial (const_cast<string &>(name));
					msgout.serial (sid);
					// we need to send all addr to all services even if the service can't access because we use the address index
					// to know which connection comes.
					msgout.serialCont (const_cast<vector<CInetAddress> &>(addr));
					nlinfo ("The service is %s-%d, broadcast the Registration to everybody", name.c_str(), sid.get());

					vector<CInetAddress> accessibleAddress;
					for (list<CServiceEntry>::iterator it3 = RegisteredServices.begin(); it3 != RegisteredServices.end (); it3++)
					{
						// send only services that can be accessed and not itself
						if ((*it3).SId != sid && canAccess(addr, (*it3), accessibleAddress))
						{
							CallbackServer->send (msgout, (*it3).SockId);
							//CNetManager::send ("NS", msgout, (*it3).SockId);
							nldebug ("Broadcast to %s-%hu", (*it3).Name.c_str(), it3->SId.get());
						}
					}
				}

				// set the sid only if it s ok
				from->setAppId (sid.get());
			}
			else
			{
				// Reply "startup denied", and do not send registration to other services
				ok = false;
			}
		}

		// send the message to the service to say if it s ok or not
		if (!reconnection)
		{
			// send the answer to the client
			CMessage msgout ("RG");
			msgout.serial (ok);
			if (ok)
			{
				msgout.serial (sid);

				// send him all services available (also itself)
				TServiceId::size_type nb = 0;

				vector<CInetAddress> accessibleAddress;

				for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
				{
					// send only services that are available
					if (canAccess(addr, (*it2), accessibleAddress))
						nb++;
				}
				msgout.serial (nb);

				for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
				{
					// send only services that are available
					if (canAccess(addr, (*it), accessibleAddress))
					{
						msgout.serial ((*it).Name);
						msgout.serial ((*it).SId);
						msgout.serialCont ((*it).Addr);
					}
				}
			}
			else
			{
				msgout.serial( reason );
			}
			
			netbase.send (msgout, from);
			netbase.flush (from);
		}
	}

	//displayRegisteredServices ();

	return ok!=0;
}

void checkWaitingUnregistrationServices ()
{
	for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end ();)
	{
		if ((*it).WaitingUnregistration && ((*it).WaitingUnregistrationServices.empty() || CTime::getLocalTime() > (*it).WaitingUnregistrationTime + UnregisterTimeout))
		{
			if ((*it).WaitingUnregistrationServices.empty())
			{
				nlinfo ("Removing the service %s-%hu because all services ACKd the removal", (*it).Name.c_str(), (*it).SId.get());
			}
			else
			{
				string res;
				for (list<TServiceId>::iterator it2 = (*it).WaitingUnregistrationServices.begin(); it2 != (*it).WaitingUnregistrationServices.end (); it2++)
				{
					res += toString(it2->get()) + " ";
				}
				nlwarning ("Removing the service %s-%hu because time out occurs (service numbers %s didn't ACK)", (*it).Name.c_str(), (*it).SId.get(), res.c_str());
			}
			it = effectivelyRemove (it);
		}
		else
		{
			it++;
		}
	}
}


/**
 * Callback for service unregistration ACK. Mean that a service was ACK the unregistration broadcast
 */
static void cbACKUnregistration (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
	TServiceId sid;
	msgin.serial (sid);

	for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).SId == sid && (*it).WaitingUnregistration)
		{
			for (list<TServiceId>::iterator it2 = (*it).WaitingUnregistrationServices.begin(); it2 != (*it).WaitingUnregistrationServices.end (); it2++)
			{
				if (*it2 == TServiceId(uint16(from->appId())))
				{
					// remove the acked service
					(*it).WaitingUnregistrationServices.erase (it2);
					checkWaitingUnregistrationServices ();
					return;
				}
			}
		}
	}
}


/**
 * Callback for service registration when the naming service goes down and up (don't need to broadcast)
 */
static void cbResendRegisteration (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
	string name;
	vector<CInetAddress> addr;
	TServiceId sid;
	msgin.serial (name);
	msgin.serialCont (addr);
	msgin.serial (sid);

	doRegister (name, addr, sid, from, netbase, true);
}



/**
 * Callback for service registration.
 *
 * Message expected : RG
 * - Name of service to register (string)
 * - Address of service (CInetAddress)
 *
 * Message emitted : RG
 * - Allocated service identifier (TServiceId) or 0 if failed
 */
static void cbRegister (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
	string name;
	vector<CInetAddress> addr;
	TServiceId sid;
	msgin.serial (name);
	msgin.serialCont (addr);
	msgin.serial (sid);

	doRegister (name, addr, sid, from, netbase);
}


/**
 * Callback for service unregistration.
 *
 * Message expected : UNI
 * - Service identifier (TServiceId)
 */
static void cbUnregisterSId (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
	TServiceId sid;
	msgin.serial( sid );

	doUnregisterService (sid);
	//displayRegisteredServices ();
}


/*
 * Helper function for cbQueryPort
 *
 * \warning QueryPort + Registration is not atomic so more than one service could ask a port before register
 */
uint16 doAllocatePort (const CInetAddress &addr)
{
	static uint16 nextAvailablePort = MinBasePort;

	// check if nextavailableport is free

	if (nextAvailablePort >= MaxBasePort) nextAvailablePort = MinBasePort;

	bool ok;
	do
	{
		ok = true;
		list<CServiceEntry>::iterator it;
		for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
		{
			if ((*it).Addr[0].port () == nextAvailablePort)
			{
				nextAvailablePort++;
				ok = false;
				break;
			}
		}
	}
	while (!ok);

	return nextAvailablePort++;
}


/**
 * Callback for port allocation
 * Note: if a service queries a port but does not register itself to the naming service, the
 * port will remain allocated and unused.
 *
 * Message expected : QP
 * - Name of service to register (string)
 * - Address of service (CInetAddress) (its port can be 0)
 *
 * Message emitted : QP
 * - Allocated port number (uint16)
 */
static void cbQueryPort (CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
	// Allocate port
	uint16 port = doAllocatePort (netbase.hostAddress (from));

	// Send port back
	CMessage msgout ("QP");
	msgout.serial (port);
	netbase.send (msgout, from);

	nlinfo ("The service got port %hu", port);
}


/*
 * Unregisters a service if it has not been done before.
 * Note: this callback is called whenever someone disconnects from the NS.
 * May be there are too many calls if many clients perform many transactional lookups.
 */
static void cbDisconnect /*(const string &serviceName, TSockId from, void *arg)*/ ( TSockId from, void *arg )
{
	doUnregisterService (from);
	//displayRegisteredServices ();
}

/*
 * a service is connected, send him all services infos
 */
static void cbConnect /*(const string &serviceName, TSockId from, void *arg)*/ ( TSockId from, void *arg )
{
	// we have to wait the registred services message to send all services because it this points, we can't know which sub net
	// the service can use

	//displayRegisteredServices ();

	// set the appid with a bad id (-1)
	from->setAppId (~0);
}

/*// returns the list of accessible services with a list of address
static void cbRegisteredServices(CMessage& msgin, TSockId from, CCallbackNetBase &netbase)
{
	vector<CInetAddress> addr;
	msgin.serialCont (addr);

	nlinfo ("New service ask me the available services, sending him all services available");
	// send to the new service the list of all services that this service can access (depending of his sub net)

	CMessage msgout ("RGB");

	uint8 nb = 0;

	vector<CInetAddress> accessibleAddress;

	for (list<CServiceEntry>::iterator it2 = RegisteredServices.begin(); it2 != RegisteredServices.end (); it2++)
	{
		// send only services that are available
		if (canAccess(addr, (*it2), accessibleAddress))
			nb++;
	}

	msgout.serial (nb);

	for (list<CServiceEntry>::iterator it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		// send only services that are available
		if (canAccess(addr, (*it), accessibleAddress))
		{
			msgout.serial ((*it).Name);
			msgout.serial ((*it).SId);
			msgout.serialCont (accessibleAddress);
		}
	}

	CNetManager::send ("NS", msgout, from);
}*/


/*
 * Helper that emulates layer5 send()
 */
/*void sendToService( uint16 sid, CMessage& msgout )
{
	list<CServiceEntry>::iterator it;
	for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).SId == sid)
		{
			CallbackServer->send (msgout, (*it).SockId);
		}
	}
}*/


/*
 * Helper that emulate layer5's getServiceName()
 */
string getServiceName( TServiceId  sid )
{
	list<CServiceEntry>::iterator it;
	for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).SId == sid)
		{
			return (*it).Name;
		}
	}
	return ""; // not found
}


/*
 * Helper that returns the first address of a service
 */
CInetAddress getHostAddress( TServiceId  sid )
{
	list<CServiceEntry>::iterator it;
	for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
	{
		if ((*it).SId == sid)
		{
			return (*it).Addr[0];
		}
	}
	return CInetAddress();
}


//
// Callback array
//

TCallbackItem CallbackArray[] =
{
	{ "RG", cbRegister },
	{ "RRG", cbResendRegisteration },
	{ "QP", cbQueryPort },
	{ "UNI", cbUnregisterSId },
	{ "ACK_UNI", cbACKUnregistration },
//	{ "RS", cbRegisteredServices },
};


//
// Service
//

class CNamingService : public NLNET::IService
{
public:

	/**
	 * Init
	 */
	void init()
	{
		// if a baseport is available in the config file, get it
		CConfigFile::CVar *var;
		if ((var = ConfigFile.getVarPtr ("BasePort")) != NULL)
		{
			uint16 newBasePort = var->asInt ();
			nlinfo ("Changing the MinBasePort number from %hu to %hu", MinBasePort, newBasePort);
			sint32 delta = MaxBasePort - MinBasePort;
			nlassert (delta > 0);
			MinBasePort = newBasePort;
			MaxBasePort = MinBasePort + uint16 (delta);
		}

		// Parameters for the service instance manager
		try
		{
			CConfigFile::CVar& uniqueServices = ConfigFile.getVar("UniqueOnShardServices");
			for ( uint i=0; i!=uniqueServices.size(); ++i )
			{
				_ServiceInstances.addUniqueService( uniqueServices.asString(i), true );
			}
		}
		catch(Exception &)
		{}
		try
		{
			CConfigFile::CVar& uniqueServicesM = ConfigFile.getVar("UniqueByMachineServices");
			for ( uint i=0; i!=uniqueServicesM.size(); ++i )
			{
				_ServiceInstances.addUniqueService( uniqueServicesM.asString(i), false );
			}
		}
		catch(Exception &)
		{}

/*
		// we don't try to associate message from client
		CNetManager::getNetBase ("NS")->ignoreAllUnknownId (true);

		// add the callback in case of disconnection
		CNetManager::setConnectionCallback ("NS", cbConnect, NULL);
		
		// add the callback in case of disconnection
		CNetManager::setDisconnectionCallback ("NS", cbDisconnect, NULL);
*/
		// DEBUG
		// DebugLog->addDisplayer( new CStdDisplayer() );

		vector<CInetAddress> v = CInetAddress::localAddresses();
		nlinfo ("%d detected local addresses:", v.size());
		for (uint i = 0; i < v.size(); i++)
		{
			nlinfo (" %d - '%s'",i, v[i].asString().c_str());
		}

		uint16 nsport = 50000;
		if ((var = ConfigFile.getVarPtr ("NSPort")) != NULL)
		{
			nsport = var->asInt ();
		}

		CallbackServer = new CCallbackServer;
		CallbackServer->init(nsport);
		CallbackServer->addCallbackArray(CallbackArray, sizeof(CallbackArray)/sizeof(CallbackArray[0]));
		CallbackServer->setConnectionCallback(cbConnect, NULL);
		CallbackServer->setDisconnectionCallback(cbDisconnect, NULL);
	}

	/**
	 * Update
	 */
	bool update ()
	{
		checkWaitingUnregistrationServices ();

		CallbackServer->update ();

		return true;
	}

	void release()
	{
		if (CallbackServer != NULL)
			delete CallbackServer;
		CallbackServer = NULL;
	}

private:

	/// Service instance manager singleton
	CServiceInstanceManager		_ServiceInstances;
};


static const char* getCompleteServiceName(const IService* theService)
{
	static std::string s;
	s= "naming_service";

	if (theService->haveLongArg("nsname"))
	{
		s+= "_"+theService->getLongArg("nsname");
	}

	if (theService->haveLongArg("fullnsname"))
	{
		s= theService->getLongArg("fullnsname");
	}

	return s.c_str();
}

static const char* getShortServiceName(const IService* theService)
{
	static std::string s;
	s= "NS";

	if (theService->haveLongArg("shortnsname"))
	{
		s= theService->getLongArg("shortnsname");
	}
	
	return s.c_str();
}
//
/// Naming Service
//
NLNET_SERVICE_MAIN( CNamingService, getShortServiceName(scn), getCompleteServiceName(scn), 0, EmptyCallbackArray, NELNS_CONFIG, NELNS_LOGS)


//
// Commands
//


NLMISC_COMMAND (nsServices, "displays the list of all registered services", "")
{
	if(args.size() != 0) return false;

	displayRegisteredServices (&log);

	return true;
}

NLMISC_COMMAND (kill, "kill a service and send an unregister broadcast to other service", "<ServiceShortName>|<ServiceId>")
{
	if(args.size() != 1) return false;

	// try with number

	TServiceId sid(atoi(args[0].c_str()));

	if(sid.get() == 0)
	{
		// not a number, try a name
		list<CServiceEntry>::iterator it;
		for (it = RegisteredServices.begin(); it != RegisteredServices.end (); it++)
		{
			if ((*it).Name == args[0])
			{
				sid = (*it).SId;
				break;
			}
		}
		if (it == RegisteredServices.end())
		{
			log.displayNL ("Bad service name or id '%s'", args[0].c_str());
			return false;
		}
	}

	doUnregisterService (sid);
	return true;
}

NLMISC_DYNVARIABLE(uint32, NbRegisteredServices, "display the number of service that are registered in naming service")
{
	if (get) *pointer = (uint32)RegisteredServices.size();
}

NLMISC_COMMAND( displayServiceInstances, "SIM: Display info on service instances", "" )
{
	SIMInstance->displayInfo( &log );
	return true;
}

NLMISC_COMMAND( killAllServices, "SIM: Make all the controlled services quit", "" )
{
	SIMInstance->killAllServices();
	return true;
}