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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// A set of extension methods for the <see cref="ICollection{T}"/> type.
    /// </summary>
    public static class CollectionExtensions
    {
        /// <summary>
        /// Adds several items to an <see cref="ICollection{T}"/>. Note that
        /// this implementation performs a foreach over the items to be added
        /// and adds each one using <see cref="ICollection{T}.Add(T)"/>. This
        /// will be slow over some <see cref="ICollection{T}"/> types but
        /// necessary in cases where it is the only option.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="ICollection{T}"/>.</typeparam>
        /// <param name="collection">The <see cref="ICollection{T}"/> that is to
        /// have the items added to it.</param>
        /// <param name="items">The items that are to be added to the collection.</param>
        public static void AddRange<T>(this ICollection<T> collection, IEnumerable<T> items)
        {
            foreach (T value in items)
                collection.Add(value);
        }

        /// <summary>
        /// Adds several items to an <see cref="ICollection{T}"/>. Note that
        /// this implementation performs a foreach over the items to be added
        /// and adds each one using <see cref="ICollection{T}.Add(T)"/>. This
        /// will be slow over some <see cref="ICollection{T}"/> types but
        /// necessary in cases where it is the only option.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="ICollection{T}"/>.</typeparam>
        /// <param name="collection">The <see cref="ICollection{T}"/> that is to
        /// have the items added to it.</param>
        /// <param name="items">The items that are to be added to the collection.</param>
        public static void AddRange<T>(this ICollection<T> collection, params T[] items) =>
            collection.AddRange((IEnumerable<T>)items);

        /// <summary>
        /// Removes several items from an <see cref="ICollection{T}"/>.
        /// </summary>
        /// <typeparam name="T">The type of the items contained within the
        /// <see cref="ICollection{T}"/>.</typeparam>
        /// <param name="collection">The <see cref="ICollection{T}"/> that is to
        /// have the items removed from it.</param>
        /// <param name="items">The items that are to be removed from the
        /// <see cref="ICollection{T}"/>.</param>
        /// <exception cref="ArgumentException">Thrown if <paramref name="collection"/>
        /// and <paramref name="items"/> are the same instance. This method should
        /// not be used to remove all items from an <see cref="ICollection{T}"/>
        /// as <see cref="ICollection{T}.Clear()"/> would be a faster way to
        /// do that.</exception>
        public static void RemoveRange<T>(this ICollection<T> collection, IEnumerable<T> items)
        {
            if(ReferenceEquals(collection, items))
                throw new ArgumentException("The IEnumerable<T> of items being " +
                                            "removed (parameter named 'items') and " +
                                            "the ICollection<T> that the items " +
                                            "are being removed from are the same " +
                                            "instance. Use ICollection<T>.Clear() " +
                                            "if you want to remove all items from " +
                                            "an ICollection<T>", nameof(items));

            foreach (T value in items)
                collection.Remove(value);
        }

        /// <summary>
        /// Returns true if the <paramref name="index"/> is within the range of <paramref name="values"/>,
        /// false if otherwise.
        /// </summary>
        public static bool IsInBounds(this ICollection values, int index)
            => 0 <= index && index <= (values.Count - 1);

        /// <summary>
        /// Returns true if the <paramref name="index"/> is within the range of <paramref name="values"/>,
        /// false if otherwise.
        /// </summary>
        public static bool IsInBounds<T>(this ICollection<T> values, int index)
            => 0 <= index && index <= (values.Count - 1);

        /// <summary>
        /// Returns true if the <paramref name="index"/> is within the range of <paramref name="values"/>,
        /// false if otherwise.
        /// </summary>
        public static bool IsInBounds<T>(this T[] values, int index)
            // This method exists to prevent ambiguous reference compiler error that results from
            // calling IsInBounds on arrays.
            => ((ICollection)values).IsInBounds(index);
    }
}