/*
 * messaging_packet.hpp
 *
 *  Created on: Mar 27, 2021
 *      Author: erki
 */

#ifndef MESSAGING_INC_MESSAGING_PACKET_HPP_
#define MESSAGING_INC_MESSAGING_PACKET_HPP_

#include <cstring>
#include <cstdint>

namespace Messaging
{

template<size_t N>
struct Packet
{
  static constexpr std::uint8_t preamble[] = { 'A', 'A' };
  std::uint8_t data[N];
  std::uint32_t data_length = 0;

  const std::uint32_t max_data_length = N;
  const std::uint32_t preamble_length = sizeof(preamble);
  const std::uint32_t data_length_length = sizeof(data_length);

  bool serialize(std::uint8_t* buffer, const std::uint32_t max_length)
  {
    const std::uint32_t required_size = preamble_length + data_length_length + data_length;

    if (max_length < required_size)
      return false;

    std::memcpy(buffer, preamble, preamble_length);
    buffer += preamble_length;

    std::memcpy(buffer, &data_length, data_length_length);
    buffer += data_length_length;

    std::memcpy(buffer, data, data_length);

    return true;
  }

  bool deserialize(std::uint8_t* buffer, const std::uint32_t length)
  {
    const std::uint32_t header_length = preamble_length + data_length_length;

    if (length < header_length)
      return false;

    if (std::memcmp(buffer, preamble, preamble_length) != 0)
      return false;

    std::memcpy(&data_length, buffer + preamble_length, preamble_length);

    const std::uint32_t final_length = header_length + data_length;

    if (length != final_length)
      return false;

    std::memcpy(data, buffer + header_length, data_length);

    return true;
  }
};

}


#endif /* MESSAGING_INC_MESSAGING_PACKET_HPP_ */