RoboidControl-cpp/Participants/ParticipantUDP.h

#pragma once

#include "Messages/BinaryMsg.h"
#include "Messages/InvestigateMsg.h"
#include "Messages/ModelUrlMsg.h"
#include "Messages/NameMsg.h"
#include "Messages/ParticipantMsg.h"
#include "Messages/PoseMsg.h"
#include "Messages/SiteMsg.h"
#include "Messages/ThingMsg.h"
#include "Participant.h"

#if !defined(NO_STD)
#include <functional>
#include <list>
// #include <unordered_map>
#endif

#if defined(_WIN32) || defined(_WIN64)
#include <winsock2.h>
#elif defined(__unix__) || defined(__APPLE__)
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#endif

namespace RoboidControl {

constexpr int MAX_SENDER_COUNT = 256;

/// @brief A local participant is the local device which can communicate with
/// other participants It manages all local things and communcation with other
/// participants. Each application has a local participant which is usually
/// explicit in the code. An participant can be isolated. In that case it is
/// standalong and does not communicate with other participants.
///
/// It is possible to work with an hidden participant by creating things without
/// specifying a participant in the constructor. In that case an hidden isolated
/// participant is created which can be obtained using
/// RoboidControl::IsolatedParticipant::Isolated().
/// @sa RoboidControl::Thing::Thing()
class ParticipantUDP : public Participant {
 public:
  /// @brief Create a participant without connecting to a site
  /// @param port The port on which the participant communicates
  /// These participant typically broadcast Participant messages to let site
  /// servers on the local network know their presence. Alternatively they can
  /// broadcast information which can be used directly by other participants.
  ParticipantUDP(int port = 7681);
  /// @brief Create a participant which will try to connect to a site.
  /// @param ipAddress The IP address of the site
  /// @param port The port used by the site
  ParticipantUDP(const char* ipAddress,
                   int port = 7681,
                   int localPort = 7681);
  // Note to self: one cannot specify the port used by the local participant
  // now!!

  /// @brief Isolated participant is used when the application is run without
  /// networking
  /// @return A participant without networking support
  static ParticipantUDP* Isolated();

  /// @brief True if the participant is running isolated.
  /// Isolated participants do not communicate with other participants
  bool isIsolated = false;

  /// The interval in milliseconds for publishing (broadcasting) data on the
  /// local network
  long publishInterval = 3000;  // 3 seconds

  /// @brief The name of the participant
  const char* name = "ParticipantUDP";

  // int localPort = 0;

  /// @brief The remote site when this participant is connected to a site
  Participant* remoteSite = nullptr;

#if defined(ARDUINO)
  // const char* remoteIpAddress = nullptr;
  // unsigned short remotePort = 0;
  // char* broadcastIpAddress = nullptr;

  // WiFiUDP udp;
#else

#if defined(__unix__) || defined(__APPLE__)
  int sock;
#elif defined(_WIN32) || defined(_WIN64)
  sockaddr_in remote_addr;
  sockaddr_in server_addr;
  sockaddr_in broadcast_addr;
#endif

#endif

  void begin();
  bool connected = false;

  virtual void Update(unsigned long currentTimeMs = 0) override;

  void SendThingInfo(Participant* remoteParticipant, Thing* thing, bool recurse = false);
  void PublishThingInfo(Thing* thing);

  bool Send(Participant* remoteParticipant, IMessage* msg);
  bool Publish(IMessage* msg);

  void ReceiveData(unsigned char bufferSize,
                   char* senderIpAddress,
                   unsigned int senderPort);
  void ReceiveData(unsigned char bufferSize, Participant* remoteParticipant);

#if defined(NO_STD)
  unsigned char senderCount = 0;
  Participant* senders[MAX_SENDER_COUNT];
#else
  std::list<Participant*> senders;
#endif

 protected:
  unsigned long nextPublishMe = 0;

  char buffer[1024];

  void SetupUDP(int localPort, const char* remoteIpAddress, int remotePort);

  Participant* GetParticipant(const char* ipAddress, int port);
  Participant* AddParticipant(const char* ipAddress, int port);

  void ReceiveUDP();

  virtual void Process(Participant* sender, ParticipantMsg* msg);
  virtual void Process(Participant* sender, SiteMsg* msg);
  virtual void Process(Participant* sender, InvestigateMsg* msg);
  virtual void Process(Participant* sender, ThingMsg* msg);
  virtual void Process(Participant* sender, NameMsg* msg);
  virtual void Process(Participant* sender, ModelUrlMsg* msg);
  virtual void Process(Participant* sender, PoseMsg* msg);
  virtual void Process(Participant* sender, BinaryMsg* msg);

#if !defined(NO_STD)
//  public:
//   using ThingConstructor = std::function<Thing*(Participant* participant,
//                                                 unsigned char networkId,
//                                                 unsigned char thingId)>;

//   template <typename ThingClass>
//   void Register(unsigned char thingType) {
//     thingMsgProcessors[thingType] = [](Participant* participant,
//                                        unsigned char networkId,
//                                        unsigned char thingId) {
//       return new ThingClass(participant, networkId, thingId);
//     };
//   };

//   template <typename ThingClass>
//   void Register2(unsigned char thingType, ThingConstructor f) {
//     thingMsgProcessors[thingType] = [f](Participant* participant,
//                                        unsigned char networkId,
//                                        unsigned char thingId) {
//       return f(participant, networkId, thingId);
//     };
//   };

//  protected:
//   std::unordered_map<unsigned char, ThingConstructor> thingMsgProcessors;

#endif
};

}  // namespace RoboidControl