using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Utility;
using JetBrains.Annotations;
using Microsoft.FSharp.Collections;

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// Utility and extension methods for <see cref="IEnumerable{T}"/> and its
    /// dependencies.
    /// </summary>
    public static class Enumerable
    {
        /// <summary>
        /// Returns the zero based index location of <paramref name="value"/>
        /// within <paramref name="source"/>. This method uses
        /// <see cref="EqualityComparer{T}.Default"/> for comparison.
        /// </summary>
        /// <typeparam name="T">The type contained within the
        /// <paramref name="source"/>.</typeparam>
        /// <param name="source">The instance to loop over to determine the index
        /// where <paramref name="value"/> is located true.</param>
        /// <param name="value">The instance to search for.</param>
        /// <returns>The index where <paramref name="value"/> is located or -1
        /// if <paramref name="value"/> was not located.</returns>
        public static int IndexOf<T>(this IEnumerable<T> source, T value)
        {
            return source.IndexOf(value, null);
        }

        /// <summary>
        /// Returns the zero based index location of <paramref name="value"/>
        /// within <paramref name="source"/>.
        /// </summary>
        /// <typeparam name="T">The type contained within the
        /// <paramref name="source"/>.</typeparam>
        /// <param name="source">The instance to loop over to determine the index
        /// where <paramref name="value"/> is located true.</param>
        /// <param name="value">The instance to search for.</param>
        /// <param name="comparer">The instance used to perform the comparison
        /// or null if <see cref="EqualityComparer{T}.Default"/> should be used.</param>
        /// <returns>The index where <paramref name="value"/> is located or -1
        /// if <paramref name="value"/> was not located.</returns>
        public static int IndexOf<T>(this IEnumerable<T> source, T value, IEqualityComparer<T> comparer)
        {
            comparer = comparer ?? EqualityComparer<T>.Default;
            return source.IndexWhere(item => comparer.Equals(item, value));
        }

        /// <summary>
        /// Returns the zero based index where the provided
        /// <paramref name="predicate"/> returns true.
        /// </summary>
        /// <typeparam name="T">The type contained within the
        /// <paramref name="source"/>.</typeparam>
        /// <param name="source">The instance to loop over to determine the index
        /// where <paramref name="predicate"/> returns true.</param>
        /// <param name="predicate">The predicate use to determine the index
        /// returned.</param>
        /// <returns>The index where <paramref name="predicate"/> is true or -1
        /// if <paramref name="predicate"/> never returned true.</returns>
        public static int IndexWhere<T>(this IEnumerable<T> source, Predicate<T> predicate)
        {
            int index = 0;

            foreach (T item in source)
            {
                if (predicate(item))
                    return index;
                ++index;
            }

            return -1;
        }

        /// <summary>
        /// Returns true if <paramref name="enumerable"/> is empty, false if
        /// otherwise.
        /// </summary>
        /// <param name="enumerable">The instance to determine if empty.</param>
        /// <returns>True if <paramref name="enumerable"/> is empty, false if
        /// otherwise. </returns>
        public static bool IsEmpty(this IEnumerable enumerable)
        {
            return enumerable.GetEnumerator().MoveNext() == false;
        }

        /// <summary>
        /// Returns true if <paramref name="enumerable"/> is null or empty, false if
        /// otherwise.
        /// </summary>
        /// <param name="enumerable">The instance to determine if null or empty.</param>
        /// <returns>True if <paramref name="enumerable"/> is null or empty, false if
        /// otherwise.</returns>
        [ContractAnnotation("enumerable:null => false")]
        public static bool IsEmptyOrNull(this IEnumerable enumerable)
        {
            return enumerable == null || enumerable.IsEmpty();
        }

        /// <summary>
        /// Returns the elements of the specified sequence or the specified
        /// value in a singleton collection if the sequence is empty.
        /// </summary>
        /// <typeparam name="T">The type of the elements of source.</typeparam>
        /// <param name="enumerable">The sequence to return the specified value
        /// for if it is empty.</param>
        /// <param name="creator">The method that is to create the default value
        /// if the sequence is empty.</param>
        /// <returns>An <see cref="IEnumerable{T}"/> that contains the instance
        /// created by <paramref name="creator"/> if source is empty; otherwise,
        /// source.</returns>
        public static IEnumerable<T> DefaultIfEmpty<T>(this IEnumerable<T> enumerable, Func<T> creator)
        {
            // ReSharper disable PossibleMultipleEnumeration
            return enumerable.IsEmpty() ? creator().ToEnumerable() : enumerable;
            // ReSharper restore PossibleMultipleEnumeration
        }

        /// <summary>
        /// Applies a specified function to the corresponding elements of two
        /// sequences, producing a sequence of the results.
        /// </summary>
        /// <typeparam name="T1">The type of the elements of the first input
        /// sequence.</typeparam>
        /// <typeparam name="T2">The type of the elements of the second input
        /// sequence.</typeparam>
        /// <param name="first">The first input sequence.</param>
        /// <param name="second">The second input sequence.</param>
        /// <returns>An <see cref="IEnumerable{T}"/> that contains elements of
        /// the two input sequences, combined using <see cref="Pair{T1, T2}"/>.</returns>
        public static IEnumerable<Pair<T1, T2>> Zip<T1, T2>(this IEnumerable<T1> first, IEnumerable<T2> second)
        {
            return first.Zip(second, (arg1, arg2) => new Pair<T1, T2>(arg1, arg2));
        }

        /// <summary>
        /// Applies a specified function to the corresponding elements of two
        /// sequences, producing a sequence of the results.
        /// </summary>
        /// <typeparam name="T1">The type of the elements of the first input
        /// sequence.</typeparam>
        /// <typeparam name="T2">The type of the elements of the second input
        /// sequence.</typeparam>
        /// <typeparam name="TResult">The type of the elements of the result
        /// sequence.</typeparam>
        /// <param name="first">The first input sequence.</param>
        /// <param name="second">The second input sequence.</param>
        /// <param name="resultSelector">A function that specifies how to
        /// combine the corresponding elements of the two sequences.</param>
        /// <returns>An <see cref="IEnumerable{T}"/> that contains elements of
        /// the two input sequences, combined by <paramref name="resultSelector"/>.</returns>
        public static IEnumerable<TResult> Zip<T1, T2, TResult>(this IEnumerable<T1> first, IEnumerable<T2> second, Func<T1, T2, TResult> resultSelector)
        {
// ReSharper disable PossibleMultipleEnumeration
            first.ThrowIfNull("first");

            second.ThrowIfNull("second");
            resultSelector.ThrowIfNull("factory");

            using (var item1 = first.GetEnumerator())
            using (var item2 = second.GetEnumerator())
                while (item1.MoveNext() && item2.MoveNext())
                    yield return resultSelector(item1.Current, item2.Current);
// ReSharper restore PossibleMultipleEnumeration
        }

        /// <summary>
        /// Returns a never ending <see cref="IEnumerable{T}"/> filled with values from <paramref name="func"/>.
        /// Use <see cref="System.Linq.Enumerable.Take{T}(IEnumerable{T}, int)"/> on the returned
        /// instance to limit the size.
        /// </summary>
        /// <typeparam name="T">The type returned by <paramref name="func"/>.</typeparam>
        /// <param name="func">The method that will create the values.</param>
        public static IEnumerable<T> From<T>(Func<T> func)
        {
            while (true) yield return func();
        }

        /// <summary>
        /// Returns a never ending <see cref="IEnumerable{T}"/> filled with values from <paramref name="func"/>.
        /// Use <see cref="System.Linq.Enumerable.Take{T}(IEnumerable{T}, int)"/> on the returned
        /// instance to limit the size.
        /// </summary>
        /// <typeparam name="T">The type returned by <paramref name="func"/>.</typeparam>
        /// <param name="func">The method that takes the current index and returns result values.</param>
        public static IEnumerable<T> From<T>(Func<int, T> func)
        {
            for (var i = 0;; i++) yield return func(i);
        }

        /// <summary>
        /// Converts an <see cref="IEnumerator{T}"/> into a method where each invocation of the
        /// method returns the next value from the <see cref="IEnumerator{T}"/>.
        /// </summary>
        /// <param name="enumerator">The instance to pull the values from.</param>
        /// <param name="fillerValue">The value that will be returned if nothing is left in the
        /// <paramref name="enumerator"/>.</param>
        public static Func<T> AsFunc<T>(this IEnumerator<T> enumerator, T fillerValue = default(T))
        {
            return () => enumerator.MoveNext() ? enumerator.Current : fillerValue;
        }

        /// <summary>
        /// Passes each item in <paramref name="enumerable"/> to <paramref name="callback"/>.
        /// </summary>
        /// <typeparam name="T">The type of the item in <paramref name="enumerable"/>.</typeparam>
        /// <param name="enumerable">The items that are to be provided to
        /// <paramref name="callback"/>.</param>
        /// <param name="callback">The method to invoke with each item from
        /// <paramref name="enumerable"/>.</param>
        public static void For<T>(this IEnumerable<T> enumerable, Action<T> callback)
        {
            foreach (var item in enumerable)
                callback(item);

            // Note: we don't return 'enumerable' here because we don't want users thinking that this
            // method executes when the IEnumerable is looped through (such as when invoking ToArray).
        }

        /// <summary>
        /// Passes each item in <paramref name="enumerable"/> to <paramref name="callback"/> along
        /// with the index of that item.
        /// </summary>
        /// <typeparam name="T">The type of the item in <paramref name="enumerable"/>.</typeparam>
        /// <param name="enumerable">The items that are to be provided to
        /// <paramref name="callback"/>.</param>
        /// <param name="callback">The method to invoke with each item from
        /// <paramref name="enumerable"/> and the index of that item.</param>
        public static void For<T>(this IEnumerable<T> enumerable, Action<T, int> callback)
        {
            int index = 0;
            foreach (var item in enumerable)
            {
                callback(item, index);
                index++;
            }

            // Note: we don't return 'enumerable' here because we don't want users thinking that this
            // method executes when the IEnumerable is looped through (such as when invoking ToArray).
        }

        /// <summary>
        /// Executes <paramref name="callback"/> on each item that gets iterated on when iterating
        /// over <see cref="IEnumerable{T}"/>.
        /// </summary>
        public static IEnumerable<T> OnIterate<T>(this IEnumerable<T> enumerable, Action<T> callback)
        {
            return enumerable.Select(t =>
            {
                callback(t);
                return t;
            });
        }

        /// <summary>
        /// Returns the values that have duplicates in <paramref name="enumerable"/>.
        /// </summary>
        /// <typeparam name="T">The type of the item in <paramref name="enumerable"/>.</typeparam>
        /// <param name="enumerable">The enumerable to look in for duplicated
        /// items.</param>
        /// <returns>The values that have duplicates in <paramref name="enumerable"/>.</returns>
        public static IEnumerable<T> Duplicated<T>(this IEnumerable<T> enumerable)
        {
            return enumerable.GroupBy(x => x)
                             .Where(group => @group.Count() > 1)
                             .Select(group => @group.Key);
        }


        /// <summary>
        /// Copies the items from the <paramref name="source"/> into the <paramref name="destination"/>
        /// until either there is nothing left to copy from <paramref name="source"/> or
        /// <paramref name="destination"/> has been filled completely.
        /// </summary>
        /// <typeparam name="T">The type of the destination and source arrays.</typeparam>
        /// <param name="source">The instance to copy the items from.</param>
        /// <param name="destination">The instance to copy the items to.</param>
        /// <param name="destinationOffset">The location from the start of destination to begin
        /// placing items.</param>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the <paramref name="destinationOffset"/>
        /// is greater than or equal to the length of <paramref name="destination"/>.</exception>
        public static void Fill<T>(this IEnumerable<T> source, T[] destination, int destinationOffset = 0)
        {
            // NOTE: You will notice that there is no generic version of this code, i.e. where source
            // is IEnumerable and destination is IList. This is because the non-generic version of
            // this method cannot handle the case where the destination array has been casted to
            // another array type (such as a byte array that has been casted to a float array) while
            // the generic version can. You'll get an ArgumentException from the non-generic version
            // in this case, though the non-generic version still works for other cases.

            destinationOffset.Throw(nameof(destinationOffset))
                             .IfGreaterThanOrEqualTo(destination.Length, $"{nameof(destination)}.Length");

            var copyCount = destination.Length - destinationOffset;

            using (var sourceEnumerator = source.GetEnumerator())
            {
                for (int i = 0; i < copyCount && sourceEnumerator.MoveNext(); i++)
                {
                    destination[destinationOffset] = sourceEnumerator.Current;
                    destinationOffset++;
                }
            }
        }

        /// <summary>
        /// Determines whether the specified <see cref="IEnumerable{T}"/>
        /// contains entirely unique items. This method was taken from:
        /// http://stackoverflow.com/questions/5391264/best-way-to-find-out-if-ienumerable-has-unique-values
        /// </summary>
        /// <typeparam name="T">The type of the item contained within the
        /// <see cref="IEnumerable{T}"/> .</typeparam>
        /// <param name="values">The <see cref="IEnumerable{T}"/> to test for
        /// unique values.</param>
        /// <returns>True if the specified <see cref="IEnumerable{T}"/> is unique;
        /// otherwise, false.</returns>
        public static bool IsUnique<T>(this IEnumerable<T> values)
        {
            return IsUnique(values, null);
        }

        /// <summary>
        /// Determines whether the specified <see cref="IEnumerable{T}"/>
        /// contains entirely unique items. This method was taken from:
        /// http://stackoverflow.com/questions/5391264/best-way-to-find-out-if-ienumerable-has-unique-values
        /// and modified to use an <see cref="IEqualityComparer{T}"/>.
        /// </summary>
        /// <typeparam name="T">The type of the item contained within the
        /// <see cref="IEnumerable{T}"/> .</typeparam>
        /// <param name="values">The <see cref="IEnumerable{T}"/> to test for
        /// unique values.</param>
        /// <param name="comparer">The <see cref="IEqualityComparer{T}"/>
        /// implementation to use when comparing values in the set, or null to
        /// use the default <see cref="IEqualityComparer{T}"/>  implementation
        /// for the set type.</param>
        /// <returns>True if the specified <see cref="IEnumerable{T}"/> is unique;
        /// otherwise, false.</returns>
        public static bool IsUnique<T>(this IEnumerable<T> values, IEqualityComparer<T> comparer)
        {
            HashSet<T> hs = new HashSet<T>(comparer);
            return values.All(hs.Add);
        }

        /// <summary>
        /// Returns a single random item from the <see cref="IEnumerable{T}"/>
        /// specified.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="IEnumerable{T}"/>.</typeparam>
        /// <param name="values">The set of values to look in for the random
        /// item.</param>
        public static T Random<T>(this IEnumerable<T> values)
            => values.Random(1, false).First();

        /// <summary>
        /// Returns a single random item from the <see cref="IEnumerable{T}"/>
        /// specified.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="IEnumerable{T}"/>.</typeparam>
        /// <param name="values">The set of values to look in for the random
        /// item.</param>
        /// <param name="random">The <see cref="System.Random"/> number generator
        /// to use when finding random items.</param>
        public static T Random<T>(this IEnumerable<T> values, Random random)
            => values.Random(1, false, random).First();

        /// <summary>
        /// Returns a set of random values from the <see cref="IEnumerable{T}"/>
        /// specified.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="IEnumerable{T}"/>.</typeparam>
        /// <param name="values">The set of values to look in for the random
        /// items.</param>
        /// <param name="count">The number of random items to return. If
        /// <paramref name="allowDuplicates"/> is true then this method will
        /// clamp this amount to the number of items in <paramref name="values"/>.</param>
        /// <param name="allowDuplicates">True if duplicate random items can be
        /// returned, false if otherwise.</param>
        /// <returns>The items that were randomly selected from <paramref name="values"/>.</returns>
        public static IEnumerable<T> Random<T>(this IEnumerable<T> values, uint count, bool allowDuplicates)
            => values.Random(count, allowDuplicates, new Random());

        /// <summary>
        /// Returns a set of random values from the <see cref="IEnumerable{T}"/>
        /// specified.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="IEnumerable{T}"/>.</typeparam>
        /// <param name="values">The set of values to look in for the random
        /// items.</param>
        /// <param name="count">The number of random items to return. If
        /// <paramref name="allowDuplicates"/> is true then this method will
        /// clamp this amount to the number of items in <paramref name="values"/>.</param>
        /// <param name="allowDuplicates">True if duplicate random items can be
        /// returned, false if otherwise.</param>
        /// <param name="random">The <see cref="System.Random"/> number generator
        /// to use when finding random items.</param>
        /// <returns>The items that were randomly selected from <paramref name="values"/>.</returns>
        public static IEnumerable<T> Random<T>(this IEnumerable<T> values, uint count, bool allowDuplicates, Random random)
        {
            if (values.Any() == false)
                throw new ArgumentOutOfRangeException("values", values,
                    "IEnumerable<T> must contain items to choose from.");

            List<T> temporary = new List<T>(values);

            // If no duplicates are allowed, then the maximum we can return is
            // all of the values randomized in a different order.
            if (allowDuplicates == false)
                count = (uint)Math.Min((int)count, temporary.Count);

            for (uint i = 0; i < count; ++i)
            {
                int randomItemIndex = random.Next(temporary.Count);
                yield return temporary[randomItemIndex];

                if (allowDuplicates == false)
                    temporary.RemoveAt(randomItemIndex);
            }
        }

        /// <summary>
        /// Groups the provided <see cref="IEnumerable{T}"/> into multiple sets whose sizes are
        /// determined by <paramref name="count"/> except the last group which may contain less than
        /// the count if <paramref name="values"/> has fewer than needed for all groups.
        /// </summary>
        /// <param name="values">The <see cref="IEnumerable{T}"/> to break into groups.</param>
        /// <param name="count">The method that dictates the size of each group.</param>
        public static IEnumerable<IEnumerable<T>> Batch<T>(this IEnumerable<T> values, Func<int> count)
        {
            return values.BatchSelect(() => (count(), 0), (batch, size) => batch);
        }

        /// <summary>
        /// Groups the provided <see cref="IEnumerable{T}"/> into multiple sets whose sizes are
        /// determined by <paramref name="count"/> except the last group which may contain less than
        /// the count if <paramref name="values"/> has fewer than needed for all groups. The sets
        /// are then passed through the selector for conversion, if necessary.
        /// </summary>
        /// <param name="values">The <see cref="IEnumerable{T}"/> to break into groups.</param>
        /// <param name="count">The method that dictates the size of each group.</param>
        /// <param name="selector">The method that converts the provided batch and its requested
        /// size into the result.</param>
        public static IEnumerable<TResult> BatchSelect<T, TCount, TResult>(
            this IEnumerable<T> values,
            Func<(int, TCount)> count,
            Func<IEnumerable<T>, (int, TCount), TResult> selector)
        {
            // ReSharper disable PossibleMultipleEnumeration
            while (values.Any())
            {
                var size = count();

                var result = values.Take(size.Item1);
                values = values.Skip(size.Item1);

                yield return selector(result, size);
            }
            // ReSharper restore PossibleMultipleEnumeration
        }

        /// <summary>
        /// Returns an <see cref="IEnumerable{T}"/> that returns and caches the content of
        /// <paramref name="source"/>. <paramref name="source"/> will only be enumerated once, and
        /// only as far as necessary.
        /// For more info see F# Seq.Cache method:
        /// https://msdn.microsoft.com/en-us/visualfsharpdocs/conceptual/seq.cache%5B%27t%5D-function-%5Bfsharp%5D
        /// </summary>
        /// <param name="source">The <see cref="IEnumerable{T}"/> whose contents are to be cached as
        /// the result of this method is enumerated.</param>
        public static IEnumerable<T> Cache<T>(this IEnumerable<T> source)
        {
            return SeqModule.Cache(source);
        }

        /// <summary>
        /// Returns an <see cref="IEnumerable{T}"/> that has <paramref name="value"/> placed in
        /// between each item in <paramref name="source"/>.
        /// </summary>
        /// <param name="source">The collection that is to have the <paramref name="value"/> placed
        /// between each item.</param>
        /// <param name="value">The value to go between each item in <paramref name="source"/>.</param>
        public static IEnumerable<T> Intersperse<T>(this IEnumerable<T> source, T value)
        {
            // Implementation was taken from https://stackoverflow.com/a/753329.

            bool first = true;
            foreach (T item in source)
            {
                if (!first) yield return value;
                yield return item;
                first = false;
            }
        }
    }
}