#ifndef ARMAPCHANGER_H
#define ARMAPCHANGER_H

#include "ariaTypedefs.h"
#include "ariaUtil.h"

#include <list>

#include <ArMapInterface.h>
#include <ArMapUtils.h>
#include <ArMutex.h>

#include "ArNetPacket.h"
#include "ArCentralForwarder.h"
#include "ArClientBase.h"
#include "ArClientSwitchManager.h"
#include "ArServerBase.h"
#include "ArServerClient.h"
#include "ArMapChanger.h"

/// Utility class used to apply incremental changes to an Aria map.
/**
 *  ArMapChanger is a helper class that can send and receive ArMapChangeDetails
 *  over the network and apply them to an associated Aria map.  An instance of 
 *  ArMapChanger must be instantiated on both the client and the server side.
 *  (Note that there are two different versions of the constructors for this.)
 * 
 * TODO: Possibly subclass this into ArClientMapChanger and ArServerMapChanger?
 * 
 * @see ArMapChangeDetails
**/
class ArMapChanger 
{
public:
  
  /// Reply status for a map change request
  enum MapChangeReplyType {
    CHANGE_FAILED = 0,
    CHANGE_SUCCESS = 10
  };

  /// Name of the network packet that contains the incremental map changes.
  static const char *PROCESS_CHANGES_PACKET_NAME;

  /// Name of the network packet that contains incremental map changes originated by the robot.
  static const char *PROCESS_ROBOT_CHANGES_PACKET_NAME;

  /// Name of a network packet that is broadcast when the map is being changed.
  static const char *CHANGES_IN_PROGRESS_PACKET_NAME;

  /// Name of the network packet that is broadcast when map changes originated by the robot are complete.
  static const char *ROBOT_CHANGES_COMPLETE_PACKET_NAME;

  // ---------------------------------------------------------------------------
  // Constructors, Destructor
  // ---------------------------------------------------------------------------

  /// Constructs a server map changer.
  /**
   * The map changer will automatically apply the received map change details 
   * to the given map.
   * 
   * @param server the ArServerBase * that receives the network packets
   * @param map the ArMapInterface * to which to apply the map changes
  **/
  AREXPORT ArMapChanger(ArServerBase *server, 
						            ArMapInterface *map);

  /// Constructs a server map changer that can also originate changes (to the EM).
  /**
   * The map changer will automatically apply the received map change details 
   * to the given map.
   * 
   * @param clientSwitch the ArClientSwitchManager * that communicates to the EM
   * @param server the ArServerBase * that receives the network packets
   * @param map the ArMapInterface * to which to apply the map changes
  **/
  AREXPORT ArMapChanger(ArClientSwitchManager *clientSwitch,
                        ArServerBase *server, 
						            ArMapInterface *map);


  /// Constructs a client map changer.
  /**
   * The map changer will send map change details to the server.  The application
   * must request this by calling sendMapChanges.
   *
   * @param client the ArClientBase * which is used to send the map change details
   * @param infoNames the list of info names included in the map
  **/
  AREXPORT ArMapChanger(ArClientBase *client, 
                        const std::list<std::string> &infoNames);
  
  /// Constructs a stand-alone map changer that will apply changes to the given map.
  /**
   * This method is primarily used for debugging.
   *
   * @param map the ArMapInterface * to which to apply the map changes
  **/
  AREXPORT ArMapChanger(ArMapInterface *map);

  /// Destructor
  AREXPORT virtual ~ArMapChanger();
  
  // ---------------------------------------------------------------------------
  // Main Methods
  // ---------------------------------------------------------------------------

  /// Sends the given map changes from the client to the server.
  AREXPORT virtual bool sendMapChanges(ArMapChangeDetails *changeDetails);
  
  /// Sends the given map changes from the robot to the central server.
  AREXPORT virtual bool sendRobotMapChanges(ArMapChangeDetails *changeDetails);

  /// Applies the given map changes received from the client to the associated Aria map.
  AREXPORT virtual bool applyMapChanges(ArMapChangeDetails *changeDetails);

  /// Transmits the given map change packet list from the client to the server.
  AREXPORT virtual bool sendPacketList(const std::list<ArNetPacket *> &packetList);
 
  /// Transmit the given map change packet list from the robot to the central server. 
  AREXPORT virtual bool sendRobotPacketList(const std::list<ArNetPacket *> &packetList);

