#pragma once

#include "CoreTypes.h"
#include "TypeTraits/TypeTraits.h"
#include "Templates/Utility.h"
#include "Templates/TypeHash.h"
#include "Memory/Allocator.h"
#include "Memory/MemoryOperator.h"
#include "Iterator/Utility.h"
#include "Iterator/BasicIterator.h"
#include "Iterator/Sentinel.h"
#include "Iterator/ReverseIterator.h"
#include "Range/Utility.h"
#include "Range/Factory.h"
#include "Miscellaneous/Compare.h"
#include "Miscellaneous/AssertionMacros.h"

NAMESPACE_REDCRAFT_BEGIN
NAMESPACE_MODULE_BEGIN(Redcraft)
NAMESPACE_MODULE_BEGIN(Utility)

/** Dynamic array. The elements are stored contiguously, which means that elements can be accessed not only through iterators, but also using offsets to regular pointers to elements. */
template <CAllocatableObject T, CAllocator<T> Allocator = FHeapAllocator>
class TArray
{
private:

	template <bool bConst, typename = TConditional<bConst, const T, T>>
	class TIteratorImpl;

public:

	using FElementType   = T;
	using FAllocatorType = Allocator;

	using      FReference =       T&;
	using FConstReference = const T&;

	using      FIterator = TIteratorImpl<false>;
	using FConstIterator = TIteratorImpl<true >;

	using      FReverseIterator = TReverseIterator<     FIterator>;
	using FConstReverseIterator = TReverseIterator<FConstIterator>;

	static_assert(CContiguousIterator<     FIterator>);
	static_assert(CContiguousIterator<FConstIterator>);

	/** Default constructor. Constructs an empty container with a default-constructed allocator. */
	FORCEINLINE TArray() : TArray(0) { }

	/** Constructs the container with 'Count' default instances of T. */
	explicit TArray(size_t Count) requires (CDefaultConstructible<T>)
	{
		Impl.ArrayNum = Count;
		Impl.ArrayMax = Impl->CalculateSlackReserve(Num());
		Impl.Pointer  = Impl->Allocate(Max());

		Memory::DefaultConstruct<FElementType>(Impl.Pointer, Num());
	}

	/** Constructs the container with 'Count' copies of elements with 'InValue'. */
	FORCEINLINE explicit TArray(size_t Count, const FElementType& InValue) requires (CCopyConstructible<T>)
		: TArray(Range::Repeat(InValue, Count))
	{ }

	/** Constructs the container with the contents of the range ['First', 'Last'). */
	template <CInputIterator I, CSentinelFor<I> S> requires (CConstructibleFrom<T, TIteratorReference<I>> && CMovable<T>)
	explicit TArray(I First, S Last)
	{
		if constexpr (CForwardIterator<I>)
		{
			size_t Count = 0;

			if constexpr (CSizedSentinelFor<S, I>)
			{
				checkf(First - Last <= 0, TEXT("Illegal range iterator. Please check First <= Last."));

				Count = Last - First;
			}
			else for (I Iter = First; Iter != Last; ++Iter) ++Count;

			Impl.ArrayNum = Count;
			Impl.ArrayMax = Impl->CalculateSlackReserve(Num());
			Impl.Pointer  = Impl->Allocate(Max());

			for (size_t Index = 0; Index != Count; ++Index)
			{
				new (Impl.Pointer + Index) FElementType(*First++);
			}
		}
		else
		{
			Impl.ArrayNum = 0;
			Impl.ArrayMax = Impl->CalculateSlackReserve(Num());
			Impl.Pointer  = Impl->Allocate(Max());

			while (First != Last)
			{
				PushBack(*First);
				++First;
			}
		}
	}

	/** Constructs the container with the contents of the range. */
	template <CInputRange R> requires (!CSameAs<TRemoveCVRef<R>, TArray> && CConstructibleFrom<T, TRangeReference<R>> && CMovable<T>)
	FORCEINLINE explicit TArray(R&& Range) : TArray(Range::Begin(Range), Range::End(Range)) { }

	/** Copy constructor. Constructs the container with the copy of the contents of 'InValue'. */
	TArray(const TArray& InValue) requires (CCopyConstructible<T>)
	{
		Impl.ArrayNum = InValue.Num();
		Impl.ArrayMax = Impl->CalculateSlackReserve(Num());
		Impl.Pointer  = Impl->Allocate(Max());

		Memory::CopyConstruct<FElementType>(Impl.Pointer, InValue.Impl.Pointer, Num());
	}

	/** Move constructor. After the move, 'InValue' is guaranteed to be empty. */
	TArray(TArray&& InValue) requires (CMoveConstructible<T>)
	{
		Impl.ArrayNum = InValue.Num();

		if (InValue.Impl->IsTransferable(InValue.Impl.Pointer))
		{
			Impl.ArrayMax = InValue.Max();
			Impl.Pointer  = InValue.Impl.Pointer;

			InValue.Impl.ArrayNum = 0;
			InValue.Impl.ArrayMax = InValue.Impl->CalculateSlackReserve(InValue.Num());
			InValue.Impl.Pointer  = InValue.Impl->Allocate(InValue.Max());
		}
		else
		{
			Impl.ArrayMax = Impl->CalculateSlackReserve(Num());
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, InValue.Impl.Pointer, Num());
		}

