// 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/>.



#ifndef NL_NETWORK_CONNECTION_H
#define NL_NETWORK_CONNECTION_H

#include "nel/misc/types_nl.h"
#include "nel/misc/bit_set.h"

#include <string>
#include <vector>
#include <list>
#include <deque>
#include <set>

#include <nel/misc/bit_mem_stream.h>
#include <nel/net/inet_address.h>
#include <nel/net/login_cookie.h>
#include <nel/net/login_client.h>
#include <nel/net/udp_sim_sock.h>
#include <nel/misc/vectord.h>
#include <nel/misc/md5.h>

#include "time_client.h"
#include "game_share/entity_types.h"
#include "property_decoder.h"
#include "impulse_decoder.h"
#include "game_share/action.h"
#include "game_share/ryzom_entity_id.h"
#include "game_share/action_block.h"
#include "game_share/loot_harvest_state.h"

/*
 * ENABLE_INCOMING_MSG_RECORDER for recording/replaying incoming network messages
 */
#undef ENABLE_INCOMING_MSG_RECORDER

#ifdef ENABLE_INCOMING_MSG_RECORDER
#include <nel/misc/file.h>
#endif

/*
// UNUSED
const uint		PropertiesPerEntity = 16;
const uint		EntitiesPerClient = 256;
*/

class CCDBNodeBranch;

namespace CLFECOMMON
{
	class CActionGeneric;
	class CActionGenericMultiPart;
}

// Hierachical timer
H_AUTO_DECL ( RZ_Client_Network_Connection_Set_Reference_Position )

//#define MEASURE_FE_SENDING

extern const char * ConnectionStateCStr [9];


/**
 * Exception thrown when the sending returns a "blocking operation interrupted".
 */
class EBlockedByFirewall : public NLNET::ESocket
{};


struct TNewEntityInfo
{
	void reset()
	{
		DataSetIndex = CLFECOMMON::INVALID_CLIENT_DATASET_INDEX;
		Alias = 0;
	}

	/// Compressed dataset row
	CLFECOMMON::TClientDataSetIndex		DataSetIndex;

	/// Alias (only for mission giver NPCs)
	uint32								Alias;
};



// ***************************************************************************
/**
 * Abstracts the connection client towards front-end
 * \author Benjamin Legros, Olivier Cado
 * \author Nevrax France
 * \date 2001-2002
 */
class CNetworkConnection
{
public:
	enum
	{
		/*
		 * DO LEAVE ENOUGH ROOM FOR FUTURE PROPERTIES !
		 */
		AddNewEntity = 32,
		RemoveOldEntity,
		ConnectionReady,
		LagDetected,
		ProbeReceived
	};


	struct TVPNodeClient : public CLFECOMMON::TVPNodeBase
	{
		struct TSlotContext
		{
			CNetworkConnection						*NetworkConnection;
			CLFECOMMON::TCLEntityId					Slot;
			NLMISC::TGameCycle						Timestamp;
		};

		// Static data
		static TSlotContext							SlotContext;

		///
		TVPNodeClient() : TVPNodeBase() {}

		TVPNodeClient	*a() { return (TVPNodeClient*)VPA; }
		TVPNodeClient	*b() { return (TVPNodeClient*)VPB; }
		TVPNodeClient	*parent() { return (TVPNodeClient*)VPParent; }

		///
		void			decodeDiscreetProperties( NLMISC::CBitMemStream& msgin )
		{
			msgin.serialBitAndLog( BranchHasPayload );
			if ( BranchHasPayload )
			{
				if ( isLeaf() )
				{
					SlotContext.NetworkConnection->decodeDiscreetProperty( msgin, PropIndex );
				}
				else
				{
					if ( a() ) a()->decodeDiscreetProperties( msgin );
					if ( b() ) b()->decodeDiscreetProperties( msgin );
				}
			}
		}

		void		makeChildren()
		{
			VPA = new TVPNodeClient();
			VPA->VPParent = this;
			VPB = new TVPNodeClient();
			VPB->VPParent = this;
		}

		void		makeDescendants( uint nbLevels )
		{
			makeChildren();
			if ( nbLevels > 1 )
			{
				a()->makeDescendants( nbLevels-1 );
				b()->makeDescendants( nbLevels-1 );
			}
		}

		void		deleteBranches()
		{
			if ( a() )
			{	a()->deleteBranches();
				delete a();
			}
			if ( b() )
			{	b()->deleteBranches();
				delete b();
			}
		}