  // ---------------------------------------------------------------------------
  // Callback Methods
  // ---------------------------------------------------------------------------

  /// Adds a callback to be invoked after the map has been changed on the server.
  /**
   * This method is primarily used on the central server.  After the map changes
   * are successfully applied to its map, they are propagated to all of the 
   * connected robots.
  **/
  AREXPORT virtual bool addChangeCB
                          (ArFunctor2<ArServerClient *, 
                                      std::list<ArNetPacket *> *> *functor);

  /// Removes a callback from the map change list.
  AREXPORT virtual bool remChangeCB
                          (ArFunctor2<ArServerClient *, 
                                      std::list<ArNetPacket *> *> *functor);
  
  /// Adds a callback to be invoked after the remote reply has been received.
  /**
   * This method is primarily used on the robot.  After the ARCL originated 
   * changes have been applied by the Enterprise Manager, this callback list
   * is invoked for other interested parties.
  **/
  AREXPORT virtual bool addRobotChangeReplyCB
                          (ArFunctor2<ArServerClient *, ArNetPacket *>  *functor);

  /// Removes a callback from the remote reply list.
  AREXPORT virtual bool remRobotChangeReplyCB
                          (ArFunctor2<ArServerClient *, ArNetPacket *>  *functor);

  /// Adds a callback to be invoked before the map file is written.
  /**
   * This method is primarily used to temporarily make the server's directory
   * writeable, if necessary.
  **/
  AREXPORT virtual void addPreWriteFileCB(ArFunctor *functor,
                                          ArListPos::Pos position = ArListPos::LAST);

  /// Removes a callback from the pre-write file list.
  AREXPORT virtual void remPreWriteFileCB(ArFunctor *functor);

  /// Adds a callback to be invoked after the map file has been written.
  /**
   * This method is primarily used to restore the server's directory write status,
   * if necessary.
  **/
  AREXPORT virtual void addPostWriteFileCB(ArFunctor *functor,
                                           ArListPos::Pos position = ArListPos::LAST);

  /// Removes a callback from the post-write file list.
  AREXPORT virtual void remPostWriteFileCB(ArFunctor *functor);

// -----------------------------------------------------------------------------

protected:

  /// Indicates the current stage of the map change network packets.
  enum MapChangeCommand {
    START_CHANGES    = 0, ///< First packet that contains changes to be applied to the map
    CONTINUE_CHANGES = 1, ///< Request to continue applying changes to the map
    FINISH_CHANGES   = 2, ///< Last packet that contains changes to be applied to the map
    CANCEL_CHANGES   = 3, ///< Cancel the request to change the map
    LAST_CHANGE_COMMAND = CANCEL_CHANGES ///< Last value in the enumeration
  };

  /// Type of data contained in the map change network packet
  enum MapChangeDataType {
    NO_CHANGE = 0,       ///< No change data
    SUMMARY_DATA = 1,    ///< Summary data, e.g. min/max pos, number of points
    INFO_DATA = 2,       ///< Any of the info data, e.g. MapInfo, RouteInfo
    SUPPLEMENT_DATA = 3, ///< Miscellaneous supplemental data such as origin lat/long/alt
    OBJECTS_DATA = 4,    ///< Map objects, i.e. Cairn lines
    POINTS_DATA = 5,     ///< Map data points
    LINES_DATA = 6,      ///< Map data lines
    LAST_CHANGE_DATA_TYPE = LINES_DATA ///< Last value in the enumeration
  }; 

  /// Miscellaneous constants
  enum {
    CHANGE_DATA_TYPE_COUNT = LAST_CHANGE_DATA_TYPE + 1,
    CHANGE_COMMAND_COUNT = LAST_CHANGE_COMMAND + 1,
    MAX_POINTS_IN_PACKET = 1000,
    MAX_LINES_IN_PACKET = 500
  };


  // ---------------------------------------------------------------------------
  // Packet Handlers
  // ---------------------------------------------------------------------------

  /// Server handler for packets that contain map change details.
  AREXPORT virtual void handleChangePacket(ArServerClient *client, 
                                           ArNetPacket *packet);
  
  AREXPORT virtual void handleRobotChangeReplyPacket(ArServerClient *client, 
                                                     ArNetPacket *packet);

  /// Client handler for the results of applying the map changes on the server. 
  AREXPORT virtual void handleChangeReplyPacket(ArNetPacket *packet);
  
