// Copyright Epic Games, Inc. All Rights Reserved.

#include <zencore/zencore.h>

#if ZEN_WITH_TESTS

#	include <zencore/compactbinary.h>
#	include <zencore/compactbinarybuilder.h>
#	include <zencore/string.h>
#	include <zencore/testing.h>
#	include <zencore/uid.h>
#	include <zenutil/cache/cachepolicy.h>

namespace zen::tests {

using namespace std::literals;

TEST_CASE("cachepolicy")
{
	SUBCASE("atomics serialization")
	{
		CachePolicy SomeAtomics[] = {CachePolicy::None,
									 CachePolicy::QueryLocal,
									 CachePolicy::StoreRemote,
									 CachePolicy::SkipData,
									 CachePolicy::KeepAlive};
		for (CachePolicy Atomic : SomeAtomics)
		{
			CHECK(ParseCachePolicy(WriteToString<128>(Atomic)) == Atomic);
		}
		// Also verify that we ignore unrecognized bits
		for (CachePolicy Atomic : SomeAtomics)
		{
			CHECK(ParseCachePolicy(WriteToString<128>(Atomic | (CachePolicy)0x10000000)) == Atomic);
		}
	}
	SUBCASE("aliases serialization")
	{
		CachePolicy SomeAliases[] = {CachePolicy::Query, CachePolicy::Local};
		for (CachePolicy Alias : SomeAliases)
		{
			CHECK(ParseCachePolicy(WriteToString<128>(Alias)) == Alias);
		}
		// Also verify that we ignore unrecognized bits
		for (CachePolicy Alias : SomeAliases)
		{
			CHECK(ParseCachePolicy(WriteToString<128>(Alias | (CachePolicy)0x10000000)) == Alias);
		}
	}
	SUBCASE("aliases take priority over atomics")
	{
		CHECK(WriteToString<128>(CachePolicy::Default).ToView() == "Default"sv);
		CHECK(WriteToString<128>(CachePolicy::Query).ToView() == "Query"sv);
		CHECK(WriteToString<128>(CachePolicy::Local).ToView() == "Local"sv);
	}
	SUBCASE("policies requiring multiple strings work")
	{
		char		Delimiter	= ',';
		CachePolicy Combination = CachePolicy::SkipData | CachePolicy::QueryLocal;
		CHECK(WriteToString<128>(Combination).ToView().find(Delimiter) != std::string_view::npos);
		CHECK(ParseCachePolicy(WriteToString<128>(Combination)) == Combination);
	}
	SUBCASE("parsing invalid text")
	{
		CHECK(ParseCachePolicy(",,,") == CachePolicy::None);
		CHECK(ParseCachePolicy("fee,fie,foo,fum") == CachePolicy::None);
		CHECK(ParseCachePolicy("fee,KeepAlive,foo,fum") == CachePolicy::KeepAlive);
	}
}

TEST_CASE("cacherecordpolicy")
{
	SUBCASE("policy with no values")
	{
		CachePolicy				 Policy		 = CachePolicy::SkipData | CachePolicy::QueryLocal | CachePolicy::PartialRecord;
		CachePolicy				 ValuePolicy = Policy & CacheValuePolicy::PolicyMask;
		CacheRecordPolicy		 RecordPolicy;
		CacheRecordPolicyBuilder Builder(Policy);
		RecordPolicy = Builder.Build();
		SUBCASE("construct")
		{
			CHECK(RecordPolicy.IsUniform());
			CHECK(RecordPolicy.GetRecordPolicy() == Policy);
			CHECK(RecordPolicy.GetBasePolicy() == Policy);
			CHECK(RecordPolicy.GetValuePolicy(Oid::NewOid()) == ValuePolicy);
			CHECK(RecordPolicy.GetValuePolicies().size() == 0);
		}
		SUBCASE("saveload")
		{
			CbWriter Writer;
			RecordPolicy.Save(Writer);
			CbObject		  Saved	 = Writer.Save()->AsObject();
			CacheRecordPolicy Loaded = CacheRecordPolicy::Load(Saved).Get();
			CHECK(Loaded.IsUniform());
			CHECK(Loaded.GetRecordPolicy() == Policy);
			CHECK(Loaded.GetBasePolicy() == Policy);
			CHECK(Loaded.GetValuePolicy(Oid::NewOid()) == ValuePolicy);
			CHECK(Loaded.GetValuePolicies().size() == 0);
		}
	}

	SUBCASE("policy with values")
	{
		CachePolicy DefaultPolicy	   = CachePolicy::StoreRemote | CachePolicy::QueryLocal | CachePolicy::PartialRecord;
		CachePolicy DefaultValuePolicy = DefaultPolicy & CacheValuePolicy::PolicyMask;
		CachePolicy PartialOverlap	   = CachePolicy::StoreRemote;
		CachePolicy NoOverlap		   = CachePolicy::QueryRemote;
		CachePolicy UnionPolicy		   = DefaultPolicy | PartialOverlap | NoOverlap | CachePolicy::PartialRecord;

		CacheRecordPolicy		 RecordPolicy;
		CacheRecordPolicyBuilder Builder(DefaultPolicy);
		Oid						 PartialOid	  = Oid::NewOid();
		Oid						 NoOverlapOid = Oid::NewOid();
		Oid						 OtherOid	  = Oid::NewOid();
		Builder.AddValuePolicy(PartialOid, PartialOverlap);
		Builder.AddValuePolicy(NoOverlapOid, NoOverlap);
		RecordPolicy = Builder.Build();
		SUBCASE("construct")
		{
			CHECK(!RecordPolicy.IsUniform());
			CHECK(RecordPolicy.GetRecordPolicy() == UnionPolicy);
			CHECK(RecordPolicy.GetBasePolicy() == DefaultPolicy);
			CHECK(RecordPolicy.GetValuePolicy(PartialOid) == PartialOverlap);
			CHECK(RecordPolicy.GetValuePolicy(NoOverlapOid) == NoOverlap);
			CHECK(RecordPolicy.GetValuePolicy(OtherOid) == DefaultValuePolicy);
			CHECK(RecordPolicy.GetValuePolicies().size() == 2);
		}
		SUBCASE("saveload")
		{
			CbWriter Writer;
			RecordPolicy.Save(Writer);
			CbObject		  Saved	 = Writer.Save()->AsObject();
			CacheRecordPolicy Loaded = CacheRecordPolicy::Load(Saved).Get();
			CHECK(!RecordPolicy.IsUniform());
			CHECK(RecordPolicy.GetRecordPolicy() == UnionPolicy);
			CHECK(RecordPolicy.GetBasePolicy() == DefaultPolicy);
			CHECK(RecordPolicy.GetValuePolicy(PartialOid) == PartialOverlap);
			CHECK(RecordPolicy.GetValuePolicy(NoOverlapOid) == NoOverlap);
			CHECK(RecordPolicy.GetValuePolicy(OtherOid) == DefaultValuePolicy);
			CHECK(RecordPolicy.GetValuePolicies().size() == 2);
		}
	}

	SUBCASE("parsing invalid text")
	{
		OptionalCacheRecordPolicy Loaded = CacheRecordPolicy::Load(CbObject());
		CHECK(Loaded.IsNull());
	}
}

}  // namespace zen::tests

#endif