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

#include <catch2/catch.hpp>

#include <messaging_packet.hpp>
#include <messaging_parser.hpp>

using Packet = Messaging::Packet<2>;

namespace
{

std::array<std::uint8_t, 2> test_data = {'C', 'D'};

std::array<std::uint8_t, 8>
getRawData(const std::array<std::uint8_t, 2>& data)
{
  std::array<std::uint8_t, 8> raw = {'A', 'A', 0, 0, 0, 0, data[0], data[1]};

  const std::uint32_t len = 2;
  std::memcpy(raw.data() + 2, &len, 4);

  return raw;
}

std::array<std::uint8_t, 8> getRawData() { return getRawData({'C', 'D'}); }

}// namespace

TEST_CASE("Parser parses raw message successfully.", "[messaging],[parser]")
{
  Messaging::Parser<Packet, Packet::totalLength()> parser;

  for (const std::uint8_t& byte : getRawData())
  {
    parser.pushByte(byte);
  }

  REQUIRE(parser.packetReady());

  SECTION("Retrieved packet is correct.")
  {
    Packet packet;
    REQUIRE(parser.getPacket(packet));

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

TEST_CASE("Parser ignores extra bytes when done.", "[messaging],[parser]")
{
  Messaging::Parser<Packet, Packet::totalLength()> parser;

  for (const std::uint8_t& byte : getRawData())
  {
    parser.pushByte(byte);
  }

  REQUIRE(parser.packetReady());

  for (const std::uint8_t& byte : getRawData({'E', 'F'}))
  {
    parser.pushByte(byte);
  }

  SECTION("Retrieved packet is correct.")
  {
    Packet packet;
    REQUIRE(parser.getPacket(packet));

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

TEST_CASE("Parser ignores junk data until header is spotted.",
          "[messaging],[parser]")
{
  Messaging::Parser<Packet, Packet::totalLength()> parser;
  const std::array<std::uint8_t, 8> junk_data = {'E', 'F', 'A', 'H',
                                                 'I', 'J', 'K', 'L'};

  for (const std::uint8_t& byte : junk_data)
  {
    parser.pushByte(byte);
  }

  REQUIRE(parser.packetReady() == false);

  SECTION("Valid packet after junk is parsed successfully.")
  {
    for (const std::uint8_t& byte : getRawData())
    {
      parser.pushByte(byte);
    }

    REQUIRE(parser.packetReady());

    SECTION("Retrieved packet is correct.")
    {
      Packet packet;
      REQUIRE(parser.getPacket(packet));

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

TEST_CASE("Parser resets successfully when required.", "[messaging],[parser]")
{
  Messaging::Parser<Packet, Packet::totalLength()> parser;

  for (const std::uint8_t& byte : getRawData())
  {
    parser.pushByte(byte);
  }

  REQUIRE(parser.packetReady());

  parser.reset();

  REQUIRE(parser.packetReady() == false);

  SECTION("Follow-up packet is parsed successfully.")
  {
    for (const std::uint8_t& byte : getRawData())
    {
      parser.pushByte(byte);
    }

    REQUIRE(parser.packetReady());

    SECTION("Retrieved packet is correct.")
    {
      Packet packet;
      REQUIRE(parser.getPacket(packet));

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