Telemetry.h

#pragma once
 
#include <Foundation/Communication/Implementation/TelemetryMessage.h>
#include <Foundation/Containers/Deque.h>
#include <Foundation/Containers/HybridArray.h>
#include <Foundation/Containers/Map.h>
#include <Foundation/Logging/Log.h>
#include <Foundation/Strings/String.h>
#include <Foundation/Threading/Mutex.h>
#include <Foundation/Time/Time.h>
 
 
class PL_FOUNDATION_DLL plTelemetry
{
public:
  static plUInt16 s_uiPort /* = 1040*/;
 
  enum ConnectionMode
  {
    None,   
    Server, 
    Client, 
  };
 
  enum TransmitMode
  {
    Reliable,   
    Unreliable, 
  };
 
 
  static plResult ConnectToServer(plStringView sConnectTo = {});
 
  static void CreateServer();
 
  static void CloseConnection();
 
 
 
 
  static void Broadcast(TransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, const void* pData, plUInt32 uiDataBytes);
  static void Broadcast(TransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, plStreamReader& inout_stream, plInt32 iDataBytes = -1);
  static void Broadcast(TransmitMode tm, plTelemetryMessage& ref_msg);
 
  static void SendToServer(plUInt32 uiSystemID, plUInt32 uiMsgID, const void* pData = nullptr, plUInt32 uiDataBytes = 0);
  static void SendToServer(plUInt32 uiSystemID, plUInt32 uiMsgID, plStreamReader& inout_stream, plInt32 iDataBytes = -1);
  static void SendToServer(plTelemetryMessage& ref_msg);
 
 
 
  static ConnectionMode GetConnectionMode() { return s_ConnectionMode; }
 
  static bool IsConnectedToServer() { return s_bConnectedToServer; }
 
  static bool IsConnectedToClient() { return s_bConnectedToClient; }
 
  static bool IsConnectedToOther();
 
  static plTime GetPingToServer() { return s_PingToServer; }
 
  static plStringView GetServerName() { return s_sServerName; }
 
  static void SetServerName(plStringView sName);
 
  static plStringView GetServerIP() { return s_sServerIP; }
 
  static plUInt32 GetServerID() { return s_uiServerID; }
 
  static plMutex& GetTelemetryMutex();
 
 
 
  static plResult RetrieveMessage(plUInt32 uiSystemID, plTelemetryMessage& out_message);
 
  static void UpdateNetwork();
 
  using ProcessMessagesCallback = void (*)(void*);
 
  static void AcceptMessagesForSystem(plUInt32 uiSystemID, bool bAccept, ProcessMessagesCallback callback = nullptr, void* pPassThrough = nullptr);
 
  static void PerFrameUpdate();
 
  static void SetOutgoingQueueSize(plUInt32 uiSystemID, plUInt16 uiMaxQueued);
 
 
 
  struct TelemetryEventData
  {
    enum EventType
    {
      ConnectedToClient,      
      ConnectedToServer,      
      DisconnectedFromClient, 
      DisconnectedFromServer, 
      PerFrameUpdate,         
    };
 
    EventType m_EventType;
  };
 
  using plEventTelemetry = plEvent<const TelemetryEventData&, plMutex>;
 
  static void AddEventHandler(plEventTelemetry::Handler handler) { s_TelemetryEvents.AddEventHandler(handler); }
 
  static void RemoveEventHandler(plEventTelemetry::Handler handler) { s_TelemetryEvents.RemoveEventHandler(handler); }
 
 
private:
  static void UpdateServerPing();
 
  static plResult OpenConnection(ConnectionMode Mode, plStringView sConnectTo = {});
 
  static void Transmit(TransmitMode tm, const void* pData, plUInt32 uiDataBytes);
 
  static void Send(TransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, const void* pData, plUInt32 uiDataBytes);
  static void Send(TransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, plStreamReader& Stream, plInt32 iDataBytes = -1);
  static void Send(TransmitMode tm, plTelemetryMessage& msg);
 
  friend class plTelemetryThread;
 
  static void FlushOutgoingQueues();
 
  static void InitializeAsServer();
  static plResult InitializeAsClient(plStringView sConnectTo);
  static ConnectionMode s_ConnectionMode;
 
  static plUInt32 s_uiApplicationID;
  static plUInt32 s_uiServerID;
 
  static plString s_sServerName;
  static plString s_sServerIP;
 
  static bool s_bConnectedToServer;
  static bool s_bConnectedToClient;
  static bool s_bAllowNetworkUpdate;
 
  static void QueueOutgoingMessage(TransmitMode tm, plUInt32 uiSystemID, plUInt32 uiMsgID, const void* pData, plUInt32 uiDataBytes);
 
  static void SendServerName();
 
  static plTime s_PingToServer;
 
  using MessageDeque = plDeque<plTelemetryMessage>;
 
  struct MessageQueue
  {
    MessageQueue()
    {
      m_bAcceptMessages = false;
      m_uiMaxQueuedOutgoing = 1000;
      m_Callback = nullptr;
      m_pPassThrough = nullptr;
    }
 
    bool m_bAcceptMessages;
    ProcessMessagesCallback m_Callback;
    void* m_pPassThrough;
    plUInt32 m_uiMaxQueuedOutgoing;
 
    MessageDeque m_IncomingQueue;
    MessageDeque m_OutgoingQueue;
  };
 
  static plMap<plUInt64, MessageQueue> s_SystemMessages;
 
  static plEventTelemetry s_TelemetryEvents;
 
private:
  static plMutex s_TelemetryMutex;
  static void StartTelemetryThread();
  static void StopTelemetryThread();
};