#pragma once

#include "Thing.h"

namespace RoboidControl {

constexpr int MAX_THING_COUNT = 256;

/// @brief class which manages all known participants
class ParticipantRegistry {
 public:
  /// @brief Retrieve a participant by its address
  /// @param ipAddress The IP address of the participant
  /// @param port The port number of the participant
  /// @return The participant or a nullptr when it could not be found
  Participant* Get(const char* ipAddress, unsigned int port);
  /// @brief Retrieve a participant by its network ID
  /// @param networkID The network ID of the participant
  /// @return The participant or a nullptr when it could not be found
  Participant* Get(unsigned char networkID);

  /// @brief Add a participant with the given details
  /// @param ipAddress The IP address of the participant
  /// @param port The port number of the participant
  /// @return The added participant
  Participant* Add(const char* ipAddress, unsigned int port);
  /// @brief Add a participant
  /// @param participant The participant to add
  void Add(Participant* participant);

  /// @brief Remove a participant
  /// @param participant The participant to remove
  void Remove(Participant* participant);

 private:
#if defined(NO_STD)
 public:
  Participant** GetAll() const;
  int count = 0;

 private:
  Participant** participants;
#else
 public:
  /// @brief Get all participants
  /// @return All participants
  const std::list<Participant*>& GetAll() const;

 private:
  /// @brief The list of known participants
  std::list<Participant*> participants;
#endif
};

/// @brief A participant is a device which manages things.
/// It can communicate with other participant to synchronise the state of
/// things. This class is used to register the things the participant is
/// managing. It also maintains the communcation information to contact the
/// participant. It is used as a basis for the local participant, but also as a
/// reference to remote participants.
class Participant {
 public:
  /// @brief The name of the participant
  const char* name = "Participant";

  /// @brief The Ip Address of a participant.
  const char* ipAddress = "0.0.0.0";
  /// @brief The port number for UDP communication with the participant.
  unsigned int port = 0;

  /// @brief The network Id to identify the participant
  unsigned char networkId = 0;

  Participant();
  /// @brief Create a new participant with the given communcation info
  /// @param ipAddress The IP address of the participant
  /// @param port The UDP port of the participant
  Participant(const char* ipAddress, int port);
  /// @brief Destructor for the participant
  ~Participant();

  static Participant* LocalParticipant;
  static void ReplaceLocalParticipant(Participant& newParticipant);

  Thing* root = new Thing(this);

 public:
#if defined(NO_STD)
  unsigned char thingCount = 0;
  Thing* things[MAX_THING_COUNT];
#else
  /// @brief  The things managed by this participant
  std::list<Thing*> things;
#endif
  /// @brief Find a thing managed by this participant
  /// @param thingId The ID of the thing
  /// @return The thing if found, nullptr when no thing has been found
  Thing* Get(unsigned char thingId);
  /// @brief Add a new thing for this participant.
  /// @param thing The thing to add
  /// @param checkId If true, the thing.id is regenerated if it is zero
  void Add(Thing* thing, bool checkId = true);
  /// @brief Remove a thing for this participant
  /// @param thing The thing to remove
  void Remove(Thing* thing);

  /// @brief Update all things for this participant
  /// @param currentTimeMs The current time in milliseconds (optional)
  virtual void Update();

 public:
  static ParticipantRegistry registry;
};

}  // namespace RoboidControl