using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Text;

namespace ScreenConnect;

public static class EnumerableExtensions
{
	public static IEnumerable<T> AppendIf<T>(this IEnumerable<T> @this, T newItem, bool append)
	{
		foreach (T item in @this)
		{
			yield return item;
		}
		if (append)
		{
			yield return newItem;
		}
	}

	public static IEnumerable<T> AppendIf<T>(this IEnumerable<T> @this, Func<T> newItemCreator, bool append)
	{
		foreach (T item in @this)
		{
			yield return item;
		}
		if (append)
		{
			yield return newItemCreator();
		}
	}

	public static IEnumerable<T> PrependIf<T>(this IEnumerable<T> @this, T newItem, bool prepend)
	{
		if (prepend)
		{
			yield return newItem;
		}
		foreach (T item in @this)
		{
			yield return item;
		}
	}

	public static IEnumerable<T> PrependIf<T>(this IEnumerable<T> @this, Func<T> newItemCreator, bool prepend)
	{
		if (prepend)
		{
			yield return newItemCreator();
		}
		foreach (T item in @this)
		{
			yield return item;
		}
	}

	public static IEnumerable<KeyValuePair<TKey, TValue>> WhereValueNotNull<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue?>> @this)
	{
		return @this.Where<KeyValuePair<TKey, TValue>>((KeyValuePair<TKey, TValue> it) => it.Value != null);
	}

	public static IEnumerable<T> TryAppend<T>(this IEnumerable<T> @this, Func<T> newItemCreator) where T : class
	{
		foreach (T item in @this)
		{
			yield return item;
		}
		T val = Extensions.TryGet(newItemCreator);
		if (val != null)
		{
			yield return val;
		}
	}

	public static IEnumerable<T> AppendIfNotNull<T>(this IEnumerable<T> @this, T? newItem) where T : class
	{
		return @this.AppendIfNotNull(newItem, (T it) => it);
	}

	public static IEnumerable<T> AppendIfNotNull<T>(this IEnumerable<T> @this, T? newItem) where T : struct
	{
		foreach (T item in @this)
		{
			yield return item;
		}
		if (newItem.HasValue)
		{
			yield return newItem.Value;
		}
	}

	public static IEnumerable<T> AppendIfNotNull<T, TItem>(this IEnumerable<T> @this, TItem? item, Func<TItem, T> func) where TItem : class
	{
		foreach (T item2 in @this)
		{
			yield return item2;
		}
		if (item != null)
		{
			yield return func(item);
		}
	}

	public static IEnumerable<T> PrependIfNotNull<T>(this IEnumerable<T> @this, T? newItem) where T : class
	{
		if (newItem != null)
		{
			yield return newItem;
		}
		foreach (T item in @this)
		{
			yield return item;
		}
	}

	public static IEnumerable<T> Generate<T>(int count, Func<T> generator)
	{
		return from _ in Enumerable.Range(0, count)
			select generator();
	}

	public static IEnumerable<T> Generate<T>(int count, Func<int, T> generator)
	{
		return Enumerable.Range(0, count).Select(generator);
	}

	public static bool IsNullOrEmpty([NotNullWhen(false)] this IEnumerable? @this)
	{
		if (@this == null)
		{
			return true;
		}
		if (@this is ICollection collection)
		{
			return collection.Count == 0;
		}
		IEnumerator enumerator = @this.GetEnumerator();
		try
		{
			if (enumerator.MoveNext())
			{
				_ = enumerator.Current;
				return false;
			}
		}
		finally
		{
			IDisposable disposable = enumerator as IDisposable;
			if (disposable != null)
			{
				disposable.Dispose();
			}
		}
		return true;
	}

	public static string Join(this IEnumerable<string?> @this, char separator)
	{
		return @this.Join(separator.ToString());
	}

	public static string Join(this IEnumerable<string?> @this, string? separator)
	{
		StringBuilder stringBuilder = null;
		foreach (string item in @this)
		{
			if (stringBuilder == null)
			{
				stringBuilder = new StringBuilder(128);
			}
			else
			{
				stringBuilder.Append(separator);
			}
			stringBuilder.Append(item);
		}
		return stringBuilder?.ToString() ?? string.Empty;
	}

	public static void Join(this IEnumerable<string?> @this, string? separator, StringBuilder builder)
	{
		bool flag = true;
		foreach (string item in @this)
		{
			if (flag)
			{
				flag = false;
			}
			else
			{
				builder.Append(separator);
			}
			builder.Append(item);
		}
	}

	public static int Count<T>(this IList<T> @this, Func<T, bool> predicate)
	{
		int num = 0;
		for (int i = 0; i < @this.Count; i++)
		{
			if (predicate(@this[i]))
			{
				num++;
			}
		}
		return num;
	}

	public static IEnumerable<T> MutateMany<T>(this IEnumerable<T> @this, Proc<T> mutator)
	{
		return @this.Select((T it) => it.Mutate(mutator));
	}

	public static TDictionary ToDictionary<TSource, TKey, TValue, TDictionary>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, bool throwOnDuplicateKey = true) where TKey : notnull where TDictionary : IDictionary<TKey, TValue>, new()
	{
		TDictionary result = new TDictionary();
		foreach (TSource item in source)
		{
			TKey val = keySelector(item);
			if (result.ContainsKey(val) & throwOnDuplicateKey)
			{
				throw new ArgumentException($"Duplicate key: {val}");
			}
			result[val] = valueSelector(item);
		}
		return result;
	}

	public static Dictionary<TKey, TValue> ToDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector, bool throwOnDuplicateKey = true) where TKey : notnull
	{
		return source.ToDictionary<TSource, TKey, TValue, Dictionary<TKey, TValue>>(keySelector, valueSelector, throwOnDuplicateKey);
	}

	public static Dictionary<TKey, TSource> ToDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, bool throwOnDuplicateKey = true) where TKey : notnull
	{
		return source.ToDictionary<TSource, TKey, TSource, Dictionary<TKey, TSource>>(keySelector, (TSource it) => it, throwOnDuplicateKey);
	}

	public static Dictionary<TKey, List<TSource>> ToDictionary<TKey, TSource>(this IEnumerable<IGrouping<TKey, TSource>> groupings) where TKey : notnull
	{
		return groupings.ToDictionary((IGrouping<TKey, TSource> it) => it.Key, (IGrouping<TKey, TSource> it) => it.ToList());
	}

	public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<(TKey, TValue)> items) where TKey : notnull
	{
		return items.ToDictionary<(TKey, TValue), TKey, TValue>(((TKey, TValue) it) => it.Item1, ((TKey, TValue) it) => it.Item2);
	}

	public static IDictionary<TKey, TValue> ToDictionary<TKey, TValue>(this (TKey, TValue) tuple) where TKey : notnull
	{
		return new(TKey, TValue)[1] { tuple }.ToDictionary();
	}

	public static string[] AllNonNullKeys(this NameValueCollection collection)
	{
		return collection.AllKeys.WhereNotNull().ToArray();
	}

	public static Dictionary<string, string?> ToDictionary(this NameValueCollection collection)
	{
		return collection.AllNonNullKeys().ToDictionary((string it) => it, (string it) => collection[it].ToNullable());
	}

	public static Dictionary<string, string?> ToDictionary(this NameValueCollection collection, bool throwOnDuplicateKey)
	{
		return collection.AllNonNullKeys().ToDictionary((string it) => it, (string it) => collection[it].ToNullable(), throwOnDuplicateKey);
	}

	public static Dictionary<string, string[]?> ToMultiValueDictionary(this NameValueCollection collection)
	{
		return collection.AllNonNullKeys().ToDictionary((string it) => it, (string it) => collection.GetValues(it).ToNullable());
	}

	public static TDictionary ToDictionary<TKey, TValue, TDictionary>(this IEnumerable<KeyValuePair<TKey, TValue>> mappings, bool throwOnDuplicateKey = false) where TKey : notnull where TDictionary : IDictionary<TKey, TValue>, new()
	{
		return mappings.ToDictionary<KeyValuePair<TKey, TValue>, TKey, TValue, TDictionary>((KeyValuePair<TKey, TValue> _) => _.Key, (KeyValuePair<TKey, TValue> _) => _.Value, throwOnDuplicateKey);
	}

	public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> mappings, bool throwOnDuplicateKey = false) where TKey : notnull
	{
		return mappings.ToDictionary<TKey, TValue, Dictionary<TKey, TValue>>(throwOnDuplicateKey);
	}

	public static DisposableList<T> ToDisposableList<T>(this IEnumerable<T> @this) where T : IDisposable
	{
		return new DisposableList<T>(@this);
	}

	public static T? FirstOrDefault<T>(this IEnumerable<T> @this, out int index)
	{
		return @this.FirstOrDefault(null, out index);
	}

	public static T? FirstOrDefault<T>(this IEnumerable<T> @this, Predicate<T>? predicate, out int index)
	{
		index = 0;
		foreach (T item in @this)
		{
			if (predicate == null || predicate(item))
			{
				return item;
			}
			index++;
		}
		index = -1;
		return default(T);
	}

	public static TCollection ToCollection<T, TCollection>(this IEnumerable<T> @this, Func<TCollection> factory) where TCollection : IList<T>
	{
		TCollection result = factory();
		foreach (T item in @this)
		{
			result.Add(item);
		}
		return result;
	}

	public static TCollection ToCollection<T, TCollection>(this IEnumerable<T> @this) where TCollection : IList<T>, new()
	{
		return @this.ToCollection(() => new TCollection());
	}
}