#ifndef NLSERVERBASE_H
#define NLSERVERBASE_H

#include "Aria.h"
#include "ArServerCommands.h"
#include "ArServerClient.h"
#include "ArServerData.h"
#include "ArNetPacket.h"
#include "ArNetPacketReceiverUdp.h"
#include "ArServerUserInfo.h"

/**
   Base server for all networking services.

   This class is the "base" server for network services. Start
   this server by calling open(), and then running the loop with run() or runAsync(),
   (or loopOnce() if it is absolutely neccesary to use your own loop; see the
   implementation of run()).
   You can then pass this object to the various "ArServerInfo", "ArServerHandler", and ArServerMode classes. 

   Data request callbacks are added to an ArServerBase object by calling
   addData().

   This class takes care of locking in its own function calls so you
   don't need to worry about locking and unlocking the class before
   you do things.

    The counterpart of this class for clients is ArClientBase.

   You can require user names and passwords for making connections to
   the server, so each user has a set of permissions for different
   command groups. To do this, load configuration from a userInfo file 
   with loadUserInfo().  You can log the
   user info (and what commands users have) with logUserInfo().  You can
   log the command groups with logCommandGroups() or
   logCommandGroupsToFile().  For a description of the file see
   ArServerUserInfo.  There is also an example in
   <code>ArNetworking/examples/serverDemo.userInfo</code>.

   In addition to the user and password requirement you can set a server "key"
   (a special string of text) required (in addition to user and password)
   to access the server with setServerKey(), though this is ONLY used if
   user and password information is requied (so that older clients can
   connect if there's no user and password information required).  

   The way that the passwords are transmitted across the network is this:
   Upon connection the server sends a randomly generated (for that
   connection) string of text to the client which we'll call the
   passwordKey.  The client then combines the serverKey (a string which must be
   known to connect to the server at all), the password, and the
   passwordKey (that string that is generated uniquely for each
   connection) and comes up with an md5 of that string and sends that
   md5 value across the line.  The server then compares the md5 from
   the client with the md5 generated with the correct information on
   the server... if they match the password is good, otherwise it
   rejects the connection.  This is NOT perfect security but should be
   much better then plaintext.  If you care about perfect security
   then use an ssh tunnel with something like PUTTY from the machine
   the client is on to the machine the server is on with an openssh
   server set up (this'll likely even work in windows with cygwin) and
   set up a firewall on the machine the server is on that disallows
   port the server port connection from outside and only allows ssh
   from outside (and get a book or three and read those).

   This class now handles identifiers for the ArServerClients... all
   server bases will let a client set a self identifier string, and a
   here goal... those may be used by any server.  Messages can be sent
   to just server clients that match that message (so that its easier
   to send messages to people who sent commands).  

   Master servers (the main connection server base on the central
   server) can also give each connection an id number (with
   identGetConnectionID).  Things that then connect to the other
   server bases on a master server (slave servers) should then set
   their ConnectionID (with identSetConnectionID) so that things can
   relate the different connections together.

   @sa ArServerSimpleOpener
   @sa ArClientBase
   @sa ArServerMode
**/

class ArServerBase: public ArASyncTask
{
public:
  /// Constructor
  AREXPORT ArServerBase(
	  bool addAriaExitCB = true, 
	  const char *serverName = "",
	  bool addBackupTimeoutToConfig = true,
	  const char *backupTimeoutName = "RobotToClientTimeoutInMins",
	  const char *backupTimeoutDesc = "The amount of time the central server can go without sending a packet to the robot successfully (when there are packets to send).  A number less than 0 means this won't happen.  The time is in minutes but takes doubles (ie .5) (5 seconds is used if the value is positive, but less than that amount)",
	  bool masterServer = false, bool slaveServer = false,
	  bool logPasswordFailureVerbosely = false, 
	  bool allowSlowPackets = true, bool allowIdlePackets = true,
	  int maxClientsAllowed = -1);

  /// Destructor
  AREXPORT virtual ~ArServerBase();
  
