//
// Created by erki on 27.03.21.
//

#include <catch2/catch.hpp>

#include <messaging_packet.hpp>
#include "simple.pb.h"

TEST_CASE("Packet copy_data_in copies data in.", "[messaging],[packet]")
{
  Messaging::Packet<2> packet;

  SECTION("Plain C-array data copies properly.")
  {
    const std::uint8_t data[2] = {'C', 'D'};
    const std::uint32_t data_size = sizeof(data);

    packet.copy_data_in(data);

    REQUIRE(packet.data_length == data_size);
    REQUIRE(packet.data[0] == data[0]);
    REQUIRE(packet.data[1] == data[1]);
  }

  SECTION("STL data copies properly.")
  {
    const std::array<std::uint8_t, 2> data = {'C', 'D'};

    packet.copy_data_in(data);

    REQUIRE(packet.data_length == data.size());
    REQUIRE(packet.data[0] == data[0]);
    REQUIRE(packet.data[1] == data[1]);
  }
}

TEST_CASE("Packet copying data in cuts off excess bytes.",
          "[messaging],[packet]")
{
  Messaging::Packet<2> packet;

  const std::uint8_t data[4] = {'C', 'D', 'E', 'F'};

  packet.copy_data_in(data);

  REQUIRE(packet.data_length == 2);
  REQUIRE(packet.data[0] == 'C');
  REQUIRE(packet.data[1] == 'D');
}

TEST_CASE("Packet gets serialized properly.", "[messaging],[packet]")
{
  Messaging::Packet<2> packet;

  const std::uint8_t data[2] = {'C', 'D'};
  const std::uint32_t data_size = sizeof(data);

  packet.copy_data_in(data);

  std::uint8_t output[data_size + 2 + 4];
  REQUIRE(packet.serialize(output, sizeof(output)));
  REQUIRE(packet.data_length == 2);

  SECTION("Preamble gets serialized properly.")
  {
    REQUIRE(output[0] == 'A');
    REQUIRE(output[1] == 'A');
  }

  SECTION("Length gets serialized properly.")
  {
    std::uint32_t length;

    std::memcpy(&length, output + 2, sizeof(length));
    REQUIRE(length == 2);
  }

  SECTION("Data gets serialized properly.")
  {
    const std::uint32_t offset = sizeof(data_size) + 2;
    REQUIRE(output[offset + 0] == 'C');
    REQUIRE(output[offset + 1] == 'D');
  }
}

TEST_CASE("Packet serialization fails if buffer too small.",
          "[messaging],[packet]")
{
  Messaging::Packet<2> packet;

  const std::uint8_t data[2] = {'C', 'D'};
  packet.copy_data_in(data);

  std::uint8_t output[4] = {0};
  REQUIRE(packet.serialize(output, sizeof(output)) == false);

  SECTION("Output buffer is left unmodified.")
  {
    for (const std::uint8_t& u : output)
    {
      REQUIRE(u == 0);
    }
  }
}

TEST_CASE("Packet deserialization works as expected.", "[messaging],[packet]")
{
  std::uint8_t data[] = {'A', 'A', 0, 0, 0, 0, 'C', 'D'};

  const std::uint32_t data_length = 2;
  std::memcpy(data + 2, &data_length, sizeof(data_length));

  Messaging::Packet<2> packet;

  REQUIRE(packet.deserialize(data, sizeof(data)));
  REQUIRE(packet.data_length == data_length);
  REQUIRE(packet.data[0] == 'C');
  REQUIRE(packet.data[1] == 'D');
}

TEST_CASE("Packet deserialization fails with invalid conditions.",
          "[messaging],[packet]")
{
  std::uint8_t data[] = {'A', 'A', 0, 0, 0, 0, 'C', 'D'};

  const std::uint32_t data_length = 2;
  std::memcpy(data + 2, &data_length, sizeof(data_length));

  Messaging::Packet<2> packet;

  SECTION("Invalid preamble causes failure.")
  {
    data[0] = 'B';
    REQUIRE(packet.deserialize(data, sizeof(data)) == false);

    data[0] = 'A';
    data[1] = 'B';
    REQUIRE(packet.deserialize(data, sizeof(data)) == false);
  }

  SECTION("Data length exceeding expected buffer length causes failure.")
  {
    const std::uint32_t data_length_fake = 4;
    std::memcpy(data + 2, &data_length_fake, sizeof(data_length_fake));

    REQUIRE(packet.deserialize(data, sizeof(data)) == false);
  }
}