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

#include "zencore/testutils.h"

#if ZEN_WITH_TESTS

#	include <zencore/filesystem.h>
#	include <zencore/session.h>
#	include "zencore/string.h"

#	include <atomic>

namespace zen {

static std::atomic<int> Sequence{0};

std::filesystem::path
CreateTemporaryDirectory()
{
	std::error_code Ec;

	std::filesystem::path DirPath = std::filesystem::temp_directory_path() / GetSessionIdString() / IntNum(++Sequence).c_str();
	DeleteDirectories(DirPath, Ec);
	CreateDirectories(DirPath);

	return DirPath;
}

ScopedTemporaryDirectory::ScopedTemporaryDirectory() : m_RootPath(CreateTemporaryDirectory())
{
}

ScopedTemporaryDirectory::ScopedTemporaryDirectory(std::filesystem::path Directory) : m_RootPath(Directory)
{
	std::error_code Ec;
	DeleteDirectories(Directory, Ec);
	CreateDirectories(Directory);
}

ScopedTemporaryDirectory::~ScopedTemporaryDirectory()
{
	std::error_code Ec;
	DeleteDirectories(m_RootPath, Ec);
}

IoBuffer
CreateRandomBlob(uint64_t Size)
{
	static FastRandom Rand{.Seed = 0x7CEBF54E45B9F5D1};
	return CreateRandomBlob(Rand, Size);
};

IoBuffer
CreateSemiRandomBlob(uint64_t Size)
{
	IoBuffer	 Result(Size);
	const size_t PartCount = (Size / (1u * 1024u * 64)) + 1;
	const size_t PartSize  = Size / PartCount;
	auto		 Part	   = CreateRandomBlob(PartSize);
	auto		 Remain	   = Result.GetMutableView().CopyFrom(Part.GetView());
	while (Remain.GetSize() >= PartSize)
	{
		Remain = Remain.CopyFrom(Part.GetView());
	}
	if (Remain.GetSize() > 0)
	{
		auto RemainBuffer = CreateRandomBlob(Remain.GetSize());
		Remain.CopyFrom(RemainBuffer.GetView());
	}
	return Result;
};

IoBuffer
CreateRandomBlob(FastRandom& Rand, uint64_t Size)
{
	IoBuffer  Data(Size);
	uint64_t* DataPtr = reinterpret_cast<uint64_t*>(Data.MutableData());
	while (Size > sizeof(uint64_t))
	{
		*DataPtr++ = Rand.Next();
		Size -= sizeof(uint64_t);
	}
	uint64_t ByteNext	 = Rand.Next();
	uint8_t* ByteDataPtr = reinterpret_cast<uint8_t*>(DataPtr);
	while (Size > 0)
	{
		*ByteDataPtr++ = static_cast<uint8_t>(ByteNext & 0xff);
		ByteNext >>= 8;
		Size--;
	}
	return Data;
};

IoBuffer
CreateSemiRandomBlob(FastRandom& Rand, uint64_t Size)
{
	IoBuffer	 Result(Size);
	const size_t PartCount = (Size / (1u * 1024u * 64)) + 1;
	const size_t PartSize  = Size / PartCount;
	auto		 Part	   = CreateRandomBlob(Rand, PartSize);
	auto		 Remain	   = Result.GetMutableView().CopyFrom(Part.GetView());
	while (Remain.GetSize() >= PartSize)
	{
		Remain = Remain.CopyFrom(Part.GetView());
	}
	if (Remain.GetSize() > 0)
	{
		auto RemainBuffer = CreateRandomBlob(Rand, Remain.GetSize());
		Remain.CopyFrom(RemainBuffer.GetView());
	}
	return Result;
};

}  // namespace zen

#endif	// ZEN_WITH_TESTS