  /// Opens the server to accept new client connections
  AREXPORT bool open(unsigned int port, const char *openOnIP = NULL,
		     bool tcpOnly = false);
  /// Closes the server
  AREXPORT void close(void);
  /// Runs the server loop once
  AREXPORT void loopOnce(void);

  /// Adds a callback to be called when requests for some data are recieved.
  AREXPORT bool addData(const char *name, const char *description,
			ArFunctor2<ArServerClient *, ArNetPacket *> *functor,
			const char *argumentDescription,
			const char *returnDescription,
			const char *commandGroup = NULL,
			const char *dataFlags = NULL);

  /// Loads up a set of usernames/passwords/permissions from a file
  AREXPORT bool loadUserInfo(const char *fileName, 
			     const char *baseDirectory = "");
  
  /// Logs the users and their groups
  AREXPORT void logUserInfo(void);

  /// Logs the groups and commands in those groups
  AREXPORT void logCommandGroups(void);  

  /// Logs the groups and commands in those groups to a file
  AREXPORT void logCommandGroupsToFile(const char *fileName);  

  /// Logs the command group names and command group descriptions for those names
  AREXPORT void setGroupDescription(const char *GrpName, const char *GrpDesc);  

  /// Logs the command group names and descriptions
  AREXPORT void logGroupDescriptions(void);  

  /// Logs the command group names and descriptions to a file
  AREXPORT void logGroupDescriptionsToFile(const char *fileName);  

  /// Sets a 'key' needed to access the server through any account
  AREXPORT void setServerKey(const char *serverKey);


  /// Tells the server to reject connectings because we're usinga central server
  AREXPORT void rejectSinceUsingCentralServer(
	  const char *centralServerIPString);

  /// Enforces that the server is using this protocol version
  AREXPORT void enforceProtocolVersion(const char *protocolVersion);

  /// Enforces that the robots that connect are this type
  AREXPORT void enforceType(ArServerCommands::Type type);

  /// Sets the backup timeout
  AREXPORT void setBackupTimeout(double timeoutInMins);

  /// Runs the server in this thread
  AREXPORT virtual void run(void);
  
  /// Runs the server in its own thread
  AREXPORT virtual void runAsync(void);

  /// Logs the connections
  AREXPORT void logConnections(const char *prefix = "");
  
  /// Gets the number of clients connected
  AREXPORT int getNumClients(void);

  /// Gets the number of a command
  AREXPORT unsigned int findCommandFromName(const char *command);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketTcp(ArNetPacket *packet, const char *name);
  
  /// Broadcasts packets to any client wanting this data that matches the ID
  AREXPORT bool broadcastPacketTcpToMatching(
	  ArNetPacket *packet, const char *name, 
	  ArServerClientIdentifier identifier, bool matchConnectionID = false);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketTcpWithExclusion(
	  ArNetPacket *packet, const char *name, 
	  ArServerClient *excludeClient, bool match = false, 
	ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
	bool matchConnectionID = false);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketUdp(ArNetPacket *packet, const char *name);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketUdpWithExclusion(
        ArNetPacket *packet, const char *name, ArServerClient *excludeClient,
	bool match = false, 
	ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
	bool matchConnectionID = false);

  /// Broadcasts packets to any client wanting this data that matches
  AREXPORT bool broadcastPacketUdpToMatching(
	  ArNetPacket *packet, const char *name, 
	  ArServerClientIdentifier identifier, bool matchConnectionID);
 
  /// Delays the current thread by the specified msecs, for use after packet sent.
  AREXPORT void sleepAfterSend(int msecDelay);

  /// Sees if we have any idle processing pending (idle packets or callbacks)
  AREXPORT bool idleProcessingPending(void);

  /// Processes udp packets
  AREXPORT void processPacket(ArNetPacket *packet, 
			      struct sockaddr_in *sin);

  /// Sends Udp packets
  AREXPORT bool sendUdp(ArNetPacket *packet, 
			struct sockaddr_in *sin);
  
  /// Logs the tracking on each client (how many packets and bytes were sent)
  AREXPORT void logTracking(bool terse = true);

