#pragma once

#include "NetworkPerception.h"
#include "Perception.h"
#include "Roboid.h"
#include "Types.h"

namespace Passer {
namespace RoboidControl {

/// @brief Interface for synchronizaing state between clients across a network
class NetworkSync {
 public:
  NetworkSync(Roboid* roboid);

  unsigned char networkId;

  /// @brief Retreive and send the roboid state
  /// @param roboid The roboid for which the state is updated
  virtual void NetworkUpdate(Roboid* roboid) = 0;
  /// @brief Inform that the given object is no longer being tracked
  /// @param obj
  virtual void DestroyObject(InterestingThing* obj);
  virtual void NewObject(InterestingThing* obj);
  virtual void PublishModel(Roboid* obj);
  void PublishModel(Thing* thing);

  /// @brief The id of a Pose message
  static const unsigned char PoseMsg = 0x10;
  static const unsigned char PoseTypeMsg = 0x11;
  static const unsigned char RelativePoseMsg = 0x12;
  /// @brief A bit pattern for the pose, stating that this message contains a
  /// position in world coordinates
  static const unsigned char Pose_Position = 0x01;
  /// @brief A bit pattern for the pose, stating that this message contains an
  /// orientation in world coordinates
  static const unsigned char Pose_Orientation = 0x02;
  /// @brief A bit pattern for the pose, stating that this messsage contains a
  /// linear velocity in world coordinates
  static const unsigned char Pose_LinearVelocity = 0x04;
  /// @brief A bit pattern for the pose, stating that this message contains an
  /// angular velocity in world coordinates
  static const char Pose_AngularVelocity = 0x08;

  static const unsigned char DestroyMsg = 0x20;

  static const unsigned char AngVelocity2DMsg = 0x46;
  static const unsigned char Position2DMsg = 0x61;
  static const unsigned char Velocity2DMsg = 0x62;
  static const unsigned char CreateMsg = 0x80;
  static const unsigned char InvestigateMsg = 0x81;
  static const unsigned char ClientMsg = 0xA0;
  static const unsigned char NetworkIdMsg = 0xA1;

  typedef void (*Buffer)(UInt8* buffer, UInt16 bufferSize);

  void ReceiveMessage(Roboid* roboid, unsigned char bytecount);

  void ReceiveNetworkId();

  void SendInvestigateThing(InterestingThing* thing);

  void SendPoseMsg(Buffer sendBuffer, Roboid* roboid);
  void SendDestroyObject(Buffer sendBuffer, InterestingThing* obj);
  void PublishNewObject();
  void PublishRelativeThing(Thing* thing, bool recurse = false);

  void PublishTrackedObjects(Roboid* roboid, InterestingThing** objects);

  virtual void SendPosition(Vector3 worldPosition) {};
  virtual void SendPose(Vector3 worldPosition, Quaternion worldOrientation) {};
  void SendPose(Roboid* roboid, bool recurse = true);
  void SendPose(Thing* thing, bool recurse = true);

  virtual void SendText(const char* s);
  void SendInt(const int x);

 protected:
  Roboid* roboid;
  NetworkPerception* networkPerception;

  void PublishTrackedObject(Roboid* roboid, InterestingThing* object);
  void PublishRelativeObject(Buffer sendBuffer,
                             UInt8 parentId,
                             InterestingThing* object);

  void SendSingle100(unsigned char* data, unsigned int startIndex, float value);
  void SendFloat16(unsigned char* data, unsigned char* startIndex, float value);

  void SendInt32(unsigned char* data, unsigned int startIndex, Int32 value);
  void SendAngle8(unsigned char* data,
                  unsigned int startIndex,
                  const float value);
  // void SendAngle16(unsigned char *data, unsigned int startIndex,
  //                  const float value);
  // void SendAngle32(unsigned char *data, unsigned int startIndex,
  //                  const float value);
  void SendVector3(unsigned char* data,
                   unsigned char* startIndex,
                   const Vector3 v);
  void SendQuaternion(unsigned char* data,
                      const int startIndex,
                      const Quaternion q);

  void SendPolar(unsigned char* data, unsigned char* startIndex, Polar p);
  void SendSpherical(unsigned char* data,
                     unsigned char* startIndex,
                     Spherical s);
  void SendSpherical16(unsigned char* data,
                       unsigned char* startIndex,
                       Spherical16 s);
  // void SendSpherical32(unsigned char *data, int startIndex, Spherical s);
  void SendQuat32(unsigned char* data,
                  unsigned char* startIndex,
                  const Quaternion q);

  unsigned char buffer[256];
  virtual void SendBuffer(unsigned char bufferSize);

  void PublishClient();
};

}  // namespace RoboidControl
}  // namespace Passer