		void		deleteA()
		{
			if ( a() )
			{	a()->deleteBranches();
				delete a();
			}
		}

		void		deleteB()
		{
			if ( b() )
			{	b()->deleteBranches();
				delete b();
			}
		}

	};

	/// Additional info for position updates
	struct TPositionInfo
	{
		/**
		 * Only for positions (property index 0): interval, in game cycle unit, between the current
		 * position update and the next predicted one. In most cases the next real position update
		 * will occur just before the predicted interval elapses.
		 *
		 * If the interval cannot be predicted yet (e.g. before having received two updates
		 * for the same entity), PredictedInterval is set to ~0.
		 */
		NLMISC::TGameCycle			PredictedInterval;

		/// Is position interior (only for position)
		bool						IsInterior;
	};

	/**
	 * A property change
	 */
	class CChange
	{
	public:

		/// Constructor
		CChange( CLFECOMMON::TCLEntityId id = 0, uint8 prop = 255, NLMISC::TGameCycle gc = 0 ) :
			ShortId(id), Property(prop), GameCycle(gc) {}

		/// Slot
		CLFECOMMON::TCLEntityId		ShortId;

		/// Property index
		uint8						Property;

		/// The tick when the property changed, in server time
		NLMISC::TGameCycle			GameCycle;

		// These contextual additional properties must be set by hand (not by constructor)
		union
		{
			/// Position additional information (prediction & interior)
			TPositionInfo						PositionInfo;

			/// Additional information when creating an entitys
			TNewEntityInfo						NewEntityInfo;
		};
	};


	/// The states of the connection to the server (if you change them, change ConnectionStateCStr)
	enum TConnectionState
	{
		NotInitialised = 0,		// nothing happened yet
		NotConnected,			// init() called
		Authenticate,			// connect() called, identified by the login server
		Login,					// connecting to the frontend, sending identification
		Synchronize,			// connection accepted by the frontend, synchronizing
		Connected,				// synchronized, connected, ready to work
		Probe,					// connection lost by frontend, probing for response
		Stalled,				// server is stalled
		Disconnect,				// disconnect() called, or timeout, or connection closed by frontend
		Quit					// quit() called
	};

	typedef void	(*TImpulseCallback)(NLMISC::CBitMemStream &, CLFECOMMON::TPacketNumber packet, void *arg);

	static bool					LoggingMode;

public:

	/// Constructor
	CNetworkConnection();

	/// Destructor
	virtual ~CNetworkConnection();

	/// @name Connection initialisation
	//@{

	/**
	 * Inits the client connection to the front-end.
	 * \param cookie it s the cookie in string format that was passed to the exe command line (given by the nel_launcher)
	 * \param addr it s the front end address in string format that was passed to the exe command line (given by the nel_launcher)
	 */
	void			init(const std::string &cookie, const std::string &addr);

	/**
	 * Sets the cookie and front-end address, resets the connection state.
	 */
	void			initCookie(const std::string &cookie, const std::string &addr);

	/**
	 * Connects to the front-end (using or not the login system, depending on what was specified at init())
	 * \param result the message returned in case of an error
	 * Returns true if no error occured.
	 */
	bool			connect(std::string &result);


	/**
	 * Sets the callback called when	a generic impulse comes
	 */
	void			setImpulseCallback(TImpulseCallback callback, void *argument = NULL);

	//@}


	/// @name Connection management
	//@{

	/**
	 * Tells if the client is yet connected or not
	 */
	bool			isConnected();


	/**
	 * Gets the connection state
	 */
	TConnectionState	getConnectionState() const { return _ConnectionState; }


	/**
	 * Updates the whole connection with the frontend.
	 *
	 * Behaviour in login state when a firewall does not grant the sending:
	 * - When a sending is refused (error "Blocking operation interrupted")
	 * the exception EBlockedByFirewall in thrown. The first time, a time-out is armed.
	 * - In a later attempt, if the time-out expired, the function sets state to
	 * Disconnect, then throws EBlockedByFirewall.
	 *
	 * \return bool 'true' if data were sent/received.
	 */
	bool			update();


	/**
	 * Disconnects the current connection
	 */
	void			disconnect();

	//@}


	/**
	 * Quit the game till the connection is reset
	 */
	void			quit();


	/// @name Database management
	//@{

	/**
	 * Set database entry point
	 */
	void			setDataBase(CCDBNodeBranch *database);

	//@}



	/// @name Push and Send
	//@{