		InValue.Reset();
	}

	/** Constructs the container with the contents of the initializer list. */
	FORCEINLINE TArray(initializer_list<FElementType> IL) requires (CCopyConstructible<T>) : TArray(Range::Begin(IL), Range::End(IL)) { }

	/** Destructs the array. The destructors of the elements are called and the used storage is deallocated. */
	~TArray()
	{
		Memory::Destruct(Impl.Pointer,Num());
		Impl->Deallocate(Impl.Pointer);
	}

	/** Copy assignment operator. Replaces the contents with a copy of the contents of 'InValue'. */
	TArray& operator=(const TArray& InValue) requires (CCopyable<T>)
	{
		if (&InValue == this) UNLIKELY return *this;

		size_t NumToAllocate = InValue.Num();

		NumToAllocate = NumToAllocate > Max() ? Impl->CalculateSlackGrow(InValue.Num(), Max())   : NumToAllocate;
		NumToAllocate = NumToAllocate < Max() ? Impl->CalculateSlackShrink(InValue.Num(), Max()) : NumToAllocate;

		if (NumToAllocate != Max())
		{
			Memory::Destruct(Impl.Pointer, Num());
			Impl->Deallocate(Impl.Pointer);

			Impl.ArrayNum = InValue.Num();
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::CopyConstruct<FElementType>(Impl.Pointer, InValue.Impl.Pointer, Num());

			return *this;
		}

		if (InValue.Num() <= Num())
		{
			Memory::CopyAssign(Impl.Pointer, InValue.Impl.Pointer, InValue.Num());
			Memory::Destruct(Impl.Pointer + InValue.Num(), Num() - InValue.Num());
		}
		else if (InValue.Num() <= Max())
		{
			Memory::CopyAssign(Impl.Pointer, InValue.Impl.Pointer, Num());
			Memory::CopyConstruct<FElementType>(Impl.Pointer + Num(), InValue.Impl.Pointer + Num(), InValue.Num() - Num());
		}
		else check_no_entry();

		Impl.ArrayNum = InValue.Num();

		return *this;
	}

	/** Move assignment operator. After the move, 'InValue' is guaranteed to be empty. */
	TArray& operator=(TArray&& InValue) requires (CMovable<T>)
	{
		if (&InValue == this) UNLIKELY return *this;

		if (InValue.Impl->IsTransferable(InValue.Impl.Pointer))
		{
			Memory::Destruct(Impl.Pointer, Num());
			Impl->Deallocate(Impl.Pointer);

			Impl.ArrayNum = InValue.Num();
			Impl.ArrayMax = InValue.Max();
			Impl.Pointer  = InValue.Impl.Pointer;

			InValue.Impl.ArrayNum = 0;
			InValue.Impl.ArrayMax = InValue.Impl->CalculateSlackReserve(InValue.Num());
			InValue.Impl.Pointer  = InValue.Impl->Allocate(InValue.Max());

			return *this;
		}

		size_t NumToAllocate = InValue.Num();

		NumToAllocate = NumToAllocate > Max() ? Impl->CalculateSlackGrow(InValue.Num(), Max())   : NumToAllocate;
		NumToAllocate = NumToAllocate < Max() ? Impl->CalculateSlackShrink(InValue.Num(), Max()) : NumToAllocate;

		if (NumToAllocate != Max())
		{
			Memory::Destruct(Impl.Pointer, Num());
			Impl->Deallocate(Impl.Pointer);

			Impl.ArrayNum = InValue.Num();
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, InValue.Impl.Pointer, Num());

			InValue.Reset();

			return *this;
		}

		if (InValue.Num() <= Num())
		{
			Memory::MoveAssign(Impl.Pointer, InValue.Impl.Pointer, InValue.Num());
			Memory::Destruct(Impl.Pointer + InValue.Num(), Num() - InValue.Num());
		}
		else if (InValue.Num() <= Max())
		{
			Memory::MoveAssign(Impl.Pointer, InValue.Impl.Pointer, Num());
			Memory::MoveConstruct<FElementType>(Impl.Pointer + Num(), InValue.Impl.Pointer + Num(), InValue.Num() - Num());
		}
		else check_no_entry();

		Impl.ArrayNum = InValue.Num();

		InValue.Reset();

		return *this;
	}

	/** Replaces the contents with those identified by initializer list. */
	TArray& operator=(initializer_list<FElementType> IL) requires (CCopyable<T>)
	{
		size_t NumToAllocate = Range::Num(IL);

		NumToAllocate = NumToAllocate > Max() ? Impl->CalculateSlackGrow  (Range::Num(IL), Max()) : NumToAllocate;
		NumToAllocate = NumToAllocate < Max() ? Impl->CalculateSlackShrink(Range::Num(IL), Max()) : NumToAllocate;

		if (NumToAllocate != Max())
		{
			Memory::Destruct(Impl.Pointer, Num());
			Impl->Deallocate(Impl.Pointer);

			Impl.ArrayNum = Range::Num(IL);
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::CopyConstruct<FElementType>(Impl.Pointer, Range::GetData(IL), Num());

			return *this;
		}

		if (Range::Num(IL) <= Num())
		{
			Memory::CopyAssign(Impl.Pointer, Range::GetData(IL), Range::Num(IL));
			Memory::Destruct(Impl.Pointer + Range::Num(IL), Num() - Range::Num(IL));
		}
		else if (Range::Num(IL) <= Max())
		{
			Memory::CopyAssign(Impl.Pointer, Range::GetData(IL), Num());
			Memory::CopyConstruct<FElementType>(Impl.Pointer + Num(), Range::GetData(IL) + Num(), Range::Num(IL) - Num());
		}
		else check_no_entry();

		Impl.ArrayNum = Range::Num(IL);

		return *this;
	}

	/** Compares the contents of two arrays. */
	NODISCARD friend bool operator==(const TArray& LHS, const TArray& RHS) requires (CWeaklyEqualityComparable<T>)
	{
		if (LHS.Num() != RHS.Num()) return false;

		for (size_t Index = 0; Index < LHS.Num(); ++Index)
		{
			if (LHS[Index] != RHS[Index]) return false;
		}

		return true;
	}

	/** Compares the contents of 'LHS' and 'RHS' lexicographically. */
	NODISCARD friend auto operator<=>(const TArray& LHS, const TArray& RHS) requires (CSynthThreeWayComparable<T>)
	{
		const size_t NumToCompare = LHS.Num() < RHS.Num() ? LHS.Num() : RHS.Num();

		for (size_t Index = 0; Index < NumToCompare; ++Index)
		{
			if (const auto Result = SynthThreeWayCompare(LHS[Index], RHS[Index]); Result != 0) return Result;
		}

		return LHS.Num() <=> RHS.Num();
	}

	/** Inserts 'InValue' before 'Iter' in the container. */
	FIterator Insert(FConstIterator Iter, const FElementType& InValue) requires (CCopyable<T>)
	{
		checkf(IsValidIterator(Iter), TEXT("Read access violation. Please check IsValidIterator()."));

		const size_t InsertIndex = Iter - Begin();

		const size_t NumToAllocate = Num() + 1 > Max() ? Impl->CalculateSlackGrow(Num() + 1, Max()) : Max();

		check(NumToAllocate >= Num() + 1);

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Num() + 1;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, InsertIndex);
			new (Impl.Pointer + InsertIndex) FElementType(InValue);
			Memory::MoveConstruct<FElementType>(Impl.Pointer + InsertIndex + 1, OldAllocation + InsertIndex, NumToDestruct - InsertIndex);

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return FIterator(this, Impl.Pointer + InsertIndex);
		}

		if (InsertIndex != Num())
		{
			new (Impl.Pointer + Num()) FElementType(MoveTemp(Impl.Pointer[Num() - 1]));

			for (size_t Index = Num() - 1; Index != InsertIndex; --Index)
			{
				Impl.Pointer[Index] = MoveTemp(Impl.Pointer[Index - 1]);
			}

			Impl.Pointer[InsertIndex] = InValue;
		}
		else new (Impl.Pointer + Num()) FElementType(InValue);

		Impl.ArrayNum = Num() + 1;

		return FIterator(this, Impl.Pointer + InsertIndex);
	}

	/** Inserts 'InValue' before 'Iter' in the container. */
	FIterator Insert(FConstIterator Iter, FElementType&& InValue) requires (CMovable<T>)
	{
		checkf(IsValidIterator(Iter), TEXT("Read access violation. Please check IsValidIterator()."));

		const size_t InsertIndex = Iter - Begin();

		const size_t NumToAllocate = Num() + 1 > Max() ? Impl->CalculateSlackGrow(Num() + 1, Max()) : Max();

		check(NumToAllocate >= Num() + 1);

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Num() + 1;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, InsertIndex);
			new (Impl.Pointer + InsertIndex) FElementType(MoveTemp(InValue));
			Memory::MoveConstruct<FElementType>(Impl.Pointer + InsertIndex + 1, OldAllocation + InsertIndex, NumToDestruct - InsertIndex);

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return FIterator(this, Impl.Pointer + InsertIndex);
		}

		if (InsertIndex != Num())
		{
			new (Impl.Pointer + Num()) FElementType(MoveTemp(Impl.Pointer[Num() - 1]));

			for (size_t Index = Num() - 1; Index != InsertIndex; --Index)
			{
				Impl.Pointer[Index] = MoveTemp(Impl.Pointer[Index - 1]);
			}

			Impl.Pointer[InsertIndex] = MoveTemp(InValue);
		}
		else new (Impl.Pointer + Num()) FElementType(MoveTemp(InValue));

		Impl.ArrayNum = Num() + 1;

		return FIterator(this, Impl.Pointer + InsertIndex);
	}

	/** Inserts 'Count' copies of the 'InValue' before 'Iter' in the container. */
	FIterator Insert(FConstIterator Iter, size_t Count, const FElementType& InValue) requires (CCopyable<T>)
	{
		checkf(IsValidIterator(Iter), TEXT("Read access violation. Please check IsValidIterator()."));

		return Insert(Iter, Range::Repeat(InValue, Count));
	}

	/** Inserts elements from range ['First', 'Last') before 'Iter'. */
	template <CInputIterator I, CSentinelFor<I> S> requires (CConstructibleFrom<T, TIteratorReference<I>> && CAssignableFrom<T&, TIteratorReference<I>> && CMovable<T>)
	FIterator Insert(FConstIterator Iter, I First, S Last)
	{
		checkf(IsValidIterator(Iter), TEXT("Read access violation. Please check IsValidIterator()."));

		if constexpr (CForwardIterator<I>)
		{
			const size_t InsertIndex = Iter - Begin();

			size_t Count = 0;

			if constexpr (CSizedSentinelFor<S, I>)
			{
				checkf(First - Last <= 0, TEXT("Illegal range iterator. Please check First <= Last."));

				Count = Last - First;
			}
			else for (I Jter = First; Jter != Last; ++Jter) ++Count;

			if (Count == 0) return FIterator(this, Impl.Pointer + InsertIndex);

			const size_t NumToAllocate = Num() + Count > Max() ? Impl->CalculateSlackGrow(Num() + Count, Max()) : Max();

			check(NumToAllocate >= Num() + Count);

			if (NumToAllocate != Max())
			{
				FElementType* OldAllocation = Impl.Pointer;
				const size_t  NumToDestruct = Num();

				Impl.ArrayNum = Num() + Count;
				Impl.ArrayMax = NumToAllocate;
				Impl.Pointer  = Impl->Allocate(Max());

				Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, InsertIndex);

				for (size_t Index = InsertIndex; Index != InsertIndex + Count; ++Index)
				{
					new (Impl.Pointer + Index) FElementType(*First++);
				}

				Memory::MoveConstruct<FElementType>(Impl.Pointer + InsertIndex + Count, OldAllocation + InsertIndex, NumToDestruct - InsertIndex);

				Memory::Destruct(OldAllocation, NumToDestruct);
				Impl->Deallocate(OldAllocation);

				return FIterator(this, Impl.Pointer + InsertIndex);
			}

			/*
			 * NO(XA) - No Operation
			 * IA(AB) - Insert Assignment
			 * IC(BC) - Insert Construction
			 * MA(CD) - Move Assignment
			 * MC(DO) - Move Construction
			 *
			 * IR(AC) - Insert Range
			 * UI(UO) - Uninitialized
			 *
			 * |X|-------------------| |-UI-|O|
			 * |X|----|A|-IR-| C|-----------|O|
			 * |X|-NO-|A|-IA-|BC|-MA-|D|-MC-|O|
			 *
			 * |X|-----------------|   |-UI-|O|
			 * |X|----------|A|-IR-| CD|----|O|
			 * |X|----NO----|A|-IA-|BCD|-MC-|O|
			 *
			 * |X|-----------| |-----UI-----|O|
			 * |X|----|A|----IR-----|C |----|O|
			 * |X|-NO-|A|-IA-|B|-IC-|CD|-MC-|O|
			 *
			 * |X|----------------|  |-UI-|  O|
			 * |X|----------------|A |-IR-|C O|
			 * |X|-------NO-------|AB|-IC-|CDO|
			 *
			 * |X|-----------| |----UI----|  O|
			 * |X|----------------|A |-IR-|C O|
			 * |X|-------NO-------|AB|-IC-|CDO|
			 */

			const size_t IndexA = InsertIndex;
			const size_t IndexC = InsertIndex + Count;
			const size_t IndexB = Num() > IndexA ? (Num() < IndexC ? Num() : IndexC) : IndexA;
			const size_t IndexD = Num() > IndexC ? Num() : IndexC;
			const size_t IndexO = Num() + Count;

			for (size_t TargetIndex = IndexO - 1; TargetIndex != IndexD - 1; --TargetIndex)
			{
				new (Impl.Pointer + TargetIndex) FElementType(MoveTemp(Impl.Pointer[TargetIndex - Count]));
			}

			for (size_t TargetIndex = IndexD - 1; TargetIndex != IndexC - 1; --TargetIndex)
			{
				Impl.Pointer[TargetIndex] = MoveTemp(Impl.Pointer[TargetIndex - Count]);
			}

			for (size_t TargetIndex = IndexA; TargetIndex != IndexB; ++TargetIndex)
			{
				Impl.Pointer[TargetIndex] = *First++;
			}

			for (size_t TargetIndex = IndexB; TargetIndex != IndexC; ++TargetIndex)
			{
				new (Impl.Pointer + TargetIndex) FElementType(*First++);
			}

			check(First == Last);

			Impl.ArrayNum = Num() + Count;

			return FIterator(this, Impl.Pointer + InsertIndex);
		}
		else
		{
			TArray Temp(MoveTemp(First), MoveTemp(Last));
			return Insert(Iter, MakeMoveIterator(Temp.Begin()), MakeMoveSentinel(Temp.End()));
		}
	}

	/** Inserts elements from range before 'Iter'. */
	template <CInputRange R> requires (CConstructibleFrom<T, TRangeReference<R>> && CAssignableFrom<T&, TRangeReference<R>> && CMovable<T>)
	FORCEINLINE FIterator Insert(FConstIterator Iter, R&& Range)
	{
		return Insert(Iter, Range::Begin(Range), Range::End(Range));
	}

	/** Inserts elements from initializer list before 'Iter' in the container. */
	FORCEINLINE FIterator Insert(FConstIterator Iter, initializer_list<FElementType> IL) requires (CCopyable<T>)
	{
		return Insert(Iter, Range::Begin(IL), Range::End(IL));
	}

	/** Inserts a new element into the container directly before 'Iter'. */
	template <typename... Ts> requires (CConstructibleFrom<T, Ts...> && CMovable<T>)
	FIterator Emplace(FConstIterator Iter, Ts&&... Args)
	{
		checkf(IsValidIterator(Iter), TEXT("Read access violation. Please check IsValidIterator()."));

		const size_t InsertIndex = Iter - Begin();

		const size_t NumToAllocate = Num() + 1 > Max() ? Impl->CalculateSlackGrow(Num() + 1, Max()) : Max();

		check(NumToAllocate >= Num() + 1);

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Num() + 1;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, InsertIndex);
			new (Impl.Pointer + InsertIndex) FElementType(Forward<Ts>(Args)...);
			Memory::MoveConstruct<FElementType>(Impl.Pointer + InsertIndex + 1, OldAllocation + InsertIndex, NumToDestruct - InsertIndex);

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return FIterator(this, Impl.Pointer + InsertIndex);
		}

		if (InsertIndex != Num())
		{
			new (Impl.Pointer + Num()) FElementType(MoveTemp(Impl.Pointer[Num() - 1]));

			for (size_t Index = Num() - 1; Index != InsertIndex; --Index)
			{
				Impl.Pointer[Index] = MoveTemp(Impl.Pointer[Index - 1]);
			}

			Impl.Pointer[InsertIndex] = FElementType(Forward<Ts>(Args)...);
		}
		else new (Impl.Pointer + Num()) FElementType(Forward<Ts>(Args)...);

		Impl.ArrayNum = Num() + 1;

		return FIterator(this, Impl.Pointer + InsertIndex);
	}

	/** Removes the element at 'Iter' in the container. Without changing the order of elements. */
	FORCEINLINE FIterator StableErase(FConstIterator Iter, bool bAllowShrinking = true) requires (CMovable<T>)
	{
		checkf(IsValidIterator(Iter) && Iter != End(), TEXT("Read access violation. Please check IsValidIterator()."));

		return StableErase(Iter, Iter + 1, bAllowShrinking);
	}

	/** Removes the elements in the range ['First', 'Last') in the container. Without changing the order of elements. */
	FIterator StableErase(FConstIterator First, FConstIterator Last, bool bAllowShrinking = true) requires (CMovable<T>)
	{
		checkf(IsValidIterator(First) && IsValidIterator(Last) && First <= Last, TEXT("Read access violation. Please check IsValidIterator()."));

		const size_t EraseIndex = First - Begin();
		const size_t EraseCount = Last - First;

		if (EraseCount == 0) return FIterator(this, Impl.Pointer + EraseIndex);

		const size_t NumToAllocate = bAllowShrinking ? Impl->CalculateSlackShrink(Num() - EraseCount, Max()) : Max();

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Num() - EraseCount;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, EraseIndex);
			Memory::MoveConstruct<FElementType>(Impl.Pointer + EraseIndex, OldAllocation + EraseIndex + EraseCount, NumToDestruct - EraseIndex - EraseCount);

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return FIterator(this, Impl.Pointer + EraseIndex);
		}

		for (size_t Index = EraseIndex + EraseCount; Index != Num(); ++Index)
		{
			Impl.Pointer[Index - EraseCount] = MoveTemp(Impl.Pointer[Index]);
		}

		Memory::Destruct(Impl.Pointer + Num() - EraseCount, EraseCount);

		Impl.ArrayNum = Num() - EraseCount;

		return FIterator(this, Impl.Pointer + EraseIndex);
	}

	/** Removes the element at 'Iter' in the container. But it may change the order of elements. */
	FORCEINLINE FIterator Erase(FConstIterator Iter, bool bAllowShrinking = true) requires (CMovable<T>)
	{
		checkf(IsValidIterator(Iter) && Iter != End(), TEXT("Read access violation. Please check IsValidIterator()."));

		return Erase(Iter, Iter + 1, bAllowShrinking);
	}

	/** Removes the elements in the range ['First', 'Last') in the container. But it may change the order of elements. */
	FIterator Erase(FConstIterator First, FConstIterator Last, bool bAllowShrinking = true) requires (CMovable<T>)
	{
		checkf(IsValidIterator(First) && IsValidIterator(Last) && First <= Last, TEXT("Read access violation. Please check IsValidIterator()."));

		const size_t EraseIndex = First - Begin();
		const size_t EraseCount = Last - First;

		if (EraseCount == 0) return FIterator(this, Impl.Pointer + EraseIndex);

		const size_t NumToAllocate = bAllowShrinking ? Impl->CalculateSlackShrink(Num() - EraseCount, Max()) : Max();

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Num() - EraseCount;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, EraseIndex);
			Memory::MoveConstruct<FElementType>(Impl.Pointer + EraseIndex, OldAllocation + EraseIndex + EraseCount, NumToDestruct - EraseIndex - EraseCount);

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return FIterator(this, Impl.Pointer + EraseIndex);
		}

		for (size_t Index = 0; Index != EraseCount; ++Index)
		{
			if (EraseIndex + Index >= Num() - EraseCount) break;

			Impl.Pointer[EraseIndex + Index] = MoveTemp(Impl.Pointer[Num() - Index - 1]);
		}

		Memory::Destruct(Impl.Pointer + Num() - EraseCount, EraseCount);

		Impl.ArrayNum = Num() - EraseCount;

		return FIterator(this, Impl.Pointer + EraseIndex);
	}

	/** Appends the given element value to the end of the container. */
	FORCEINLINE void PushBack(const FElementType& InValue) requires (CCopyable<T>)
	{
		EmplaceBack(InValue);
	}

	/** Appends the given element value to the end of the container. */
	FORCEINLINE void PushBack(FElementType&& InValue) requires (CMovable<T>)
	{
		EmplaceBack(MoveTemp(InValue));
	}

	/** Appends a new element to the end of the container. */
	template <typename... Ts> requires (CConstructibleFrom<T, Ts...> && CMovable<T>)
	FElementType& EmplaceBack(Ts&&... Args)
	{
		const size_t NumToAllocate = Num() + 1 > Max() ? Impl->CalculateSlackGrow(Num() + 1, Max()) : Max();

		check(NumToAllocate >= Num() + 1);

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Num() + 1;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, Num() - 1);
			new (Impl.Pointer + Num() - 1) FElementType(Forward<Ts>(Args)...);

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return Impl.Pointer[Num() - 1];
		}

		new (Impl.Pointer + Num()) FElementType(Forward<Ts>(Args)...);

		Impl.ArrayNum = Num() + 1;

		return Impl.Pointer[Num() - 1];
	}

	/** Removes the last element of the container. The array cannot be empty. */
	FORCEINLINE void PopBack(bool bAllowShrinking = true) requires (CMovable<T>)
	{
		Erase(End() - 1, bAllowShrinking);
	}

	/** Resizes the container to contain 'Count' elements. Additional default elements are appended. */
	void SetNum(size_t Count, bool bAllowShrinking = true) requires (CDefaultConstructible<T> && CMovable<T>)
	{
		size_t NumToAllocate = Count;

		NumToAllocate = NumToAllocate > Max()                    ? Impl->CalculateSlackGrow(Count, Max())            : NumToAllocate;
		NumToAllocate = NumToAllocate < Max() ? (bAllowShrinking ? Impl->CalculateSlackShrink(Count, Max()) : Max()) : NumToAllocate;

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Count;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			if (NumToDestruct <= Num())
			{
				Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, NumToDestruct);
				Memory::DefaultConstruct<FElementType>(Impl.Pointer + NumToDestruct, Num() - NumToDestruct);
			}
			else
			{
				Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, Num());
			}

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return;
		}

		if (Count <= Num())
		{
			Memory::Destruct(Impl.Pointer + Count, Num() - Count);
		}
		else if (Count <= Max())
		{
			Memory::DefaultConstruct<FElementType>(Impl.Pointer + Num(), Count - Num());
		}
		else check_no_entry();

		Impl.ArrayNum = Count;
	}

	/** Resizes the container to contain 'Count' elements. Additional copies of 'InValue' are appended. */
	void SetNum(size_t Count, const FElementType& InValue, bool bAllowShrinking = true) requires (CCopyConstructible<T> && CMovable<T>)
	{
		size_t NumToAllocate = Count;

		NumToAllocate = NumToAllocate > Max()                    ? Impl->CalculateSlackGrow(Count, Max())            : NumToAllocate;
		NumToAllocate = NumToAllocate < Max() ? (bAllowShrinking ? Impl->CalculateSlackShrink(Count, Max()) : Max()) : NumToAllocate;

		if (NumToAllocate != Max())
		{
			FElementType* OldAllocation = Impl.Pointer;
			const size_t  NumToDestruct = Num();

			Impl.ArrayNum = Count;
			Impl.ArrayMax = NumToAllocate;
			Impl.Pointer  = Impl->Allocate(Max());

			if (NumToDestruct <= Num())
			{
				Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, NumToDestruct);

				for (size_t Index = NumToDestruct; Index != Num(); ++Index)
				{
					new (Impl.Pointer + Index) FElementType(InValue);
				}
			}
			else
			{
				Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, Num());
			}

			Memory::Destruct(OldAllocation, NumToDestruct);
			Impl->Deallocate(OldAllocation);

			return;
		}

		if (Count <= Num())
		{
			Memory::Destruct(Impl.Pointer + Count, Num() - Count);
		}
		else if (Count <= Max())
		{
			for (size_t Index = Num(); Index != Count; ++Index)
			{
				new (Impl.Pointer + Index) FElementType(InValue);
			}
		}
		else check_no_entry();

		Impl.ArrayNum = Count;
	}

	/** Increase the max capacity of the array to a value that's greater or equal to 'Count'. */
	void Reserve(size_t Count) requires (CMovable<T>)
	{
		if (Count <= Max()) return;

		const size_t  NumToAllocate = Impl->CalculateSlackReserve(Count);
		FElementType* OldAllocation = Impl.Pointer;

		check(NumToAllocate > Max());

		Impl.ArrayMax = NumToAllocate;
		Impl.Pointer  = Impl->Allocate(Max());

		Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, Num());

		Memory::Destruct(OldAllocation, Num());
		Impl->Deallocate(OldAllocation);
	}

	/** Requests the removal of unused capacity. */
	void Shrink()
	{
		size_t NumToAllocate = Impl->CalculateSlackReserve(Num());

		check(NumToAllocate <= Max());

		if (NumToAllocate == Max()) return;

		FElementType* OldAllocation = Impl.Pointer;

		Impl.ArrayMax = NumToAllocate;
		Impl.Pointer  = Impl->Allocate(Max());

		Memory::MoveConstruct<FElementType>(Impl.Pointer, OldAllocation, Num());
		Memory::Destruct(OldAllocation, Num());

		Impl->Deallocate(OldAllocation);
	}

	/** @return The pointer to the underlying element storage. */
	NODISCARD FORCEINLINE       FElementType* GetData()       { return Impl.Pointer; }
	NODISCARD FORCEINLINE const FElementType* GetData() const { return Impl.Pointer; }

	/** @return The iterator to the first or end element. */
	NODISCARD FORCEINLINE      FIterator Begin()       { return      FIterator(this, Impl.Pointer);         }
	NODISCARD FORCEINLINE FConstIterator Begin() const { return FConstIterator(this, Impl.Pointer);         }
	NODISCARD FORCEINLINE      FIterator End()         { return      FIterator(this, Impl.Pointer + Num()); }
	NODISCARD FORCEINLINE FConstIterator End()   const { return FConstIterator(this, Impl.Pointer + Num()); }

	/** @return The reverse iterator to the first or end element. */
	NODISCARD FORCEINLINE      FReverseIterator RBegin()       { return      FReverseIterator(End());   }
	NODISCARD FORCEINLINE FConstReverseIterator RBegin() const { return FConstReverseIterator(End());   }
	NODISCARD FORCEINLINE      FReverseIterator REnd()         { return      FReverseIterator(Begin()); }
	NODISCARD FORCEINLINE FConstReverseIterator REnd()   const { return FConstReverseIterator(Begin()); }

	/** @return The number of elements in the container. */
	NODISCARD FORCEINLINE size_t Num() const { return Impl.ArrayNum; }

	/** @return The number of elements that can be held in currently allocated storage. */
	NODISCARD FORCEINLINE size_t Max() const { return Impl.ArrayMax; }

	/** @return true if the container is empty, false otherwise. */
	NODISCARD FORCEINLINE bool IsEmpty() const { return Num() == 0; }

	/** @return true if the iterator is valid, false otherwise. */
	NODISCARD FORCEINLINE bool IsValidIterator(FConstIterator Iter) const { return Begin() <= Iter && Iter <= End(); }

	/** @return The reference to the requested element. */
	NODISCARD FORCEINLINE       FElementType& operator[](size_t Index)       { checkf(Index < Num(), TEXT("Read access violation. Please check IsValidIterator().")); return Impl.Pointer[Index]; }
	NODISCARD FORCEINLINE const FElementType& operator[](size_t Index) const { checkf(Index < Num(), TEXT("Read access violation. Please check IsValidIterator().")); return Impl.Pointer[Index]; }

	/** @return The reference to the first or last element. */
	NODISCARD FORCEINLINE       FElementType& Front()       { return *Begin();     }
	NODISCARD FORCEINLINE const FElementType& Front() const { return *Begin();     }
	NODISCARD FORCEINLINE       FElementType& Back()        { return *(End() - 1); }
	NODISCARD FORCEINLINE const FElementType& Back()  const { return *(End() - 1); }

	/** Erases all elements from the container. After this call, Num() returns zero. */
	void Reset(bool bAllowShrinking = true)
	{
		const size_t NumToAllocate = Impl->CalculateSlackReserve(0);

		if (bAllowShrinking && NumToAllocate != Max())
		{
			Memory::Destruct(Impl.Pointer, Num());
			Impl->Deallocate(Impl.Pointer);

			Impl.ArrayNum = 0;
			Impl.ArrayMax = Impl->CalculateSlackReserve(Num());
			Impl.Pointer  = Impl->Allocate(Max());

			return;
		}

		Memory::Destruct(Impl.Pointer, Num());
		Impl.ArrayNum = 0;
	}

	/** Overloads the GetTypeHash algorithm for TArray. */
	NODISCARD friend FORCEINLINE size_t GetTypeHash(const TArray& A) requires (CHashable<T>)
	{
		size_t Result = 0;

		for (FConstIterator Iter = A.Begin(); Iter != A.End(); ++Iter)
		{
			Result = HashCombine(Result, GetTypeHash(*Iter));
		}

		return Result;
	}

	/** Overloads the Swap algorithm for TArray. */
	friend void Swap(TArray& A, TArray& B) requires (CMovable<T>)
	{
		const bool bIsTransferable =
			A.Impl->IsTransferable(A.Impl.Pointer) &&
			B.Impl->IsTransferable(B.Impl.Pointer);

		if (bIsTransferable)
		{
			Swap(A.Impl.ArrayNum, B.Impl.ArrayNum);
			Swap(A.Impl.ArrayMax, B.Impl.ArrayMax);
			Swap(A.Impl.Pointer,  B.Impl.Pointer);

			return;
		}

		TArray Temp = MoveTemp(A);
		A = MoveTemp(B);
		B = MoveTemp(Temp);
	}

	ENABLE_RANGE_BASED_FOR_LOOP_SUPPORT