  /// Clears the tracking on all the clients (resets counters)
  AREXPORT void resetTracking(void);

  // the function for the thread
  AREXPORT virtual void * runThread(void *arg);

  /// Gets the tcp port we're using
  AREXPORT unsigned int getTcpPort(void);
  /// Gets the udp port we're using
  AREXPORT unsigned int getUdpPort(void);
  /// Gets the IP we're opening on (or NULL if there's none)
  AREXPORT const char *getOpenOnIP(void);

  /// Add a callback to be called at every cycle
  AREXPORT void addCycleCallback(ArFunctor* functor);

  /// Remove a callback to be called at every cycle
  AREXPORT void remCycleCallback(ArFunctor* functor);

  /// Add a callback to be invoked when a client has been removed (but before it is deleted)
  AREXPORT void addClientRemovedCallback(ArFunctor1<ArServerClient *> *functor);
  /// Remove the callback invoked when a client has been removed
  AREXPORT void remClientRemovedCallback(ArFunctor1<ArServerClient *> *functor);
  /// Makes a new serverclient from this socket (for switching, needs no password since this was an outgoing connection to a trusted server)
  AREXPORT ArServerClient *makeNewServerClientFromSocket(
	  ArSocket *socket, bool overrideGeneralReject);
  /// Gets the user info we're using (mostly internal for switching)
  AREXPORT const ArServerUserInfo *getUserInfo(void) const;
  /// Sets the user info we'll use (mostly internal for switching)
  AREXPORT void setUserInfo(const ArServerUserInfo *userInfo);
  /// Adds a callback for requests in a more advanced manner, for internal use
  AREXPORT bool addDataAdvanced(
	  const char *name, const char *description,
	  ArFunctor2<ArServerClient *, ArNetPacket *> *functor,
	  const char *argumentDescription, const char *returnDescription,
	  const char *commandGroup = NULL, const char *dataFlags = NULL, 
	  unsigned int commandNumber = 0,
	  ArFunctor2<long, unsigned int> *requestChangedFunctor = NULL, 
	  ArRetFunctor2<bool, ArServerClient *, ArNetPacket *> 
	  *requestOnceFunctor = NULL);
  /// Sets the data flags to add in addition to those passed in
  AREXPORT void setAdditionalDataFlags(const char *additionalDataFlags);
  /// Gets the frequncy a command is requested (mostly internal)
  AREXPORT long getFrequency(unsigned int command, 
			     bool internalCall = false);
  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketTcpByCommand(
	  ArNetPacket *packet, unsigned int command);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketTcpByCommandWithExclusion(
	  ArNetPacket *packet, unsigned int command,
	  ArServerClient *excludeClient, bool match = false, 
	  ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
	  bool matchConnectionID = false);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketUdpByCommand(
	  ArNetPacket *packet, unsigned int command);

  /// Broadcasts packets to any client wanting this data
  AREXPORT bool broadcastPacketUdpByCommandWithExclusion(
	  ArNetPacket *packet, unsigned int command,
	  ArServerClient *excludeClient, bool match = false, 
	  ArServerClientIdentifier identifier = ArServerClientIdentifier(), 
	  bool matchConnectionID = false);
  
  /// Closes connection with a given connection ID
  AREXPORT void closeConnectionID(ArTypes::UByte4 idNum);
  /// Returns if a command has a data flag
  AREXPORT bool dataHasFlag(const char *name, const char *dataFlag);
  /// Returns if a command has a data flag by command number
  AREXPORT bool dataHasFlagByCommand(unsigned int command, 
				     const char *dataFlag);
  /// Sets debug logging 
  AREXPORT void setDebugLogging(bool debugLogging = false);
  /// Gets if this is using debug logging 
  AREXPORT bool getDebugLogging(void);
  /// Gets the most clients we've had connected
  AREXPORT int getMostClients(void); 

  /// Gets if we're allowing idle packets
  AREXPORT bool allowingIdlePackets(void);

  /// Adds an idle callback to be called once next time the robot is idle
  AREXPORT bool addIdleSingleShotCallback(ArFunctor *functor);

