using BenchmarkDotNet.Attributes;
using System.Buffers;
using System.Collections;
using System.Numerics;
using System.Runtime.CompilerServices;

namespace Recyclable.Collections.Benchmarks.POC
{
	public partial class RecyclableListPocBenchmarks
	{
		#region Old class

		private class OldRecyclableList<T> : IDisposable, IList<T>
		{
			private const int ItemNotFoundIndex = -1;

			private static readonly ArrayPool<T[]> _defaultMemoryBlocksPool = ArrayPool<T[]>.Create();
			private static readonly ArrayPool<T> _defaultBlockArrayPool = ArrayPool<T>.Create();
			private static readonly T[][] _emptyMemoryBlocksArray = new T[0][];
			private static readonly T[] _emptyBlockArray = new T[0];

			private int _blockSize;
			private int _blockSizePow2Shift;
			private int _nextItemBlockIndex;
			private int _nextItemIndex;

			protected static readonly bool NeedsClearing = !typeof(T).IsValueType;

			protected ArrayPool<T[]> _memoryBlocksPool;
			protected ArrayPool<T> _blockArrayPool;
			protected T[][] _memoryBlocks;

			private long _capacity;
			public long Capacity
			{
				get => _capacity;
				protected set => _capacity = value;
			}

			public int Count => checked((int)_longCount);
			public bool IsReadOnly { get; }
			public int LastTakenBlockIndex => _nextItemBlockIndex - (_nextItemIndex > 0 ? 0 : 1);

			protected long _longCount;

			public long LongCount
			{
				get => _longCount;
				set => _longCount = value;
			}

			public int ReservedBlockCount => (int)(_capacity >> _blockSizePow2Shift) + ((_capacity & (_blockSize - 1)) > 0 ? 1 : 0);
			public int BlockSize => _blockSize;
			public int NextItemBlockIndex => _nextItemBlockIndex;
			public int NextItemIndex => _nextItemIndex;

