using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

namespace ScreenConnect.Linq;

[Obsolete("Use System.Linq.Enumerable")]
public static class LinqExtensions
{
	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
	{
		return Enumerable.SelectMany(source, collectionSelector, resultSelector);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector)
	{
		return Enumerable.Select(source, selector);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, TResult> selector)
	{
		return Enumerable.Select(source, selector);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector)
	{
		return Enumerable.SelectMany(source, selector);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector)
	{
		return Enumerable.SelectMany(source, selector);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.Where(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.FirstOrDefault(source);
	}

	[Obsolete("Use System.Linq")]
	public static TSource? FirstOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.FirstOrDefault(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static List<TSource> ToList<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.ToList(source);
	}

	[Obsolete("Use System.Linq")]
	public static TSource[] ToArray<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.ToArray(source);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> OfType<TResult>(this IEnumerable source)
	{
		return Enumerable.OfType<TResult>(source);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> Cast<TResult>(this IEnumerable source)
	{
		return Enumerable.Cast<TResult>(source);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> Take<TSource>(this IEnumerable<TSource> source, int count)
	{
		return Enumerable.Take(source, count);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> TakeWhile<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.TakeWhile(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static List<TSource> OrderBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
	{
		return Enumerable.OrderBy(source, keySelector).ToList();
	}

	[Obsolete("Use System.Linq")]
	public static Dictionary<TKey, List<TSource>> GroupBy<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector) where TKey : notnull
	{
		return Enumerable.GroupBy(source, keySelector).ToDictionary();
	}

	[Obsolete("Use System.Linq")]
	public static Dictionary<TKey, TValue> ToDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> valueSelector) where TKey : notnull
	{
		return Enumerable.ToDictionary(source, keySelector, valueSelector);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> Concat<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second)
	{
		return Enumerable.Concat(first, second);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> Reverse<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.Reverse(source);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)
	{
		return Enumerable.Skip(source, count);
	}

	[Obsolete("Use System.Linq")]
	public static int Sum(this IEnumerable<int> source)
	{
		return Enumerable.Sum(source);
	}

	[Obsolete("Use System.Linq")]
	public static int Sum<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
	{
		return Enumerable.Sum(source, selector);
	}

	[Obsolete("Use System.Linq")]
	public static TSource? Min<TSource>(this IEnumerable<TSource> source) where TSource : IComparable
	{
		return Enumerable.Min(source);
	}

	[Obsolete("Use System.Linq")]
	public static TSource? Max<TSource>(this IEnumerable<TSource> source) where TSource : IComparable
	{
		return Enumerable.Max(source);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
	{
		return Enumerable.Zip(first, second, resultSelector);
	}

	[Obsolete("Use System.Linq")]
	public static TAccumulate Aggregate<TSource, TAccumulate>(this IEnumerable<TSource> source, TAccumulate seed, Func<TAccumulate, TSource, TAccumulate> func)
	{
		return Enumerable.Aggregate(source, seed, func);
	}

	[Obsolete("Use System.Linq")]
	public static bool Contains<TSource>(this IEnumerable<TSource> source, TSource value, IEqualityComparer<TSource>? comparer = null)
	{
		return Enumerable.Contains(source, value, comparer);
	}

	[Obsolete("Use System.Linq")]
	public static TSource First<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.First(source);
	}

	[Obsolete("Use System.Linq")]
	public static TSource First<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.First(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static TSource? LastOrDefault<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.LastOrDefault(source);
	}

	[Obsolete("Use System.Linq")]
	public static TSource? LastOrDefault<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.LastOrDefault(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static int Count<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.Count(source);
	}

	[Obsolete("Use System.Linq")]
	public static int Count<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.Count(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static bool Any<TSource>(this IEnumerable<TSource> source)
	{
		return Enumerable.Any(source);
	}

	[Obsolete("Use System.Linq")]
	public static bool Any<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.Any(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static bool All<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate)
	{
		return Enumerable.All(source, predicate);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<int> Range(int start, int count)
	{
		return Enumerable.Range(start, count);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource>? comparer = null) where TSource : notnull
	{
		return Enumerable.Distinct(source, comparer);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<T> Append<T>(this IEnumerable<T> source, T element)
	{
		return EnumerableEx.Append(source, element);
	}

	[Obsolete("Use System.Linq")]
	public static IEnumerable<T> Prepend<T>(this IEnumerable<T> source, T element)
	{
		return EnumerableEx.Prepend(source, element);
	}
}