#include <StdInc.h>

#include <random>

#include <catch_amalgamated.hpp>

#include <StateBagComponent.h>

#include "ByteReader.h"

#include "ByteWriter.h"

#include "ConsoleContextInstance.h"

#include "ENetPacketInstance.h"

#include "GameServer.h"

#include "ServerGameStatePublicInstance.h"

#include "ServerInstance.h"

#include "TestUtils.h"

#include "packethandlers/ArrayUpdatePacketHandler.h"

#include "state/ServerGameStatePublic.h"

TEST_CASE("Array update test")

{

const bool usePacket = GENERATE(true, false);

fx::SetOneSyncGetCallback([] { return true; });

REQUIRE(fx::ServerDecorators::ArrayUpdatePacketHandler::PacketType == HashRageString("msgArrayUpdate"));

// test is only implemented for onesync

REQUIRE(fx::IsOneSync() == true);

fwRefContainer<fx::ServerInstanceBase> serverInstance = ServerInstance::Create();

serverInstance->SetComponent(new fx::ClientRegistry());

serverInstance->SetComponent<fx::ServerGameStatePublic>(fx::ServerGameStatePublicInstance::Create());

serverInstance->SetComponent<console::Context>(ConsoleContextInstance::Get());

uint8_t testHandler = 1;

uint16_t testIndex = fx::TestUtils::u64Random(49);

std::vector<uint8_t> elementData (128);

fx::TestUtils::fillVectorU8Random(elementData);

net::Buffer buffer;

if (usePacket)

{

net::packet::ClientArrayUpdate clientArrayUpdate;

clientArrayUpdate.handler = testHandler;

clientArrayUpdate.index = testIndex;

clientArrayUpdate.data = {elementData.data(), elementData.size()};

std::vector<uint8_t> packetBuffer (net::SerializableComponent::GetMaxSize<net::packet::ClientArrayUpdate>());

net::ByteWriter writer {packetBuffer.data(), packetBuffer.size()};

REQUIRE(clientArrayUpdate.Process(writer) == true);

buffer.Write(packetBuffer.data(), packetBuffer.size());

}

else

{

buffer.Write<uint8_t>(testHandler);

buffer.Write<uint16_t>(testIndex);

buffer.Write<uint16_t>(elementData.size());

buffer.Write(elementData.data(), elementData.size());

}

buffer.Reset();

fx::ServerGameStatePublicInstance::GetArrayUpdateLastCall().reset();

const fx::ClientSharedPtr client = serverInstance->GetComponent<fx::ClientRegistry>()->MakeClient("test");

fx::ServerDecorators::ArrayUpdatePacketHandler handler(serverInstance.GetRef());

fx::ENetPacketPtr packetPtr = fx::ENetPacketInstance::Create(buffer.GetBuffer(), buffer.GetLength());

net::ByteReader reader(buffer.GetBuffer(), buffer.GetLength());

handler.Process(serverInstance.GetRef(), client, reader, packetPtr);

REQUIRE(fx::ServerGameStatePublicInstance::GetArrayUpdateLastCall().has_value() == true);

REQUIRE(fx::ServerGameStatePublicInstance::GetArrayUpdateLastCall().value().client == client);

REQUIRE(fx::ServerGameStatePublicInstance::GetArrayUpdateLastCall().value().handler == testHandler);

REQUIRE(fx::ServerGameStatePublicInstance::GetArrayUpdateLastCall().value().index == testIndex);

REQUIRE(fx::ServerGameStatePublicInstance::GetArrayUpdateLastCall().value().data == elementData);

}