using System;
using System.Collections.Generic;
using UnityEngine;

namespace DebuggingEssentials
{
	[Serializable]
	public class FastList<T> : FastListBase<T>
	{
		public FastList()
		{
			items = new T[4];
		}

		public FastList(bool reserve, int reserved)
		{
			int num = Mathf.Max(reserved, 4);
			items = new T[num];
			Count = (_count = reserved);
		}

		public FastList(int capacity)
		{
			if (capacity < 1)
			{
				capacity = 1;
			}
			items = new T[capacity];
		}

		public FastList(FastList<T> list)
		{
			if (list == null)
			{
				items = new T[4];
				return;
			}
			items = new T[list.Count];
			Array.Copy(list.items, items, list.Count);
			Count = (_count = items.Length);
		}

		public FastList(T[] items, bool copy = false)
		{
			if (copy)
			{
				base.items = new T[items.Length];
				Array.Copy(items, base.items, items.Length);
			}
			else
			{
				base.items = items;
			}
			_count = (Count = items.Length);
		}

		protected void SetCapacity(int capacity)
		{
			FastListBase.SetCapacity(this, ref items, capacity, _count);
		}

		public void SetCount(int count)
		{
			if (count > items.Length)
			{
				SetCapacity(count);
			}
			Count = (_count = count);
		}

		public void EnsureCount(int count)
		{
			if (count > _count)
			{
				if (count > items.Length)
				{
					SetCapacity(count);
				}
				Count = (_count = count);
			}
		}

		public virtual void SetArray(T[] items)
		{
			base.items = items;
			_count = (Count = items.Length);
		}

		public int AddUnique(T item)
		{
			if (!Contains(item))
			{
				return Add(item);
			}
			return -1;
		}

		public bool Contains(T item)
		{
			return Array.IndexOf(items, item, 0, _count) != -1;
		}

		public int IndexOf(T item)
		{
			return Array.IndexOf(items, item, 0, _count);
		}

		public T GetIndex(T item)
		{
			int num = Array.IndexOf(items, item, 0, _count);
			if (num == -1)
			{
				return default(T);
			}
			return items[num];
		}

		public virtual int Add(T item)
		{
			if (_count == items.Length)
			{
				DoubleCapacity();
			}
			items[_count] = item;
			Count = ++_count;
			return _count - 1;
		}

		public virtual int AddThreadSafe(T item)
		{
			lock (this)
			{
				if (_count == items.Length)
				{
					DoubleCapacity();
				}
				items[_count] = item;
				Count = ++_count;
				return _count - 1;
			}
		}

		public virtual void Add(T item, T item2)
		{
			if (_count + 1 >= items.Length)
			{
				DoubleCapacity();
			}
			items[_count++] = item;
			items[_count++] = item2;
			Count = _count;
		}

		public virtual void Add(T item, T item2, T item3)
		{
			if (_count + 2 >= items.Length)
			{
				DoubleCapacity();
			}
			items[_count++] = item;
			items[_count++] = item2;
			items[_count++] = item3;
			Count = _count;
		}

		public virtual void Add(T item, T item2, T item3, T item4)
		{
			if (_count + 3 >= items.Length)
			{
				DoubleCapacity();
			}
			items[_count++] = item;
			items[_count++] = item2;
			items[_count++] = item3;
			items[_count++] = item4;
			Count = _count;
		}

		public virtual void Add(T item, T item2, T item3, T item4, T item5)
		{
			if (_count + 4 >= items.Length)
			{
				DoubleCapacity();
			}
			items[_count++] = item;
			items[_count++] = item2;
			items[_count++] = item3;
			items[_count++] = item4;
			items[_count++] = item5;
			Count = _count;
		}

		public virtual void Insert(int index, T item)
		{
			if (index > _count)
			{
				Debug.LogError("Index " + index + " is out of range " + _count);
			}
			if (_count == items.Length)
			{
				DoubleCapacity();
			}
			if (index < _count)
			{
				Array.Copy(items, index, items, index + 1, _count - index);
			}
			items[index] = item;
			Count = ++_count;
		}