	/**
	 * Buffers a bitmemstream, that will be converted into a generic action, to be sent later to the server (at next update).
	 */
	void			push (NLMISC::CBitMemStream &msg);

	/**
	 * Buffers an action to be sent at next update (or later updates if network overload occurs)
	 */
	void			push(CLFECOMMON::CAction *action);

	/**
	 * Buffers a target action (set targetOrPickup to true for target, false for pick-up
	 */
	void			pushTarget(CLFECOMMON::TCLEntityId slot, LHSTATE::TLHState targetOrPickup);

	/**
	 * Send
	 */
	void			send(NLMISC::TGameCycle);

	/**
	 * Send last information without changes (only acknowedges frontend)
	 */
	void			send();

	/**
	 * Clear not acknownledged actions in sending buffer
	 */
	void			flushSendBuffer() { _Actions.clear(); }

	/**
	 * Set player reference position
	 */
//	void			setReferencePosition(const NLMISC::CVectorD &position) { _ImpulseDecoder.setReferencePosition(position); }

	//@}


	/// @name Temp methods
	// @{

	const std::vector<CChange>			&getChanges() { return _Changes; }

	void	clearChanges() { _Changes.clear(); }

	// @}


	/// @name Client time hints
	// @{
	NLMISC::TTime		getCurrentClientTime() { return _CurrentClientTime; }		// the time currently played at this frame (in the past)
	NLMISC::TGameCycle	getCurrentClientTick() { return _CurrentClientTick; }		// the tick for the current frame (also in the past)
	NLMISC::TGameCycle	getCurrentServerTick() { return _CurrentServerTick; }		// the last tick sent by the server.
	NLMISC::TTime		getMachineTimeAtTick() { return  _MachineTimeAtTick; }		// the machine time at the beginning of the current tick
	NLMISC::TTicks		getMachineTicksAtTick() { return _MachineTicksAtTick; }
	sint32				getMsPerTick() { return _MsPerTick; }
	NLMISC::TGameCycle	getSynchronize() { return _Synchronize; }
	uint32				getBestPing() { return _BestPing; }
	uint32				getPing() const { return _InstantPing; }
	NLMISC::TTime		getLCT() { return _LCT; }											// Lag compensation time
	NLMISC::TTime		getUpdateTime() { return _UpdateTime; }
	NLMISC::TTicks		getUpdateTicks() { return _UpdateTicks; }
	// Return an estimated smooth server tick. Increment only and accelerate/decelerate according to network
	sint64				getCurrentSmoothServerTick() const { return _CurrentSmoothServerTick; }
	// Convert a GameCycle to a SmoothServerTick
	sint64				convertToSmoothServerTick(NLMISC::TGameCycle t) const;
	// @}


	/// Set the Lag Compensation Time in ms (default: 1000)
	void				setLCT( NLMISC::TTime lct ) { _LCT = lct; }

	/// Allocation statistics
	void				displayAllocationStats();

	/// Get Allocation statistics
	std::string			getAllocationStats();

	/// @name Network Stats Methods
	// @{

	uint32				getSentBytes()						{ return _TotalSentBytes; }
	uint32				getPartialSentBytes()				{ uint32 ret = _PartialSentBytes; _PartialSentBytes = 0; return ret; }
	uint32				getReceivedBytes()					{ return _TotalReceivedBytes; }
	uint32				getPartialReceivedBytes()			{ uint32 ret = _PartialReceivedBytes; _PartialReceivedBytes = 0; return ret; }
	bool				getConnectionQuality()				{ return _ConnectionQuality; }
	NLMISC::TTime		getTimeSinceLastReceivedPacket()	{ return NLMISC::CTime::getLocalTime()-_LastReceivedNormalTime; }


	/// Return the average billed download rate in kbps, including all headers (UDP+IP+Ethernet)
	float				getMeanDownload() { return (_MeanDownload.mean(ryzomGetLocalTime ())+20+8+14)*0.008f; }

	/// Return the average billed upload rate in kbps, including all headers (UDP+IP+Ethernet)
	float				getMeanUpload() { return (_MeanUpload.mean(ryzomGetLocalTime ())+20+8+14)*0.008f; }

	/// Return the packet loss average
	float				getMeanPacketLoss()
	{
		NLMISC::TTime	time = ryzomGetLocalTime ();
		_MeanPackets.check(time);
		_MeanLoss.check(time);
		float	dpk = _MeanPackets.Values.empty() ? 0.0f : _MeanPackets.Values.back().second-_MeanPackets.Values.front().second+1;
		float	tloss = _MeanLoss.Content;
		return (dpk > 0.0f) ? std::min(100.0f, tloss*100.0f/dpk) : 0.0f;
	}

