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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// Extension and utility methods for the <see cref="IList{T}"/> and related types.
    /// </summary>
    public static class List
    {
        /// <summary>
        /// Returns an empty <see cref="List{T}"/>.
        /// </summary>
        public static List<T> Empty<T>() => new List<T>();

        /// <summary>
        /// Removes the first item in the list where <paramref name="predicate"/> returns true.
        /// </summary>
        /// <returns>True if an item was removed, false if otherwise.</returns>
        public static bool RemoveFirst<T>(this IList<T> list, Predicate<T> predicate)
        {
            var removeIndex = list.IndexWhere(predicate);
            if (removeIndex != -1)
            {
                list.RemoveAt(removeIndex);
                return true;
            }
            return false;
        }

        /// <summary>
        /// Removes and returns the item at the specified index.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the list.</typeparam>
        /// <param name="list">The list that is to be modified.</param>
        /// <param name="index">The index at which to remove and return the item from. This
        /// value cannot be less than zero or greater than or equal to the lists length.</param>
        /// <returns>The value at the specified index in the list.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="index"/>
        /// is out of range.</exception>
        public static T Pull<T>(this IList<T> list, int index)
        {
            // Note: We do not error check the index because the list's indexer will
            // already do this.

            var value = list[index];
            list.RemoveAt(index);
            return value;
        }

        /// <summary>
        /// Removes and returns the items at the specified index.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the list.</typeparam>
        /// <param name="list">The list that is to be modified.</param>
        /// <param name="index">The index at which to remove and return the item from. This
        /// value cannot be less than zero or greater than or equal to the lists length.</param>
        /// <param name="count">The number of items to return</param>
        /// <returns>The value at the specified index in the list.</returns>
        /// <exception cref="ArgumentOutOfRangeException">Thrown when <paramref name="index"/>
        /// is out of range.</exception>
        public static IEnumerable<T> Pull<T>(this IList<T> list, int index, int count)
        {
            return Enumerable.From(() => list.Pull(index)).Take(count);
        }

        /// <summary>
        /// Removes and returns the item at the specified index.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the list.</typeparam>
        /// <param name="list">The list that is to be modified.</param>
        /// <param name="random">The instance that will determine the indices at which to remove and
        /// return the item from.</param>
        /// <param name="count">The number of items to extract from the list.</param>
        /// <returns>The value at the specified index in the list.</returns>
        public static IEnumerable<T> Pull<T>(this IList<T> list, Random random, int count)
        {
            count.Throw(nameof(count)).IfLessThan(0).IfGreaterThan(list.Count, "list.Count");

            for (int i = 0; i < count; i++)
                yield return list.Pull(random.Next(list.Count));
        }

        /// <summary>
        /// Returns the element at a specified index in a sequence or a default value if the index
        /// is out of range. This method performs the same function as
        /// <see cref="System.Linq.Enumerable.ElementAtOrDefault{TSource}(IEnumerable{TSource}, int)"/>
        /// but is optimized for <see cref="IList{T}"/>.
        /// </summary>
        public static T AtOrDefault<T>(this IList<T> list, int index) =>
            list.IsInBounds(index) ? list[index] : default;
    }
}