  /// Internal, Sees if we have any slow packets we are waiting to process
  AREXPORT bool hasSlowPackets(void);

  /// Internal, Sees if we have any idle packets we are waiting to process
  AREXPORT bool hasIdlePackets(void);

  /// Internal, Sees if we have any idle callbacks we are waiting to process
  AREXPORT bool hasIdleCallbacks(void);
  
  /// Internal, sets the maximum number of clients 
  AREXPORT void internalSetNumClients(int numClients);

  /// Adds a callback when we switch states while starting
  AREXPORT void addTooManyClientsCB(
	  ArFunctor1<const char *> *functor, int position = 50) 
    { myTooManyClientsCBList.addCallback(functor, position); }
  /// Removes a callback when we switch to running
  AREXPORT void remTooManyClientsCB(ArFunctor1<const char *> *functor)
    { myTooManyClientsCBList.remCallback(functor); }

  /// Internal call that sets the default frequency as a helper for forwarding (if it's faster than the current default)
  AREXPORT bool internalSetDefaultFrequency(const char *command, int frequency);

  /// Internal call to lockup the server (for testing)
  AREXPORT void internalLockup(void);
protected:

  /// The command get the ConnectionID of this server client connection
  AREXPORT void identGetConnectionID(ArServerClient *client, 
				     ArNetPacket *packet);
  /// The command set the ConnectionID of this server client connection
  AREXPORT void identSetConnectionID(ArServerClient *client, 
				     ArNetPacket *packet);
  /// The command set the self identifier of this server client connection
  AREXPORT void identSetSelfIdentifier(ArServerClient *client, 
				       ArNetPacket *packet);
  /// The command set the here goal of this server client connection
  AREXPORT void identSetHereGoal(ArServerClient *client, ArNetPacket *packet);
  

  /// Handles the "startRequestTransaction" packet, and updates the state of the client. 
  /**
   *  "Request transactions" are used to indicate that a sequence of request /
   *  reply packets must be completed before idle processing can proceed. 
   *  Any "startRequestTransaction" MUST be followed by an "endRequestTransaction".
   *
   *  The packets are meant to be used sparingly. They are currently only used
   *  when the Central Server is determining whether the map file needs to 
   *  be downloaded to the client robot. 
   * 
   *  @param client the ArServerClient* that sent the request; updated to indicate
   *  a new transaction is in progress
   *  @param packet the ArNetPacket* that contains the request (no additional data)
  **/
  AREXPORT void handleStartRequestTransaction(ArServerClient *client, 
                                              ArNetPacket *packet);

  /// Handles the "endRequestTransaction" packet, and updates the state of the client. 
  /**
   *  @param client the ArServerClient* that sent the request; updated to indicate
   *  that a transaction has completed
   *  @param packet the ArNetPacket* that contains the request (no additional data)
   *  @see handleStartRequestTransaction
  **/
	AREXPORT void handleEndRequestTransaction(ArServerClient *client, 
                                            ArNetPacket *packet);

  /// Returns the number of request transactions in progress for all connected clients.
  /**
   * @see handleStartRequestTransaction
  **/
  AREXPORT int getRequestTransactionCount();


  /// accepts new sockets and moves them into the client list
  void acceptTcpSockets(void);
  /// Internal function for server/client switching
  AREXPORT ArServerClient *finishAcceptingSocket(
	  ArSocket *socket, bool skipPassword = false, 
	  bool overrideGeneralReject = false);
  bool processFile(void);

  /// callback for our slow idle thread, which is down below...
  /// The command that returns if there is idle processing to do
  AREXPORT void netIdleProcessingPending(ArServerClient *client, 
					 ArNetPacket *packet);

  void slowIdleCallback(void);
  

  
  std::string myServerName;
  std::string myLogPrefix;
  ArMutex myDataMutex;
  ArMutex myClientsMutex;
  ArMutex myCycleCallbacksMutex;
  bool myTcpOnly;
  bool myDebugLogging;
  ArLog::LogLevel myVerboseLogLevel;