  /// Client handler for the map-changes-in-progress broadcast packet
  AREXPORT virtual void handleChangesInProgressPacket(ArNetPacket *packet);

  /// Client handler for the server's idle-processing-pending broadcast packet
  AREXPORT virtual void handleIdleProcessingPacket(ArNetPacket *packet);

  /// Client handler for when the robot disconnects or is shutdown.
  AREXPORT virtual void handleClientShutdown();

protected:

  // ---------------------------------------------------------------------------
  // Helper Methods
  // ---------------------------------------------------------------------------
  
  // bool applyMapChanges(std::list<ArNetPacket*> &packetList);

  /// Applies all scan data changes that are contained in the given change details.
  /**
   * Scan data include summary data, map data points, and map data lines.
   * If the map contains scan data for multiple sources, then this method 
   * applies all of the applicable changes.
   * 
   * An Aria map must have been previously associated with the map changer.
  **/
  bool applyScanChanges(ArMapChangeDetails *changeDetails);

  /// Applies scan data changes for the specified scan type.
  /**
   * @param changeDetails the ArMapChangeDetails * that describes how the map should
   * be modified; must be non-NULL
   * @param scanType the char * identifier of the scan type to be updated
   * @param parser the ArFileParser used to parse the changeDetails
  **/
  bool applyScanChanges(ArMapChangeDetails *changeDetails,
                        const char *scanType,
                        ArFileParser &parser);

  /// Applies the given map changes to the supplemental data in the map.
  /**
   * @param changeDetails the ArMapChangeDetails * that describes how the map should
   * be modified; must be non-NULL
  **/
  bool applySupplementChanges(ArMapChangeDetails *changeDetails);

  /// Applies the given map changes to the object data in the map.
  /**
   * @param changeDetails the ArMapChangeDetails * that describes how the map should
   * be modified; must be non-NULL
  **/
  bool applyObjectChanges(ArMapChangeDetails *changeDetails);

  /// Applies the given map changes to the info data in the map.
  /**
   * @param changeDetails the ArMapChangeDetails * that describes how the map should
   * be modified; must be non-NULL
  **/
  bool applyInfoChanges(ArMapChangeDetails *changeDetails);

  /// Determines whether the two given map objects are the same object.
  /**
   * If the objects have a name, then the name must be identical.  Otherwise, the type
   * and position must be the same.
  **/
  bool isMatchingObjects(ArMapObject *obj1, 
                         ArMapObject *obj2);
                         //ArMapChangeDetails *changeDetails);

  /// Creates a list of network packets for the given map change details.
  bool convertChangeDetailsToPacketList(ArMapChangeDetails *changeDetails,
                                        std::list<ArNetPacket *> *packetListOut,
                                        bool isRelay = false);

  /// Unpacks the given network packet list and populates the given map change details.
  bool convertPacketListToChangeDetails(std::list<ArNetPacket *> &packetList,
                                        ArMapChangeDetails *changeDetailsOut);
                                        
  /// Creates network packets for the specified map change data and adds them to the given list.
  /**
   * @param dataType the MapChangeDataType that specifies which map data is to be added
   * @param changeType the MapLineChangeType that specifies the type of map change (lines
   * added or deleted)
   * @param scanType the char * identifier of the scan source to add; valid only when 
   * dataType is SUMMARY_DATA
   * @param extra an optional const char * identifier that clarifies which data to add; 
   * when dataType is INFO_DATA, this is the info name; otherwise, ignored
   * @param fileLineSet the ArMapFileLineSet * component of the map change details that
   * is to be converted to network packets
   * @param packetListOut the list of ArNetPackets to which new packets are added
  **/
  bool addFileLineSetPackets(MapChangeDataType dataType, 
                             ArMapChangeDetails::MapLineChangeType changeType,
                             const char *scanType,
                             const char *extra,
                             ArMapFileLineSet *fileLineSet,
                             std::list<ArNetPacket *> *packetListOut);

  /// Inserts header information into the given network packet.
  /**
   * @param command the MapChangeCommand that specifies which command identifier to add to this packet
   * @param dataType the MapChangeDataType that specifies which map data is to be added
   * @param changeType the MapLineChangeType that specifies the type of map change (lines
   * added or deleted)
   * @param scanType the char * identifier of the scan source to add; valid only when 
   * dataType is SUMMARY_DATA
   * @param packet the ArNetPacket * to be modified; must be non-NULL
  **/
  void addHeaderToPacket(MapChangeCommand command,
                         MapChangeDataType dataType, 
                         ArMapChangeDetails::MapLineChangeType changeType,
                         const char *scanType,
                         ArNetPacket *packet);