		public virtual void AddRange(T[] arrayItems)
		{
			if (arrayItems != null)
			{
				int num = arrayItems.Length;
				int num2 = _count + num;
				if (num2 >= items.Length)
				{
					SetCapacity(num2 * 2);
				}
				Array.Copy(arrayItems, 0, items, _count, num);
				Count = (_count = num2);
			}
		}

		public virtual void AddRange(T[] arrayItems, int startIndex, int length)
		{
			int num = _count + length;
			if (num >= items.Length)
			{
				SetCapacity(num * 2);
			}
			Array.Copy(arrayItems, startIndex, items, _count, length);
			Count = (_count = num);
		}

		public virtual void AddRange(FastList<T> list)
		{
			if (list.Count != 0)
			{
				int num = _count + list.Count;
				if (num >= items.Length)
				{
					SetCapacity(num * 2);
				}
				Array.Copy(list.items, 0, items, _count, list.Count);
				Count = (_count = num);
			}
		}

		public virtual void AddRange(List<T> list)
		{
			if (list.Count != 0)
			{
				int num = _count + list.Count;
				if (num >= items.Length)
				{
					SetCapacity(num * 2);
				}
				for (int i = 0; i < list.Count; i++)
				{
					items[_count++] = list[i];
				}
				Count = _count;
			}
		}

		public virtual int GrabListThreadSafe(FastList<T> threadList, bool fastClear = false)
		{
			lock (threadList)
			{
				int count = _count;
				AddRange(threadList);
				if (fastClear)
				{
					threadList.FastClear();
				}
				else
				{
					threadList.Clear();
				}
				return count;
			}
		}

		public virtual void ChangeRange(int startIndex, T[] arrayItems)
		{
			for (int i = 0; i < arrayItems.Length; i++)
			{
				items[startIndex + i] = arrayItems[i];
			}
		}

		public virtual bool Remove(T item, bool weakReference = false)
		{
			int num = Array.IndexOf(items, item, 0, _count);
			if (num >= 0)
			{
				items[num] = items[--_count];
				items[_count] = default(T);
				Count = _count;
				return true;
			}
			return false;
		}

		public virtual void RemoveAt(int index)
		{
			if (index >= _count)
			{
				Debug.LogError("Index " + index + " is out of range. List count is " + _count);
				return;
			}
			items[index] = items[--_count];
			items[_count] = default(T);
			Count = _count;
		}

		public virtual void RemoveLast()
		{
			if (_count != 0)
			{
				_count--;
				items[_count] = default(T);
				Count = _count;
			}
		}

		public virtual void RemoveRange(int index, int length)
		{
			if (_count - index < length)
			{
				Debug.LogError("Invalid length!");
			}
			if (length > 0)
			{
				_count -= length;
				if (index < _count)
				{
					Array.Copy(items, index + length, items, index, _count - index);
				}
				Array.Clear(items, _count, length);
				Count = _count;
			}
		}

		public virtual T Dequeue()
		{
			if (_count == 0)
			{
				Debug.LogError("List is empty!");
				return default(T);
			}
			T result = items[--_count];
			items[_count] = default(T);
			Count = _count;
			return result;
		}

		public virtual T Dequeue(int index)
		{
			T result = items[index];
			items[index] = items[--_count];
			items[_count] = default(T);
			Count = _count;
			return result;
		}

		public virtual void Clear()
		{
			if (_count > 0)
			{
				Array.Clear(items, 0, _count);
				Count = (_count = 0);
			}
		}

		public virtual void ClearThreadSafe()
		{
			lock (this)
			{
				Array.Clear(items, 0, _count);
				Count = (_count = 0);
			}
		}

		public virtual void ClearRange(int startIndex)
		{
			Array.Clear(items, startIndex, _count - startIndex);
			Count = (_count = startIndex);
		}

		public virtual void FastClear()
		{
			Count = (_count = 0);
		}

		public virtual void FastClear(int newCount)
		{
			if (newCount < Count)
			{
				Count = (_count = newCount);
			}
		}

		public virtual T[] ToArray()
		{
			T[] array = new T[_count];
			Array.Copy(items, 0, array, 0, _count);
			return array;
		}
	}
}