  unsigned int myTcpPort;
  unsigned int myUdpPort;
  std::string myOpenOnIP;
  // our mapping of the ints to the serverData
  std::map<unsigned int, ArServerData *> myDataMap;
 /// our mapping of the group names
  std::map<std::string, std::string> myGroupDescription;			

  // default frequency (helper for forwarding)
  std::map<unsigned int, int> myDefaultFrequency;

  int myRejecting;
  std::string myRejectingString;

  std::string myEnforceProtocolVersion;
  ArServerCommands::Type myEnforceType;

  double myBackupTimeout;
  bool myNewBackupTimeout;
  ArMutex myBackupTimeoutMutex;

  ArCallbackList1<const char *> myTooManyClientsCBList;

  // the number we're on for the current data
  unsigned int myNextDataNumber;
  std::string myAdditionalDataFlags;
  bool myOpened;
  std::list<ArServerClient *> myClients;
  ArNetPacketReceiverUdp myUdpReceiver;
  ArFunctor2C<ArServerBase, ArNetPacket *, struct sockaddr_in *> myProcessPacketCB;
  ArRetFunctor2C<bool, ArServerBase, ArNetPacket *, struct sockaddr_in *> mySendUdpCB;  
  ArSocket myTcpSocket;
  ArSocket myUdpSocket;
  std::list<ArFunctor*> myCycleCallbacks;
  std::list<ArFunctor1<ArServerClient *> *> myClientRemovedCallbacks;

  ArTypes::UByte4 myConnectionNumber;

  ArSocket myAcceptingSocket;
  
  int myMostClients;
  bool myUsingOwnNumClients;
  int myNumClients;
  

  unsigned int myLoopMSecs;

  ArMutex myAddListMutex;
  std::list<ArServerClient *> myAddList;
  ArMutex myRemoveSetMutex;
  std::set<ArServerClient *> myRemoveSet;

  const ArServerUserInfo *myUserInfo;
  bool myLogPasswordFailureVerbosely;
  std::string myServerKey;
  ArFunctorC<ArServerBase> myAriaExitCB;
  ArRetFunctor2C<long, ArServerBase, unsigned int, bool> myGetFrequencyCB;
  ArRetFunctorC<bool, ArServerBase> myProcessFileCB;

  ArFunctor2C<ArServerBase, ArServerClient *, 
	      ArNetPacket *> myIdentGetConnectionIDCB;
  ArFunctor2C<ArServerBase, ArServerClient *, 
	      ArNetPacket *> myIdentSetConnectionIDCB;
  ArFunctor2C<ArServerBase, ArServerClient *, 
	      ArNetPacket *> myIdentSetSelfIdentifierCB;
  ArFunctor2C<ArServerBase, ArServerClient *, 
	      ArNetPacket *> myIdentSetHereGoalCB;

  ArFunctor2C<ArServerBase, ArServerClient *, 
	                          ArNetPacket *> myStartRequestTransactionCB;
  ArFunctor2C<ArServerBase, ArServerClient *, 
	                          ArNetPacket *> myEndRequestTransactionCB;

  ArFunctor2C<ArServerBase, ArServerClient *, 
	      ArNetPacket *> myIdleProcessingPendingCB;

  bool myAllowSlowPackets;
  bool myAllowIdlePackets;

  int myMaxClientsAllowed;

  ArMutex myProcessingSlowIdleMutex;

  
  class SlowIdleThread : public ArASyncTask
  {
  public:
    /// Constructor
    SlowIdleThread(ArServerBase *serverBase);
    /// Destructor
    virtual ~SlowIdleThread(void);
    virtual void *runThread(void *arg);
  protected:
    ArServerBase *myServerBase;
  };
  friend class ArServerBase::SlowIdleThread;

  SlowIdleThread *mySlowIdleThread;
  bool myHaveSlowPackets;
  bool myHaveIdlePackets;

  bool myLastIdleProcessingPending;

  ArMutex myIdleCallbacksMutex;
  bool myHaveIdleCallbacks;
  std::list<ArFunctor *> myIdleCallbacks;
};

#endif