	/// Get total lost packets
	uint32				getTotalLostPackets() const	{ return _TotalLostPackets; }

	// @}


	/// Get the NLMISC::CEntityId from the TCLEntityId
	CLFECOMMON::TSheetId	get(CLFECOMMON::TCLEntityId id) const	{ return _PropertyDecoder.sheet(id); }

	/// Get the TCLEntityId from the NLMISC::CEntityId
	sint				get(CLFECOMMON::TSheetId id) const
	{
		TIdMap::const_iterator	it = _IdMap.find(id);
		return (it != _IdMap.end()) ? (*it).second : -1;
	}

	/// Set player's reference position
	void	setReferencePosition(const NLMISC::CVectorD &position)
	{
		H_AUTO_USE ( RZ_Client_Network_Connection_Set_Reference_Position )
		_PropertyDecoder.setReferencePosition( position );
	}

	/// Get local IP address
	const NLNET::CInetAddress&	getAddress()
	{
		return _Connection.localAddr();
	}

	/// Get socket
	NLNET::CUdpSock&			getConnection()
	{
		return _Connection.UdpSock;
	}

	/// Get userId
	uint32						getUserId()
	{
		if(_LoginCookie.isValid())
			return _LoginCookie.getUserId();
		else
			return 0xFFFFFFFF;
	}

	/// Get connection state c_string
	const char *						getConnectionStateCStr()
	{
		return ConnectionStateCStr[_ConnectionState];
	}

	/// Return the login cookie
	const NLNET::CLoginCookie&	getLoginCookie() const
	{
		return _LoginCookie;
	}

#ifdef ENABLE_INCOMING_MSG_RECORDER
	/// Return 'true' if currently recording.
	bool						isRecording() const {return _RecordIncomingMessagesOn;}
	/// Return 'true' if currently replaying.
	bool						isReplaying() const {return _ReplayIncomingMessagesOn;}

	/// Start/stop recording the incoming messages (in online mode)
	void						setRecordingMode( bool onOff, const std::string& filename = "");

	/// Start/stop replaying the incoming messages (in offline mode)
	void						setReplayingMode( bool onOff, const std::string& filename = "");
#endif

	void						decodeDiscreetProperty( NLMISC::CBitMemStream& msgin, CLFECOMMON::TPropIndex propIndex );

	const std::string			&getFrontendAddress() { return _FrontendAddress; }

protected:
	/// The current state of the connection
	TConnectionState			_ConnectionState;

	/// Connection Quality check
	bool						_ConnectionQuality;

	/// The address of the frontend service
	std::string					_FrontendAddress;

	/// The cookie for the login service
	NLNET::CLoginCookie			_LoginCookie;

	/// The UDP connection to the frontend
	NLNET::CUdpSimSock			_Connection;

	/// The receive buffer
	uint32						_ReceiveBuffer[65536];

	/// The impulse decoder
	CImpulseDecoder				_ImpulseDecoder;

	/// The callback for generic actions
	TImpulseCallback			_ImpulseCallback;

	/// The callback argument
	void						*_ImpulseArg;


	/// Position update tick queues (used for statistical interval prediction), one per slot
	std::deque<NLMISC::TGameCycle>		_PosUpdateTicks[256];

	/// Position update interval sorted sets (used for statistical interval prediction), one per slot
	std::multiset<NLMISC::TGameCycle>	_PosUpdateIntervals[256];

	/// MD5 hash keys of msg.xml and database.xml
	NLMISC::CHashKeyMD5			_MsgXmlMD5;
	NLMISC::CHashKeyMD5			_DatabaseXmlMD5;
	// if prec don't work, those may (if the server run on windows, prec won't work)
	NLMISC::CHashKeyMD5			_AltMsgXmlMD5;
	NLMISC::CHashKeyMD5			_AltDatabaseXmlMD5;


	/// @name Network statistics
	//@{

	class CMeanComputer
	{
	public:
		CMeanComputer() : MeanPeriod(2000), Content(0.0f) {}
		std::deque< std::pair<NLMISC::TTime, float> >	Values;
		uint32											MeanPeriod; // in ms
		float											Content;

		// checks all values have valid time (inside the mean period)
		void					check(NLMISC::TTime time)
		{
			while (!Values.empty() && Values.front().first < time-MeanPeriod)
			{
				Content -= Values.front().second;
				Values.pop_front();
			}
		}