  /// Creates network packets for the specified file line group and adds them to the given list.
  bool addGroupToPacketList(MapChangeDataType dataType, 
                            ArMapChangeDetails::MapLineChangeType changeType,
                            const char *scanType,
                            ArMapFileLineGroup &group,
                            std::list<ArNetPacket *> *packetListOut);

  /// Creates network packets for the specified file line and adds them to the given list.
  bool addFileLineToPacketList(MapChangeDataType dataType, 
                               ArMapChangeDetails::MapLineChangeType changeType,
                               const char *scanType,
                               const ArMapFileLine &fileLine,
                               std::list<ArNetPacket *> *packetListOut);

  /// Creates network packets for the given map data points and adds them to the given list.
  bool addPointsPackets(ArMapChangeDetails::MapLineChangeType changeType,
                        const char *scanType,
                        std::vector<ArPose> *pointList,
                        std::list<ArNetPacket *> *packetListOut);

  /// Creates network packets for the given map data lines and adds them to the given list.
  bool addLinesPackets(ArMapChangeDetails::MapLineChangeType changeType,
                       const char *scanType,
                       std::vector<ArLineSegment> *lineSegmentList,
                       std::list<ArNetPacket *> *packetListOut);

  /// Unpacks the header data from the given network packet.
  /**
   * @param packet the ArNetPacket * from which to extract the header information;
   * must be non-NULL
   * @param commandOut the MapChangeCommand * extracted from the packet
   * @param origMapIdOut the original ArMapId * extracted from the packet
   * @param newMapIdOut the optional new ArMapId * extracted from the packet
   * @param dataTypeOut the optional MapChangeDataType * extracted from the packet
   * @param changeTypeOut the optional MapLineChangeType * extracted from the packet
   * @param scanTypeOut the optional std::string * extracted from the packet
   * @return bool true if all of the header information was succesfully extracted;
   * false, otherwise
  **/
  bool unpackHeader(ArNetPacket *packet,
                    MapChangeCommand *commandOut,
                    ArMapId *origMapIdOut,
                    ArMapId *newMapIdOut = NULL,
                    MapChangeDataType *dataTypeOut = NULL,
                    ArMapChangeDetails::MapLineChangeType *changeTypeOut = NULL,
                    std::string *scanTypeOut = NULL);

  /// Unpacks the specified file line set from the given network packet.
  /**
   * The file line set is added to the given change details.
  **/
  bool unpackFileLineSet(ArNetPacket *packet,
                         MapChangeDataType dataType, 
                         ArMapChangeDetails::MapLineChangeType changeType,
                         const char *scanType,
                         int *numGroups,
                         int *numChildren,
                         ArMapChangeDetails *changeDetails);

  /// Unpacks the map data points for the specified scan from the given network packet.
  /**
   * The data points are added to the given change details.
  **/
  bool unpackPoints(ArNetPacket *packet,
                    ArMapChangeDetails::MapLineChangeType changeType,
                    const char *scanType,
                    int *numPoints,
                    ArMapChangeDetails *changeDetails);

  /// Unpacks the map data lines for the specified scan from the given network packet.
  /**
   * The data lines are added to the given change details.
  **/
  bool unpackLines(ArNetPacket *packet,
                   ArMapChangeDetails::MapLineChangeType changeType,
                   const char *scanType,
                   int *numLines,
                   ArMapChangeDetails *changeDetails);

  /// Resets all of the network packets in the given list so that they can be read again.
  void resetPacketList(std::list<ArNetPacket*> *packetList);

  /// Waits for a reply from the server.
  /**
   * If a reply is not received within 30 seconds, this method will timeout and return
   * false.
   * 
   * @return bool true if the reply was received; false otherwise
  **/
  bool waitForReply(ArTime &started);
  
  bool waitForCentralServerReply(ArTime &started);

  /// Determines whether idle processing is pending on the server.
  bool isIdleProcessingPending();
  
  /// Adds the given functor to the given callback list.
  AREXPORT void addToCallbackList(ArFunctor *functor,
                                  ArListPos::Pos position,
                                  std::list<ArFunctor*> *cbList);

