using System.Collections;
using System.Collections.Generic;
using ScreenConnect;

namespace System.Linq;

public static class Enumerable
{
	private class ListGrouping<TKey, TElement> : IGrouping<TKey, TElement>, IEnumerable<TElement>, IEnumerable
	{
		private List<TElement> list;

		public TKey Key { get; }

		public ListGrouping(TKey key, List<TElement> list)
		{
			Key = key;
			this.list = list;
		}

		public IEnumerator<TElement> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}

	public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
	{
		foreach (TSource element in source)
		{
			foreach (TCollection item in collectionSelector(element))
			{
				yield return resultSelector(element, item);
			}
		}
	}

	public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
	{
		foreach (TSource item in source)
		{
			yield return selector(item);
		}
	}

	public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
	{
		int index = 0;
		foreach (TSource item in source)
		{
			yield return selector(item, index++);
		}
	}

	public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
	{
		foreach (TSource item in source)
		{
			foreach (TResult item2 in selector(item))
			{
				yield return item2;
			}
		}
	}

	public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
	{
		int sourceIndex = 0;
		foreach (TSource item in source)
		{
			foreach (TResult item2 in selector(item, sourceIndex++))
			{
				yield return item2;
			}
		}
	}

	public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				yield return item;
			}
		}
	}

	public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate)
	{
		int index = 0;
		foreach (TSource item in source)
		{
			if (predicate(item, index++))
			{
				yield return item;
			}
		}
	}

	public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source)
	{
		if (source is IList<TSource> list)
		{
			if (list.Count > 0)
			{
				return list[0];
			}
		}
		else
		{
			using IEnumerator<TSource> enumerator = source.GetEnumerator();
			if (enumerator.MoveNext())
			{
				return enumerator.Current;
			}
		}
		return default(TSource);
	}

	public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				return item;
			}
		}
		return default(TSource);
	}

	public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
	{
		return new List<TSource>(source);
	}

	public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
	{
		ICollection<TSource> collection = source as ICollection<TSource>;
		if (collection == null)
		{
			return new List<TSource>(source).ToArray();
		}
		return new TSource[collection.Count].Mutate(delegate(TSource[] it)
		{
			collection.CopyTo(it, 0);
		});
	}

	public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource>? source) where TSource : notnull
	{
		return source.ToHashSet(null);
	}

	public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource>? source, IEqualityComparer<TSource>? comparer) where TSource : notnull
	{
		return new HashSet<TSource>(source, comparer);
	}

	public static IEnumerable<TResult> OfType<TResult>(this IEnumerable? source)
	{
		if (source == null)
		{
			yield break;
		}
		foreach (object item in source)
		{
			if (item is TResult)
			{
				yield return (TResult)item;
			}
		}
	}

	public static IEnumerable<TResult> Cast<TResult>(this IEnumerable? source)
	{
		if (source is IEnumerable<TResult> result)
		{
			return result;
		}
		return CastIterator();
		IEnumerable<TResult> CastIterator()
		{
			if (source != null)
			{
				foreach (object item in source)
				{
					yield return (TResult)item;
				}
			}
		}
	}

	public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
	{
		int index = 0;
		foreach (TSource item in source)
		{
			int num = index + 1;
			index = num;
			if (num <= count)
			{
				yield return item;
				continue;
			}
			yield break;
		}
	}

	public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				yield return item;
				continue;
			}
			yield break;
		}
	}

	public static List<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
	{
		return source.OrderBy(keySelector, 1);
	}

	public static List<TSource> OrderByDescending<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
	{
		return source.OrderBy(keySelector, -1);
	}

	private static List<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, int multiplier)
	{
		List<TSource> list = new List<TSource>(source);
		list.Sort((TSource x, TSource y) => multiplier * Comparer<TKey>.Default.Compare(keySelector(x), keySelector(y)));
		return list;
	}

	public static IEnumerable<IGrouping<TKey, TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) where TKey : notnull
	{
		Dictionary<TKey, List<TSource>> dictionary = new Dictionary<TKey, List<TSource>>();
		foreach (TSource item in source)
		{
			TKey key = keySelector(item);
			List<TSource> list = dictionary.TryGetValue(key);
			if (list == null)
			{
				list = (dictionary[key] = new List<TSource>());
			}
			list.Add(item);
		}
		foreach (var (key2, list4) in dictionary)
		{
			yield return new ListGrouping<TKey, TSource>(key2, list4);
		}
	}

	public static IEnumerable<TResult> GroupBy<TSource, TKey, TResult>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TKey, IEnumerable<TSource>, TResult> resultSelector) where TKey : notnull
	{
		return from it in source.GroupBy(keySelector)
			select resultSelector(it.Key, it);
	}

	public static Dictionary<TKey, TValue> ToDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector)
	{
		Dictionary<TKey, TValue> dictionary = new Dictionary<TKey, TValue>();
		foreach (TSource item in source)
		{
			dictionary[keySelector(item)] = valueSelector(item);
		}
		return dictionary;
	}

	public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
	{
		foreach (TSource item in first)
		{
			yield return item;
		}
		foreach (TSource item2 in second)
		{
			yield return item2;
		}
	}

	public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
	{
		List<TSource> list = source.ToList();
		for (int i = list.Count - 1; i >= 0; i--)
		{
			yield return list[i];
		}
	}

	public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
	{
		using IEnumerator<TSource> e = source.AssertArgumentNonNull("source").GetEnumerator();
		while (count > 0 && e.MoveNext())
		{
			count--;
		}
		if (count <= 0)
		{
			while (e.MoveNext())
			{
				yield return e.Current;
			}
			yield break;
		}
	}

	public static int Sum(this IEnumerable<int> source)
	{
		int num = 0;
		foreach (int item in source)
		{
			num += item;
		}
		return num;
	}

	public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
	{
		int num = 0;
		foreach (TSource item in source)
		{
			num += selector(item);
		}
		return num;
	}

	public static TSource? Min<TSource>(this IEnumerable<TSource> source) where TSource : IComparable
	{
		return source.MinOrMax(minOrMax: true);
	}

	public static TSource? Max<TSource>(this IEnumerable<TSource> source) where TSource : IComparable
	{
		return source.MinOrMax(minOrMax: false);
	}

	private static TSource? MinOrMax<TSource>(this IEnumerable<TSource> source, bool minOrMax) where TSource : IComparable
	{
		TSource val = default(TSource);
		bool flag = true;
		int num = (minOrMax ? 1 : int.MinValue);
		int num2 = (minOrMax ? int.MaxValue : (-1));
		Comparer<TSource> comparer = Comparer<TSource>.Default;
		foreach (TSource item in source)
		{
			if (flag || item == null)
			{
				val = item;
				flag = false;
				continue;
			}
			int num3 = comparer.Compare(val, item);
			if (num3 >= num && num3 <= num2)
			{
				val = item;
			}
		}
		return val;
	}

	public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
	{
		using IEnumerator<TFirst> e1 = first.GetEnumerator();
		using IEnumerator<TSecond> e2 = second.GetEnumerator();
		while (e1.MoveNext() && e2.MoveNext())
		{
			yield return resultSelector(e1.Current, e2.Current);
		}
	}

	public static float Average(this IEnumerable<float> source)
	{
		int num = 0;
		float num2 = 0f;
		foreach (float item in source)
		{
			num++;
			num2 += item;
		}
		return num2 / (float)num;
	}

	public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
	{
		TAccumulate val = seed;
		foreach (TSource item in source)
		{
			val = func(val, item);
		}
		return val;
	}

	public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource>? comparer = null)
	{
		if (comparer == null)
		{
			comparer = EqualityComparer<TSource>.Default;
		}
		foreach (TSource item in source)
		{
			if (comparer.Equals(item, value))
			{
				return true;
			}
		}
		return false;
	}

	public static TSource First<TSource>(this IEnumerable<TSource> source)
	{
		if (source is IList<TSource> list)
		{
			if (list.Count > 0)
			{
				return list[0];
			}
		}
		else
		{
			using IEnumerator<TSource> enumerator = source.GetEnumerator();
			if (enumerator.MoveNext())
			{
				return enumerator.Current;
			}
		}
		throw new InvalidOperationException();
	}

	public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				return item;
			}
		}
		throw new InvalidOperationException();
	}

	public static TSource Single<TSource>(this IEnumerable<TSource> source)
	{
		if (source is IList<TSource> list)
		{
			if (list.Count == 0)
			{
				throw new InvalidOperationException("No elements");
			}
			if (list.Count == 1)
			{
				return list[0];
			}
		}
		else
		{
			using IEnumerator<TSource> enumerator = source.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				throw new InvalidOperationException("No elements");
			}
			TSource current = enumerator.Current;
			if (!enumerator.MoveNext())
			{
				return current;
			}
		}
		throw new InvalidOperationException("More than one element");
	}

	public static TSource? ElementAtOrDefault<TSource>(this IList<TSource> source, int index)
	{
		if (source.Count > index)
		{
			return source[index];
		}
		return default(TSource);
	}

	public static TSource? LastOrDefault<TSource>(this IEnumerable<TSource> source)
	{
		if (source is IList<TSource> { Count: var count } list)
		{
			if (count > 0)
			{
				return list[count - 1];
			}
			return default(TSource);
		}
		TSource result = default(TSource);
		foreach (TSource item in source)
		{
			result = item;
		}
		return result;
	}

	public static TSource Last<TSource>(this IEnumerable<TSource> source)
	{
		if (source is IList<TSource> { Count: var count } list)
		{
			if (count == 0)
			{
				throw new InvalidOperationException();
			}
			return list[count - 1];
		}
		TSource result = default(TSource);
		bool flag = false;
		foreach (TSource item in source)
		{
			result = item;
			flag = true;
		}
		if (!flag)
		{
			throw new InvalidOperationException();
		}
		return result;
	}

	public static TSource? LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		TSource result = default(TSource);
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				result = item;
			}
		}
		return result;
	}

	public static int Count<TSource>(this IEnumerable<TSource> source)
	{
		if (!(source is ICollection<TSource> collection))
		{
			if (source is ICollection collection2)
			{
				return collection2.Count;
			}
			int num = 0;
			{
				foreach (TSource item in source)
				{
					_ = item;
					num++;
				}
				return num;
			}
		}
		return collection.Count;
	}

	public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		int num = 0;
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				num++;
			}
		}
		return num;
	}

	public static bool Any<TSource>(this IEnumerable<TSource> source)
	{
		using (IEnumerator<TSource> enumerator = source.GetEnumerator())
		{
			if (enumerator.MoveNext())
			{
				_ = enumerator.Current;
				return true;
			}
		}
		return false;
	}

	public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		foreach (TSource item in source)
		{
			if (predicate(item))
			{
				return true;
			}
		}
		return false;
	}

	public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		foreach (TSource item in source)
		{
			if (!predicate(item))
			{
				return false;
			}
		}
		return true;
	}

	public static IEnumerable<int> Range(int start, int count)
	{
		for (int i = 0; i < count; i++)
		{
			yield return start + i;
		}
	}

	public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource>? comparer = null) where TSource : notnull
	{
		HashSet<TSource> set = new HashSet<TSource>(comparer);
		foreach (TSource item in source)
		{
			if (!set.Contains(item))
			{
				set.Add(item);
				yield return item;
			}
		}
	}
}