		// updates the mean with a new value and time
		void					update(float value, NLMISC::TTime time)
		{
			if (!Values.empty() && Values.back().first > time)
				return;

			check(time);
			Values.push_back(std::make_pair(time, value));
			Content += value;
		}

		// gets the mean
		float					mean(NLMISC::TTime time)
		{
			check(time);
			return Content*1000.0f/(float)MeanPeriod;
		}
	};

	/// The total received length (from the beginning)
	uint32						_TotalReceivedBytes;

	/// The partial received length (since last read)
	uint32						_PartialReceivedBytes;

	/// The total sent length
	uint32						_TotalSentBytes;

	/// Partial sent length
	uint32						_PartialSentBytes;

	/// Total lost packets
	uint32						_TotalLostPackets;

	/// Mean download (payload bytes)
	CMeanComputer				_MeanDownload;

	/// Mean upload (payload bytes)
	CMeanComputer				_MeanUpload;

	/// Mean packets
	CMeanComputer				_MeanPackets;

	/// Mean lost
	CMeanComputer				_MeanLoss;

	//@}


	/// The property decoder
	CPropertyDecoder			_PropertyDecoder;

	/// The database entry
	CCDBNodeBranch				*_DataBase;


	/// @name Header message decoding
	//@{

	/// Was the header decoded for the last received message?
	bool						_DecodedHeader;

	/// The received number lastly decoded
	CLFECOMMON::TPacketNumber	_CurrentReceivedNumber;

	/// The message is in system mode
	bool						_SystemMode;

	/// Did we received a probe since last update
	bool						_ReceivedSync;

	uint						_TotalMessages;

	//@}



	/// @name Client and Server packet numbering management
	//@{

	CLFECOMMON::TPacketNumber	_CurrentSendNumber;		// number that will be used to send the next packet

	CLFECOMMON::TPacketNumber	_LastReceivedNumber;	// number of the last packet receive from the server
	uint32						_AckBitMask;			// this mask contains ack of old messages received by the server
	uint32						_LastAckBit;			// a remember of the status of the previous received packet
	NLMISC::TTime				_LastReceivedTime;		// last time the client received something from the server

	NLMISC::CBitSet				_LongAckBitField;
	CLFECOMMON::TPacketNumber	_LastAckInLongAck;

	NLMISC::TGameCycle			_LastSentCycle;

	CLFECOMMON::TPacketNumber	_LastReceivedPacketInBothModes;

	NLMISC::TTime				_LastReceivedNormalTime;	// last time the client received valid normal message from the server

	uint8						_ImpulseMultiPartNumber;

	//@}


	/// @name Client and Server time management
	//@{

	/// The stamps queues
	typedef std::deque<std::pair<sint32, NLMISC::TTime> >	TStampQueue;

	// used for lag compensation
	NLMISC::TTime				_CurrentClientTime;		// the time currently played at this frame (in the past)
	NLMISC::TGameCycle			_CurrentClientTick;		// the tick for the current frame (also in the past)
	NLMISC::TGameCycle			_CurrentServerTick;		// the last tick sent by the server.
	NLMISC::TTime				_MachineTimeAtTick;		// the machine time at the beginning of the current tick
	NLMISC::TTicks				_MachineTicksAtTick;
	sint32						_MsPerTick;
	NLMISC::TGameCycle			_Synchronize;
	uint32						_BestPing;
	uint32						_InstantPing;
	NLMISC::TTime				_LCT;					// Lag compensation time
	TStampQueue					_PacketStamps;

	NLMISC::TTime				_UpdateTime;
	NLMISC::TTicks				_UpdateTicks;
	NLMISC::TTime				_LastSentSync;

	NLMISC::TTime				_LastSendTime;

	//@}

	std::list<CLFECOMMON::CActionBlock>	_Actions;

	/// Changes since
	std::vector<CChange>		_Changes;

	// TEMP
	uint32						_DummySend;

	static bool					_Registered;

	/// @name Generic action multipart handling structures
	//@{
	struct CGenericMultiPartTemp
	{
		CGenericMultiPartTemp () : NbBlock(0xFFFFFFFF) { }
		uint32								NbBlock;
		uint32								NbCurrentBlock;
		uint32								TempSize;
		std::vector<std::vector<uint8> >	Temp;

		std::vector<bool>					BlockReceived;

		void set (CLFECOMMON::CActionGenericMultiPart *agmp, CNetworkConnection *parent);
	};