private:

	ALLOCATOR_WRAPPER_BEGIN(FAllocatorType, FElementType, Impl)
	{
		size_t ArrayNum;
		size_t ArrayMax;
		FElementType* Pointer;
	}
	ALLOCATOR_WRAPPER_END(FAllocatorType, FElementType, Impl)

private:

	template <bool bConst, typename U>
	class TIteratorImpl final
	{
	public:

		using FElementType = T;

		FORCEINLINE TIteratorImpl() = default;

#		if DO_CHECK
		FORCEINLINE TIteratorImpl(const TIteratorImpl<false>& InValue) requires (bConst)
			: Owner(InValue.Owner), Pointer(InValue.Pointer)
		{ }
#		else
		FORCEINLINE TIteratorImpl(const TIteratorImpl<false>& InValue) requires (bConst)
			: Pointer(InValue.Pointer)
		{ }
#		endif

		FORCEINLINE TIteratorImpl(const TIteratorImpl&)            = default;
		FORCEINLINE TIteratorImpl(TIteratorImpl&&)                 = default;
		FORCEINLINE TIteratorImpl& operator=(const TIteratorImpl&) = default;
		FORCEINLINE TIteratorImpl& operator=(TIteratorImpl&&)      = default;

		NODISCARD friend FORCEINLINE bool operator==(const TIteratorImpl& LHS, const TIteratorImpl& RHS) { return LHS.Pointer == RHS.Pointer; }

		NODISCARD friend FORCEINLINE strong_ordering operator<=>(const TIteratorImpl& LHS, const TIteratorImpl& RHS) { return LHS.Pointer <=> RHS.Pointer; }

		NODISCARD FORCEINLINE U& operator*()  const { CheckThis(true ); return *Pointer; }
		NODISCARD FORCEINLINE U* operator->() const { CheckThis(false); return  Pointer; }

		NODISCARD FORCEINLINE U& operator[](ptrdiff Index) const { TIteratorImpl Temp = *this + Index; return *Temp; }

		FORCEINLINE TIteratorImpl& operator++() { ++Pointer; CheckThis(); return *this; }
		FORCEINLINE TIteratorImpl& operator--() { --Pointer; CheckThis(); return *this; }

		FORCEINLINE TIteratorImpl operator++(int) { TIteratorImpl Temp = *this; ++*this; return Temp; }
		FORCEINLINE TIteratorImpl operator--(int) { TIteratorImpl Temp = *this; --*this; return Temp; }

		FORCEINLINE TIteratorImpl& operator+=(ptrdiff Offset) { Pointer += Offset; CheckThis(); return *this; }
		FORCEINLINE TIteratorImpl& operator-=(ptrdiff Offset) { Pointer -= Offset; CheckThis(); return *this; }

		NODISCARD friend FORCEINLINE TIteratorImpl operator+(TIteratorImpl Iter, ptrdiff Offset) { TIteratorImpl Temp = Iter; Temp += Offset; return Temp; }
		NODISCARD friend FORCEINLINE TIteratorImpl operator+(ptrdiff Offset, TIteratorImpl Iter) { TIteratorImpl Temp = Iter; Temp += Offset; return Temp; }

		NODISCARD FORCEINLINE TIteratorImpl operator-(ptrdiff Offset) const { TIteratorImpl Temp = *this; Temp -= Offset; return Temp; }

		NODISCARD friend FORCEINLINE ptrdiff operator-(const TIteratorImpl& LHS, const TIteratorImpl& RHS) { LHS.CheckThis(); RHS.CheckThis(); return LHS.Pointer - RHS.Pointer; }

	private:

#		if DO_CHECK
		const TArray* Owner = nullptr;
#		endif

		U* Pointer = nullptr;

#		if DO_CHECK
		FORCEINLINE TIteratorImpl(const TArray* InContainer, U* InPointer)
			: Owner(InContainer), Pointer(InPointer)
		{ }
#		else
		FORCEINLINE TIteratorImpl(const TArray* InContainer, U* InPointer)
			: Pointer(InPointer)
		{ }
#		endif

		FORCEINLINE void CheckThis(bool bExceptEnd = false) const
		{
			checkf(Owner && Owner->IsValidIterator(*this), TEXT("Read access violation. Please check IsValidIterator()."));
			checkf(!(bExceptEnd && Owner->End() == *this), TEXT("Read access violation. Please check IsValidIterator()."));
		}

		template <bool, typename> friend class TIteratorImpl;

		friend TArray;

	};

};

template <typename I, typename S>
TArray(I, S) -> TArray<TIteratorElement<I>>;

template <typename R>
TArray(R) -> TArray<TRangeElement<R>>;

template <typename T>
TArray(initializer_list<T>) -> TArray<T>;

NAMESPACE_MODULE_END(Utility)
NAMESPACE_MODULE_END(Redcraft)
NAMESPACE_REDCRAFT_END