#include <gtest/gtest.h>
#include <metadump/metadump.hpp>

template<typename T>
using serializer = metadump::mono::serializer<T>;

TEST(MONO, INTEGRAL) {
	uint8_t buf[8];

	// Serialization of uint8_t

	static_assert(!serializer<uint8_t>::SERIAL_SIZE_DYNAMIC, "Integral serialization size should be fixed (uint8_t)!");
	static_assert(serializer<uint8_t>::serial_size() == sizeof(uint8_t), "Integral serialization size is incorrect (uint8_t)!");
	uint8_t a8 = 0x01, b8 = 0;

	ASSERT_TRUE(serializer<uint8_t>::dump(buf, a8)) << "Failed to dump uint8_t!";
	ASSERT_TRUE(serializer<uint8_t>::load(buf, b8)) << "Failed to load uint8_t!";
	ASSERT_EQ(a8, b8) << "Deserialized uint8_t does not match serialization input!";

	// Serialization of uint16_t

	static_assert(!serializer<uint16_t>::SERIAL_SIZE_DYNAMIC, "Integral serialization size should be fixed (uint16_t)!");
	static_assert(serializer<uint16_t>::serial_size() == sizeof(uint16_t), "Integral serialization size is incorrect (uint16_t)!");
	uint16_t a16 = 0x0102, b16 = 0;

	ASSERT_TRUE(serializer<uint16_t>::dump(buf, a16)) << "Failed to dump uint16_t!";
	ASSERT_TRUE(serializer<uint16_t>::load(buf, b16)) << "Failed to load uint16_t!";
	ASSERT_EQ(a16, b16) << "Deserialized uint16_t does not match serialization input!";

	// Serialization of uint32_t

	static_assert(!serializer<uint32_t>::SERIAL_SIZE_DYNAMIC, "Integral serialization size should be fixed (uint32_t)!");
	static_assert(serializer<uint32_t>::serial_size() == sizeof(uint32_t), "Integral serialization size is incorrect (uint32_t)!");
	uint32_t a32 = 0x01020304, b32 = 0;

	ASSERT_TRUE(serializer<uint32_t>::dump(buf, a32)) << "Failed to dump uint32_t!";
	ASSERT_TRUE(serializer<uint32_t>::load(buf, b32)) << "Failed to load uint32_t!";
	ASSERT_EQ(a32, b32) << "Deserialized uint32_t does not match serialization input!";

	// Serialization of uint64_t

	static_assert(!serializer<uint64_t>::SERIAL_SIZE_DYNAMIC, "Integral serialization size should be fixed (uint64_t)!");
	static_assert(serializer<uint64_t>::serial_size() == sizeof(uint64_t), "Integral serialization size is incorrect (uint64_t)!");
	uint64_t a64 = 0x0102030405060708ull, b64 = 0;

	ASSERT_TRUE(serializer<uint64_t>::dump(buf, a64)) << "Failed to dump uint64_t!";
	ASSERT_TRUE(serializer<uint64_t>::load(buf, b64)) << "Failed to load uint64_t!";
	ASSERT_EQ(a64, b64) << "Deserialized uint64_t does not match serialization input!";
}

TEST(MONO, ENUM) {
	uint8_t buf[4];
	enum class ENUM : uint32_t { A, B, C, D, E };

	static_assert(!serializer<ENUM>::SERIAL_SIZE_DYNAMIC, "Enum serialization size should be fixed!");
	static_assert(serializer<ENUM>::serial_size() == sizeof(uint32_t), "Enum serialization size does not match internal type!");

	ENUM a = ENUM::D, b = ENUM::A;

	ASSERT_TRUE(serializer<ENUM>::dump(buf, a)) << "Failed to dump enum!";
	ASSERT_TRUE(serializer<ENUM>::load(buf, b)) << "Failed to load enum!";
	ASSERT_EQ(a, b) << "Deserialized enum does not match serialization input!";
}

int main(int argc, char** argv) {
	testing::InitGoogleTest(&argc, argv);
	return RUN_ALL_TESTS();
}