	std::vector<CGenericMultiPartTemp>	_GenericMultiPartTemp;
	//@}

	/// @name NLMISC::CEntityId handling (for gamedev)
	//@{
	class CHash
	{
	public:
		static const size_t bucket_size = 4;
		static const size_t min_buckets = 8;

		CHash() {}

		size_t	operator () (const CLFECOMMON::TSheetId &id) const { return id; }

		inline bool operator() (const CLFECOMMON::TSheetId &id1, const CLFECOMMON::TSheetId &id2) const { return (size_t)id1 < (size_t)id2; }
	};

	typedef	CHashMap<CLFECOMMON::TSheetId, CLFECOMMON::TCLEntityId, CHash>	TIdMap;

	TIdMap						_IdMap;
	//@}


	TVPNodeClient				*_VisualPropertyTreeRoot;


	/// \name Smooth ServerTick mgt.
	// @{
	sint64						_CurrentSmoothServerTick;
	NLMISC::TTime				_SSTLastLocalTime;

	void						updateSmoothServerTick();
	// @}

	void						reinit();

private:

	/// Set MsPerTick value
	void						setMsPerTick(sint32 msPerTick);


	/// Builds the CBitMemStream from the next incoming packet
	bool						buildStream(NLMISC::CBitMemStream &msgin);

	/// @name Client automaton states and actions
	//@{

	//
	void						sendSystemLogin();
	bool						stateLogin();
	NLMISC::TTime				_LatestLoginTime;

	//
	void						receiveSystemSync(NLMISC::CBitMemStream &msgin);
	void						sendSystemAckSync();
	bool						stateSynchronize();
	NLMISC::TTime				_LatestSyncTime;
	uint32						_LatestSync;

	//
	void						receiveNormalMessage(NLMISC::CBitMemStream &msgin);
	void						sendNormalMessage();
	bool						stateConnected();
	CLFECOMMON::TPacketNumber	_LastReceivedAck;
	uint						_NormalPacketsReceived;

	//
	void						receiveSystemProbe(NLMISC::CBitMemStream &msgin);
	void						sendSystemAckProbe();
	bool						stateProbe();
	std::vector<CLFECOMMON::TPacketNumber>	_LatestProbes;
	CLFECOMMON::TPacketNumber	_LatestProbe;
	NLMISC::TTime				_LatestProbeTime;

	//
	void						receiveSystemStalled(NLMISC::CBitMemStream &msgin);
	bool						stateStalled();

	//
	void						sendSystemDisconnection();

	//
	bool						stateQuit();
	void						receiveSystemAckQuit(NLMISC::CBitMemStream &msgin);
	void						sendSystemQuit();
	uint32						_QuitId;
	bool						_ReceivedAckQuit;
	NLMISC::TTime				_LatestQuitTime;

	//
	void						reset();
	void						initTicks();

	//@}

	//
	bool						decodeHeader(NLMISC::CBitMemStream &msgin, bool checkMessageNumber = true);

	//
	void						buildSystemHeader(NLMISC::CBitMemStream &msgout);

	//
	void						genericAction (CLFECOMMON::CActionGeneric *ag);
	void						genericAction (CLFECOMMON::CActionGenericMultiPart *agmp);

	//
	void						statsSend(uint32 bytes);
	void						statsReceive(uint32 bytes);

	bool						associationBitsHaveChanged( CLFECOMMON::TCLEntityId slot, uint32 associationBits )
	{
		bool res = ((uint16)associationBits != _PropertyDecoder.associationBits( slot ));
		_PropertyDecoder.associationBits( slot ) = (uint16)associationBits;
		return res;
	}

	void						decodeVisualProperties( NLMISC::CBitMemStream& msgin );

	/// Return true if there is some messages to replay (in replay mode)
	bool						dataToReplayAvailable();

	uint32						_AssociationBits;

#ifdef ENABLE_INCOMING_MSG_RECORDER
	NLMISC::COFile				_RecordedMessagesOut;

	NLMISC::CIFile				_RecordedMessagesIn;
	NLMISC::TGameCycle			_NextClientTickToReplay; // ~0 when no more message
	NLMISC::CBitMemStream		_NextMessageToReplay; // loaded at beginning of update(), read in buildStream()

	bool						_RecordIncomingMessagesOn;
	bool						_ReplayIncomingMessagesOn;

#endif

	//
	friend struct CGenericMultiPartTemp;
};


#endif // NL_NETWORK_CONNECTION_H

/* End of network_connection.h */