  /// Removes the given functor from the given callback list.
  AREXPORT void remFromCallbackList(ArFunctor *functor,
                                    std::list<ArFunctor*> *cbList);

private:
  /// Disabled copy constructor
  ArMapChanger(const ArMapChanger &other);

  /// Disabled assignment operator
  ArMapChanger &operator=(const ArMapChanger &other);

protected:

  /// Accumulates the packet list that describes map changes received from a specified client.
  struct ClientChangeInfo
  {
  public:
    /// Constructor for changes received from a client
    ClientChangeInfo(ArServerClient *client);
   
    /// Constructor for changes received from a robot on the CS 
    ClientChangeInfo(ArCentralForwarder *forwarder);

    /// Destructor
    ~ClientChangeInfo();

    /// Adds the given packet to the list
    void addPacket(ArNetPacket *packet);

    /// Server client which sent the map changes...
    ArServerClient *myClient;

    /// Or the forwarder that sent the map changes    
    ArCentralForwarder *myForwarder;

    /// Time at which the first packet in this list was received
    ArTime myStartTime;
    /// Time at which the most recent packet in this list was received
    ArTime myLastActivityTime;
    /// List of network packets received from the client for these map changes
    std::list<ArNetPacket *> myPacketList;
  }; // end struct ClientChangeInfo


  /// Aria map currently in use
  ArMapInterface *myMap;
  /// Copy of the current Aria map, used to make sure the changes can be successfully made
  ArMapInterface *myWorkingMap;

  /// Change details to apply to the Aria map
  ArMapChangeDetails *myChangeDetails;
  /// Number of info types in the associated Aria map
  //int myInfoCount;

  /// List of info types in the associated info map
  std::list<std::string> myInfoNames;

  /// Associated server base; non-NULL only when changer instantiated on the server
  ArServerBase *myServer;

  /// Associated client switch manager; non-NULL when changer instantiated on robot with EM
  ArClientSwitchManager *myClientSwitch;

  /// Whether the client switch manager's serverClient has been initialized with a handler (for EM)
  bool myIsServerClientInit;


  /// Mutex that protects access to the myClient member
  ArMutex myClientMutex;
  /// Associated client base; non-NULL only when changer instantiated on the client
  ArClientBase *myClient;

  /// Mutex that protects access to the myClientInfo member
  ArMutex myClientInfoMutex;
  /// Information regarding the server client that is currently sending map changes
  ClientChangeInfo *myClientInfo;

  /// Mutex that protects access to the interleave data
  ArMutex myInterleaveMutex;
  /// Whether the client is ready to send another packet
  bool myReadyForNextPacket;
  /// Whether the client is waiting for a reply from the server
  bool myIsWaitingForReturn;

  /// Mutex that protects access to the myIsIdleProcessingPending member
  ArMutex myIdleProcessingMutex;
  /// Whether the server has data to process once it becomes idle
  bool myIsIdleProcessingPending;

  /// List of callbacks to be invoked before the changed map file is written
  std::list<ArFunctor*> myPreWriteCBList;
  /// List of callbacks to be invoked after the changed map file is written
  std::list<ArFunctor*> myPostWriteCBList;
          
  /// List of server client callbacks to be invoked after the map has been changed
  std::list< ArFunctor2<ArServerClient *, std::list<ArNetPacket *> *> *> 
                                                             myChangeCBList;
  
  /// List of server client callbacks to be invoked after the map has been changed
  std::list< ArFunctor2<ArServerClient *, ArNetPacket *> *>  myRobotChangeReplyCBList;

  /// Server handler for the network packets that describe map changes.
  ArFunctor2C<ArMapChanger, ArServerClient *, ArNetPacket *> myHandleChangePacketCB;
  
  ArFunctor2C<ArMapChanger, ArServerClient *, ArNetPacket *> myHandleRobotReplyPacketCB;
  
  /// Client handler for the map-changes-in-progress packet
  ArFunctor1C<ArMapChanger, ArNetPacket *>  myHandleChangesInProgressPacketCB;
  ///  Client handler for the reply packet
  ArFunctor1C<ArMapChanger, ArNetPacket *> myHandleReplyPacketCB;
  /// Client handler for the idle-processing-in-progress packet
  ArFunctor1C<ArMapChanger, ArNetPacket *> myHandleIdleProcessingPacketCB;
  /// Handler invoked when the client shuts down
  ArFunctorC<ArMapChanger> myClientShutdownCB;

}; // end class ArMapChanger

#endif // ARMAPCHANGER