			[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
			private void DoRemoveAt(long index)
			{
				int blockSize = _blockSize;
				int nextItemIndex = _nextItemIndex;
				T[][] memoryBlocks = _memoryBlocks;
				_longCount--;
				if (index < _longCount)
				{
					int sourceBlockIndex = (int)((index + 1) >> _blockSizePow2Shift);
					int sourceItemIndex = (int)((index + 1) & (blockSize - 1));

					int targetBlockIndex = (int)(index >> _blockSizePow2Shift);
					int targetItemIndex = (int)(index & (blockSize - 1));

					int lastTakenBlockIndex = LastTakenBlockIndex;
					while (sourceBlockIndex < lastTakenBlockIndex || (sourceBlockIndex == lastTakenBlockIndex && (sourceItemIndex < nextItemIndex || sourceBlockIndex != _nextItemBlockIndex)))
					{
						int toCopy = sourceBlockIndex < lastTakenBlockIndex || nextItemIndex == 0
							? Math.Min(blockSize - sourceItemIndex, blockSize - targetItemIndex)
							: Math.Min(nextItemIndex, blockSize - targetItemIndex);

						Array.Copy(memoryBlocks[sourceBlockIndex], sourceItemIndex, memoryBlocks[targetBlockIndex], targetItemIndex, toCopy);
						// We didn't have enough room in the target array block. There are still items in the source array block to copy.
						if (sourceItemIndex + toCopy < blockSize)
						{
							sourceItemIndex += toCopy;
							targetBlockIndex++;
							targetItemIndex = 0;
						}
						// We copied all the source items in the current array block. But have we filled the target?
						else
						{
							sourceItemIndex = 0;
							sourceBlockIndex++;
							if (targetItemIndex + toCopy < blockSize)
							{
								targetItemIndex += toCopy;
							}
							else
							{
								targetBlockIndex++;
								targetItemIndex = 0;
							}
						}
					}
				}

				if (nextItemIndex > 0)
				{
					_nextItemIndex--;
				}
				else
				{
					_nextItemIndex = blockSize - 1;
					_nextItemBlockIndex--;
				}

				if (NeedsClearing)
				{
#pragma warning disable CS8601 // In real use cases we'll never access it
					new Span<T>(memoryBlocks[_nextItemBlockIndex], _nextItemIndex, 1)[0] = default;
#pragma warning restore CS8601
				}
			}

			private static void ThrowArgumentOutOfRangeException(in string message) => throw new ArgumentOutOfRangeException("index", message);

			protected void AddRangeEnumerated(IEnumerable<T> source, int growByCount)
			{
				long i, copied = _longCount;

				int blockSize = _blockSize, targetItemIdx = _nextItemIndex, targetBlockIdx = _nextItemBlockIndex;

				using IEnumerator<T> enumerator = source.GetEnumerator();
				if (!enumerator.MoveNext())
				{
					return;
				}

				long capacity = _capacity;
				long available = capacity - copied;

				Span<T[]> memoryBlocksSpan = new(_memoryBlocks, 0, ReservedBlockCount);
				Span<T> blockArraySpan;
				var memoryBlocksCount = memoryBlocksSpan.Length;
				while (true)
				{
					if (copied + growByCount > capacity)
					{
						capacity = EnsureCapacity(capacity + growByCount);
						memoryBlocksCount = _memoryBlocks.Length;
						if (blockSize != _blockSize)
						{
							blockSize = _blockSize;
						}

						memoryBlocksSpan = new(_memoryBlocks, 0, memoryBlocksCount);
						available = capacity - copied;
					}

					blockArraySpan = new(memoryBlocksSpan[targetBlockIdx], 0, blockSize);
					for (i = 1; i <= available; i++)
					{
						blockArraySpan[targetItemIdx++] = enumerator.Current;

						if (!enumerator.MoveNext())
						{
							if (targetItemIdx < blockSize)
							{
								_nextItemBlockIndex = targetBlockIdx;
								_nextItemIndex = targetItemIdx;
							}
							else
							{
								_nextItemBlockIndex = targetBlockIdx + 1;
								_nextItemIndex = 0;
							}

							_longCount += copied + i - _longCount;
							return;
						}

						if (targetItemIdx == blockSize)
						{
							targetBlockIdx++;
							targetItemIdx = 0;

							if (targetBlockIdx == memoryBlocksCount)
							{
								break;
							}

							blockArraySpan = new(memoryBlocksSpan[targetBlockIdx], 0, blockSize);
						}
					}

					copied += available;
				}
			}

			protected void AddRangeWithKnownCount(IEnumerable<T> source, int requiredAdditionalCapacity)
			{
				long copied = _longCount;
				int blockSize = _blockSize;
				int targetItemIdx = _nextItemIndex;
				int targetBlockIdx = _nextItemBlockIndex;

				Span<T[]> memoryBlocksSpan;
				Span<T> blockArraySpan;
				long requiredCapacity = copied + requiredAdditionalCapacity;
				if (_capacity < requiredCapacity)
				{
					_ = EnsureCapacity(requiredCapacity);
					blockSize = _blockSize;
				}

				var memoryBlocksCount = ReservedBlockCount;
				memoryBlocksSpan = new(_memoryBlocks, 0, memoryBlocksCount);
				blockArraySpan = new Span<T>(memoryBlocksSpan[targetBlockIdx], 0, blockSize);
				foreach (var item in source)
				{
					blockArraySpan[targetItemIdx++] = item;
					if (targetItemIdx == blockSize)
					{
						targetBlockIdx++;
						targetItemIdx = 0;
						if (targetBlockIdx == memoryBlocksCount)
						{
							break;
						}

						blockArraySpan = new Span<T>(memoryBlocksSpan[targetBlockIdx], 0, blockSize);
					}
				}

				_longCount = requiredCapacity;
				_nextItemBlockIndex = targetBlockIdx;
				_nextItemIndex = targetItemIdx;
				return;
			}

			protected static long DoIndexOf(T item, in T[][] memoryBlocks, int lastBlockIndex, int blockSize, int nextItemIndex)
			{
				Span<T[]> memoryBlocksSpan = new(memoryBlocks, 0, lastBlockIndex + 1);
				int itemIndex, blockIndex;
				for (blockIndex = 0; blockIndex < lastBlockIndex; blockIndex++)
				{
					itemIndex = Array.IndexOf(memoryBlocksSpan[blockIndex], item, 0, blockSize);
					if (itemIndex >= 0)
					{
						return itemIndex + (blockIndex << (31 - BitOperations.LeadingZeroCount((uint)blockSize)));
					}
				}

				if (blockIndex == lastBlockIndex)
				{
					itemIndex = nextItemIndex != 0
						? Array.IndexOf(memoryBlocksSpan[lastBlockIndex], item, 0, nextItemIndex)
						: Array.IndexOf(memoryBlocksSpan[lastBlockIndex], item, 0, blockSize);
				}
				else
				{
					return ItemNotFoundIndex;
				}

				return itemIndex >= 0 ? itemIndex + (lastBlockIndex << (31 - BitOperations.LeadingZeroCount((uint)blockSize))) : ItemNotFoundIndex;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			protected static long Resize(ref T[][]? source, int minBlockSize, long oldCapacity, long newCapacity, ArrayPool<T[]> memoryBlocksPool, ArrayPool<T> blockArrayPool)
			{
				int minBlockSizePowerToShift = 31 - BitOperations.LeadingZeroCount((uint)minBlockSize);
				int sourceBlockCount = (int)(oldCapacity >> minBlockSizePowerToShift);
				int requiredBlockCount = (int)(newCapacity >> minBlockSizePowerToShift) + ((newCapacity & (minBlockSize - 1)) > 0 ? 1 : 0);
				int blockIndex;
				T[][]? newMemoryBlocks;
				Span<T[]> memoryBlocksSpan;

				// Release excessive blocks if we're downsizing
				if (requiredBlockCount < sourceBlockCount && (minBlockSize >= RecyclableDefaults.MinPooledArrayLength))
				{
					memoryBlocksSpan = new(source, requiredBlockCount, sourceBlockCount - requiredBlockCount);
					blockIndex = 0;
					while (blockIndex < memoryBlocksSpan.Length)
					{
						blockArrayPool.Return(memoryBlocksSpan[blockIndex++]!, NeedsClearing);
					}
				}

				// Allocate new memory block for all arrays
				newMemoryBlocks = requiredBlockCount < RecyclableDefaults.MinPooledArrayLength
					? (new T[requiredBlockCount][])
					: memoryBlocksPool.Rent(requiredBlockCount);

				// Copy arrays from the old memory block for all arrays
				if (sourceBlockCount > 0)
				{
					Array.Copy(source!, newMemoryBlocks, sourceBlockCount);
					// We can now return the old memory block for all arrays itself
					if (sourceBlockCount >= RecyclableDefaults.MinPooledArrayLength)
					{
						memoryBlocksPool.Return(source!, true);
					}
				}

				source = newMemoryBlocks;

				// Allocate arrays for any new blocks
				if (requiredBlockCount > sourceBlockCount)
				{
					memoryBlocksSpan = new(newMemoryBlocks, sourceBlockCount, newMemoryBlocks.Length - sourceBlockCount);
					if (minBlockSize >= RecyclableDefaults.MinPooledArrayLength)
					{
						if (sourceBlockCount == 0)
						{
							memoryBlocksSpan[0] = blockArrayPool.Rent(minBlockSize);
							minBlockSize = memoryBlocksSpan[0].Length;
							blockIndex = 1;
						}
						else
						{
							blockIndex = 0;
						}

						while (blockIndex < memoryBlocksSpan.Length)
						{
							memoryBlocksSpan[blockIndex++] = blockArrayPool.Rent(minBlockSize);
						}
					}
					else
					{
						blockIndex = 0;
						while (blockIndex < memoryBlocksSpan.Length)
						{
							memoryBlocksSpan[blockIndex++] = new T[minBlockSize];
						}
					}
				}

				return newMemoryBlocks.Length << minBlockSizePowerToShift;
			}

			internal long EnsureCapacity(long requestedCapacity)
			{
				long newCapacity = _capacity > 0
					? checked((long)BitOperations.RoundUpToPowerOf2((ulong)requestedCapacity))
					: requestedCapacity;

				newCapacity = Resize(ref _memoryBlocks!, _blockSize, _capacity, newCapacity, _memoryBlocksPool, _blockArrayPool);
				if (newCapacity > 0 && _capacity == 0)
				{
					_blockSize = _memoryBlocks[0].Length;
					_blockSizePow2Shift = MathUtils.GetPow2Shift(_blockSize);
				}

				_capacity = newCapacity;
				return newCapacity;
			}

			public OldRecyclableList(int minBlockSize = RecyclableDefaults.BlockSize, long? expectedItemsCount = default, ArrayPool<T[]>? memoryBlocksPool = default, ArrayPool<T>? blockArrayPool = default)
			{
				memoryBlocksPool ??= _defaultMemoryBlocksPool;
				blockArrayPool ??= _defaultBlockArrayPool;
				_memoryBlocksPool = memoryBlocksPool;
				_blockArrayPool = blockArrayPool;

				if (expectedItemsCount > 0)
				{
					_capacity = Resize(ref _memoryBlocks!, (int)BitOperations.RoundUpToPowerOf2((uint)minBlockSize), 0, expectedItemsCount.Value, memoryBlocksPool, blockArrayPool);
					if (_memoryBlocks.Length > 0)
					{
						minBlockSize = _memoryBlocks[0].Length;
					}

					_blockSize = minBlockSize;
					_blockSizePow2Shift = MathUtils.GetPow2Shift(minBlockSize);
				}
				else
				{
					_blockSize = (int)BitOperations.RoundUpToPowerOf2((uint)minBlockSize);
					_blockSizePow2Shift = MathUtils.GetPow2Shift(minBlockSize);
					_memoryBlocks = _emptyMemoryBlocksArray;
				}
			}

			public OldRecyclableList(IEnumerable<T> source, int minBlockSize = RecyclableDefaults.BlockSize, long? expectedItemsCount = default, ArrayPool<T[]>? memoryBlocksPool = default, ArrayPool<T>? blockArrayPool = default)
			{
				memoryBlocksPool ??= _defaultMemoryBlocksPool;
				blockArrayPool ??= _defaultBlockArrayPool;
				_memoryBlocksPool = memoryBlocksPool;
				_blockArrayPool = blockArrayPool;

				if (expectedItemsCount > 0)
				{
					_capacity = Resize(ref _memoryBlocks!, (int)BitOperations.RoundUpToPowerOf2((uint)minBlockSize), 0, expectedItemsCount.Value, memoryBlocksPool, blockArrayPool);
					if (_memoryBlocks.Length > 0)
					{
						minBlockSize = _memoryBlocks[0].Length;
					}

					_blockSize = minBlockSize;
					_blockSizePow2Shift = MathUtils.GetPow2Shift(minBlockSize);
				}
				else
				{
					_blockSize = (int)BitOperations.RoundUpToPowerOf2((uint)minBlockSize);
					_blockSizePow2Shift = MathUtils.GetPow2Shift(minBlockSize);
					_memoryBlocks = _emptyMemoryBlocksArray;
				}

				AddRange(source);
			}

			public T this[long index]
			{
				get => _memoryBlocks[index >> _blockSizePow2Shift][index & (_blockSize - 1)];
				set => new Span<T>(_memoryBlocks[(int)(index >> _blockSizePow2Shift)])[(int)(index & (_blockSize - 1))] = value;
			}

			public T this[int index]
			{
				get => _memoryBlocks[index >> _blockSizePow2Shift][index & (_blockSize - 1)];
				set => new Span<T>(_memoryBlocks[index >> _blockSizePow2Shift])[index & (_blockSize - 1)] = value;
			}

			public T[][] MemoryBlocks { get => _memoryBlocks; }

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Add(T item)
			{
				if (_capacity < _longCount + 1)
				{
					_ = EnsureCapacity(_longCount + 1);
				}

				_memoryBlocks[_nextItemBlockIndex][_nextItemIndex++] = item;
				if (_nextItemIndex == _blockSize)
				{
					_nextItemBlockIndex++;
					_nextItemIndex = 0;
				}

				_longCount++;
			}

			public void AddRange(in T[] items)
			{
				if (items.LongLength == 0)
				{
					return;
				}

				long targetCapacity = _longCount + items.LongLength;
				if (_capacity < targetCapacity)
				{
					_ = EnsureCapacity(targetCapacity);
				}

				int blockSize = _blockSize,
					targetBlockIndex = _nextItemBlockIndex,
					memoryBlockCount = _memoryBlocks.Length;

				Span<T> itemsSpan = new(items);
				Span<T[]> memoryBlocksSpan = new(_memoryBlocks, 0, memoryBlockCount);
				Span<T> targetBlockArraySpan = new(memoryBlocksSpan[targetBlockIndex], _nextItemIndex, blockSize - _nextItemIndex);
				while (targetBlockArraySpan.Length <= itemsSpan.Length)
				{
					itemsSpan[..targetBlockArraySpan.Length].CopyTo(targetBlockArraySpan);
					itemsSpan = itemsSpan[targetBlockArraySpan.Length..];
					targetBlockIndex++;
					if (targetBlockIndex == memoryBlockCount)
					{
						break;
					}

					targetBlockArraySpan = new(memoryBlocksSpan[targetBlockIndex], 0, blockSize);
				}

				if (itemsSpan.Length > 0)
				{
					itemsSpan.CopyTo(targetBlockArraySpan);
				}

				_nextItemIndex = itemsSpan.Length;
				_longCount = targetCapacity;
				_nextItemBlockIndex = targetBlockIndex;
			}

			public void AddRange(RecyclableArrayList<T> items)
			{
				if (items.Count == 0)
				{
					return;
				}

				long targetCapacity = _longCount + items.Count;
				if (_capacity < targetCapacity)
				{
					_ = EnsureCapacity(targetCapacity);
				}

				int blockSize = _blockSize,
					targetBlockIndex = _nextItemBlockIndex,
					memoryBlockCount = _memoryBlocks.Length;

				Span<T> itemsSpan = new(items.AsArray(), 0, items.Count);
				Span<T[]> memoryBlocksSpan = new(_memoryBlocks, 0, memoryBlockCount);
				Span<T> targetBlockArraySpan = new(memoryBlocksSpan[targetBlockIndex], _nextItemIndex, blockSize - _nextItemIndex);
				while (targetBlockArraySpan.Length <= itemsSpan.Length)
				{
					itemsSpan[..targetBlockArraySpan.Length].CopyTo(targetBlockArraySpan);
					itemsSpan = itemsSpan[targetBlockArraySpan.Length..];
					targetBlockIndex++;
					if (targetBlockIndex == memoryBlockCount)
					{
						break;
					}

					targetBlockArraySpan = new(memoryBlocksSpan[targetBlockIndex], 0, blockSize);
				}

				_nextItemIndex = itemsSpan.Length;
				itemsSpan.CopyTo(targetBlockArraySpan);
				_longCount = targetCapacity;
				_nextItemBlockIndex = targetBlockIndex;
			}

			public void AddRange(OldRecyclableList<T> items)
			{
				if (items.LongCount == 0)
				{
					return;
				}

				long itemsCount = items.LongCount,
					targetCapacity = _longCount + itemsCount;

				if (_capacity < targetCapacity)
				{
					_ = EnsureCapacity(targetCapacity);
				}

				int blockSize = _blockSize,
					sourceBlockIndex = 0,
					targetBlockIndex = _nextItemBlockIndex,
					toCopy;

				Span<T[]> sourceMemoryBlocksSpan = new(items._memoryBlocks, 0, items._memoryBlocks.Length);
				Span<T> itemsSpan = new(sourceMemoryBlocksSpan[sourceBlockIndex], 0, items._blockSize);
				Span<T[]> targetMemoryBlocksSpan = new(_memoryBlocks, 0, _memoryBlocks.Length);
				Span<T> targetBlockArraySpan = new(targetMemoryBlocksSpan[targetBlockIndex], _nextItemIndex, blockSize - _nextItemIndex);
				long copiedCount = 0;
				while (copiedCount < itemsCount)
				{
					toCopy = (int)Math.Min(itemsCount - copiedCount, itemsSpan.Length);
					if (targetBlockArraySpan.Length < toCopy)
					{
						toCopy = targetBlockArraySpan.Length;
						itemsSpan[..toCopy].CopyTo(targetBlockArraySpan);
						targetBlockIndex++;
						targetBlockArraySpan = new(targetMemoryBlocksSpan[targetBlockIndex], 0, blockSize);
						itemsSpan = itemsSpan[toCopy..];
						copiedCount += toCopy;
					}
					else
					{
						itemsSpan[..toCopy].CopyTo(targetBlockArraySpan);
						targetBlockArraySpan = targetBlockArraySpan[toCopy..];
						itemsSpan = itemsSpan[toCopy..];
						if (itemsSpan.IsEmpty && sourceBlockIndex + 1 < sourceMemoryBlocksSpan.Length)
						{
							sourceBlockIndex++;
							itemsSpan = new(sourceMemoryBlocksSpan[sourceBlockIndex], 0, items._blockSize);
						}

						copiedCount += toCopy;
						if (targetBlockArraySpan.IsEmpty && copiedCount < itemsCount)
						{
							targetBlockIndex++;
							targetBlockArraySpan = new(targetMemoryBlocksSpan[targetBlockIndex], 0, blockSize);
						}
					}
				}

				if ((targetCapacity & (blockSize - 1)) == 0)
				{
					_nextItemIndex = 0;
					_nextItemBlockIndex = targetBlockIndex + 1;
				}
				else
				{
					_nextItemIndex = (int)(targetCapacity & (blockSize - 1));
					_nextItemBlockIndex = targetBlockIndex;

				}

				_longCount = targetCapacity;
			}

			public void AddRange(List<T> items)
			{
				if (items.Count == 0)
				{
					return;
				}

				long targetCapacity = _longCount + items.Count;
				if (_capacity < targetCapacity)
				{
					_ = EnsureCapacity(targetCapacity);
				}

				int blockSize = _blockSize,
					targetBlockIndex = _nextItemBlockIndex,
					itemsCount = items.Count,
					copied = Math.Min(blockSize - _nextItemIndex, itemsCount);

				Span<T[]> memoryBlocksSpan = new(_memoryBlocks, 0, _memoryBlocks.Length);
				items.CopyTo(0, memoryBlocksSpan[targetBlockIndex], _nextItemIndex, copied);
				if (_nextItemIndex + copied == blockSize)
				{
					targetBlockIndex++;
					_nextItemIndex = 0;
				}
				else
				{
					_nextItemIndex += copied;
				}

				while (blockSize <= itemsCount - copied)
				{
					items.CopyTo(copied, memoryBlocksSpan[targetBlockIndex++], 0, blockSize);
					copied += blockSize;
				}

				if ((itemsCount - copied < blockSize) && (itemsCount - copied != 0))
				{
					_nextItemIndex = itemsCount - copied;
					items.CopyTo(copied, memoryBlocksSpan[targetBlockIndex], 0, _nextItemIndex);
				}

				_nextItemBlockIndex = targetBlockIndex;
				_longCount = targetCapacity;
			}

			public void AddRange(IList<T> items)
			{
				if (items.Count == 0)
				{
					return;
				}

				long targetCapacity = _longCount + items.Count;
				if (_capacity < targetCapacity)
				{
					_ = EnsureCapacity(targetCapacity);
				}

				int blockSize = _blockSize,
					targetBlockIndex = _nextItemBlockIndex,
					memoryBlockCount = _memoryBlocks.Length;

				T[] itemsBuffer = items.Count >= RecyclableDefaults.MinPooledArrayLength ? _blockArrayPool.Rent(items.Count) : new T[items.Count];
				try
				{
					items.CopyTo(itemsBuffer, 0);

					Span<T> itemsSpan = new(itemsBuffer, 0, items.Count);
					Span<T[]> memoryBlocksSpan = new(_memoryBlocks, 0, memoryBlockCount);
					Span<T> targetBlockArraySpan = new(memoryBlocksSpan[targetBlockIndex], _nextItemIndex, blockSize - _nextItemIndex);
					while (targetBlockArraySpan.Length <= itemsSpan.Length)
					{
						itemsSpan[..targetBlockArraySpan.Length].CopyTo(targetBlockArraySpan);
						itemsSpan = itemsSpan[targetBlockArraySpan.Length..];
						targetBlockIndex++;
						if (targetBlockIndex == memoryBlockCount)
						{
							break;
						}

						targetBlockArraySpan = new(memoryBlocksSpan[targetBlockIndex], 0, blockSize);
					}

					itemsSpan.CopyTo(targetBlockArraySpan);
					_longCount = targetCapacity;
					_nextItemBlockIndex = targetBlockIndex;
					_nextItemIndex = itemsSpan.Length;
				}
				finally
				{
					if (items.Count >= RecyclableDefaults.MinPooledArrayLength)
					{
						_blockArrayPool.Return(itemsBuffer, NeedsClearing);
					}
				}
			}

			public void AddRange(IEnumerable<T> source, int growByCount = RecyclableDefaults.MinPooledArrayLength)
			{
				if (source is OldRecyclableList<T> sourceRecyclableList)
				{
					AddRange(sourceRecyclableList);
					return;
				}

				if (source is RecyclableArrayList<T> sourceRecyclableArrayList)
				{
					AddRange(sourceRecyclableArrayList);
					return;
				}

				if (source is T[] sourceArray)
				{
					AddRange(sourceArray);
					return;
				}

				if (source is List<T> sourceList)
				{
					AddRange(sourceList);
					return;
				}

				if (source is IList<T> sourceIList)
				{
					AddRange(sourceIList);
					return;
				}

				if (source.TryGetNonEnumeratedCount(out var requiredAdditionalCapacity))
				{
					AddRangeWithKnownCount(source, requiredAdditionalCapacity);
					return;
				}

				AddRangeEnumerated(source, growByCount);
			}

			public void Clear()
			{
				if (_blockSize >= RecyclableDefaults.MinPooledArrayLength)
				{
					Span<T[]> memoryBlocksSpan = new(_memoryBlocks, 0, ReservedBlockCount);
					int memoryBlocksCount = memoryBlocksSpan.Length;
					ArrayPool<T> blockArrayPool = _blockArrayPool;
					for (int toRemoveIdx = 0; toRemoveIdx < memoryBlocksCount; toRemoveIdx++)
					{
						blockArrayPool.Return(memoryBlocksSpan[toRemoveIdx], NeedsClearing);
					}
				}

				_capacity = 0;
				_nextItemBlockIndex = 0;
				_nextItemIndex = 0;
				_longCount = 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool Contains(T item)
			{
				if (_longCount == 0)
				{
					return false;
				}

				if (_nextItemBlockIndex == 0 || (_nextItemBlockIndex == 1 && _nextItemIndex == 0))
				{
					return Array.IndexOf(_memoryBlocks[0], item, 0, (int)_longCount) >= 0;
				}

				Span<T[]> memoryBlocksSpan = new(_memoryBlocks);
				int lastBlockIndex = _nextItemBlockIndex;
				for (int blockIndex = 0; blockIndex < lastBlockIndex; blockIndex++)
				{
					if (Array.IndexOf(memoryBlocksSpan[blockIndex], item, 0, _blockSize) >= 0)
					{
						return true;
					}
				}

				return lastBlockIndex < memoryBlocksSpan.Length && Array.IndexOf(memoryBlocksSpan[lastBlockIndex], item, 0, _nextItemIndex) >= 0;
			}

			public void CopyTo(T[] array, int arrayIndex) => _memoryBlocks.CopyTo(0, _blockSize, _longCount, array, arrayIndex);

			public IEnumerator<T> GetEnumerator() => _memoryBlocks.Enumerate(_blockSize, LongCount).GetEnumerator();

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int IndexOf(T item) => _longCount == 0
					? ItemNotFoundIndex
					: _nextItemBlockIndex == 0 || (_nextItemBlockIndex == 1 && _nextItemIndex == 0)
					? Array.IndexOf(_memoryBlocks[0], item, 0, (int)_longCount)
					: (int)DoIndexOf(item, _memoryBlocks, LastTakenBlockIndex, _blockSize, _nextItemIndex);

			public void Insert(int index, T item) => throw new NotSupportedException();
			public long LongIndexOf(T item) => _longCount == 0
					? ItemNotFoundIndex
					: _nextItemBlockIndex == 0 || (_nextItemBlockIndex == 1 && _nextItemIndex == 0)
					? Array.IndexOf(_memoryBlocks[0], item, 0, (int)_longCount)
					: DoIndexOf(item, _memoryBlocks, LastTakenBlockIndex, _blockSize, _nextItemIndex);

			public bool Remove(T item)
			{
				var itemIndex = LongIndexOf(item);
				if (itemIndex >= 0)
				{
					DoRemoveAt(itemIndex);
					return true;
				}

				return false;
			}

			public void RemoveBlock(int index)
			{
				if (_blockSize < RecyclableDefaults.MinPooledArrayLength)
				{
					_memoryBlocks[index] = _emptyBlockArray;
				}
				else
				{
					_blockArrayPool.Return(_memoryBlocks[index], NeedsClearing);
				}

				_capacity -= _blockSize;
				if (_nextItemBlockIndex == index)
				{
					_nextItemIndex = 0;
				}
				else if (_nextItemBlockIndex > index)
				{
					_nextItemBlockIndex--;
				}
			}

			public void RemoveAt(int index)
			{
				if (index > _longCount - 1 || index < 0)
				{
					ThrowArgumentOutOfRangeException($"Argument \"{nameof(index)}\" = {index} is out of range. Expected value between 0 and {_longCount - 1}");
				}

				DoRemoveAt(index);
			}

			public void RemoveAt(long index)
			{
				if (index > _longCount - 1 || index < 0)
				{
					ThrowArgumentOutOfRangeException($"Argument \"{nameof(index)}\" = {index} is out of range. Expected value between 0 and {_longCount - 1}");
				}

				DoRemoveAt(index);
			}

			IEnumerator IEnumerable.GetEnumerator() => _memoryBlocks.Enumerate(_blockSize, LongCount).GetEnumerator();

			~OldRecyclableList()
			{
				// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
				Dispose();
			}

			public void Dispose()
			{
				// Do not change this code. Put cleanup code in 'Dispose(bool disposing)' method
				if (_capacity > 0)
				{
					Clear();
					if (_memoryBlocks.Length >= RecyclableDefaults.MinPooledArrayLength)
					{
						_memoryBlocksPool.Return(_memoryBlocks, NeedsClearing);
					}

					GC.SuppressFinalize(this);
				}
			}
		}
		

		#endregion

		[Benchmark(Baseline = true)]
		public void RecyclableList_EnsureCapacity_Old_ByPowOf2()
		{
			using var list = new OldRecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
			_ = list.EnsureCapacity(TestObjectCount);
		}

		[Benchmark(Baseline = false)]
		public void RecyclableList_EnsureCapacity_ByPowOf2()
		{
			using var list = new RecyclableList<object>(minBlockSize: BlockSize, expectedItemsCount: TestObjectCount);
			_ = RecyclableList<object>.EnsureCapacity(list, TestObjectCount);
		}

		[Benchmark(Baseline = false)]
		public void RecyclableList_EnsureCapacity_Old_ByBlockSize()
		{
			using var list = new OldRecyclableList<object>();
			_ = list.EnsureCapacity(TestObjectCount);
		}

		[Benchmark(Baseline = false)]
		public void RecyclableList_EnsureCapacity_ByBlockSize()
		{
			using var list = new RecyclableList<object>();
			_ = RecyclableList<object>.EnsureCapacity(list, TestObjectCount);
		}
	}
}