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

namespace Chernobyl.Collections.Generic
{
    /// <summary>
    /// An implementation of <see cref="ICollection{T}"/> that makes the
    /// creation of new <see cref="ICollection{T}"/> instances easier.
    /// </summary>
    /// <typeparam name="T">The type that is contained within the 
    /// <see cref="ICollection{T}"/>.</typeparam>
    public abstract class Collection<T> : ICollection<T>
    {
        /// <summary>
        /// Adds an item to the <see cref="ICollection{T}"/>.
        /// </summary>
        /// <param name="item">The object to add to the <see cref="ICollection{T}"/>.</param>
        /// <exception cref="NotSupportedException">
        /// The <see cref="ICollection{T}"/> is read-only.
        ///   </exception>
        public void Add(T item)
        {
            Implementation.Add(item);
        }

        /// <summary>
        /// Removes all items from the <see cref="ICollection{T}"/>.
        /// </summary>
        /// <exception cref="NotSupportedException">
        /// The <see cref="ICollection{T}"/> is read-only.
        ///   </exception>
        public void Clear()
        {
            Implementation.Clear();
        }

        /// <summary>
        /// Determines whether the <see cref="ICollection{T}"/> contains a 
        /// specific value.
        /// </summary>
        /// <param name="item">The object to locate in the 
        /// <see cref="ICollection{T}"/>.</param>
        /// <returns>
        /// true if <paramref name="item"/> is found in the 
        /// <see cref="ICollection{T}"/>; otherwise, false.
        /// </returns>
        public bool Contains(T item)
        {
            return Implementation.Contains(item);
        }

        /// <summary>
        /// Copies the elements of the <see cref="ICollection{T}"/> to an 
        /// <see cref="Array"/>, starting at a particular <see cref="Array"/> 
        /// index.
        /// </summary>
        /// <param name="array">The one-dimensional <see cref="Array"/> that is 
        /// the destination of the elements copied from 
        /// <see cref="ICollection{T}"/>. The <see cref="Array"/> must have 
        /// zero-based indexing.</param>
        /// <param name="arrayIndex">The zero-based index in 
        /// <paramref name="array"/> at which copying begins.</param>
        /// <exception cref="ArgumentNullException"><paramref name="array"/> is 
        /// null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">
        /// <paramref name="arrayIndex"/> is less than 0.</exception>
        ///   
        /// <exception cref="ArgumentException"><paramref name="array"/> is 
        /// multidimensional, or <paramref name="arrayIndex"/> is equal to or 
        /// greater than the length of <paramref name="array"/>, or the number 
        /// of elements in the source <see cref="ICollection{T}"/> is greater 
        /// than the available space from <paramref name="arrayIndex"/> to the 
        /// end of the destination <paramref name="array"/>, or type 
        /// <typeparamref name="T"/> cannot be cast automatically to the type of the 
        /// destination <paramref name="array"/>.</exception>
        public void CopyTo(T[] array, int arrayIndex)
        {
            Implementation.CopyTo(array, arrayIndex);
        }

        /// <summary>
        /// Gets the number of elements contained in the <see cref="ICollection{T}"/>.
        /// </summary>
        /// <returns>
        /// The number of elements contained in the <see cref="ICollection{T}"/>.
        ///   </returns>
        public int Count
        {
            get { return Implementation.Count; }
        }

        /// <summary>
        /// Gets a value indicating whether the <see cref="ICollection{T}"/> is 
        /// read-only.
        /// </summary>
        /// <returns>true if the <see cref="ICollection{T}"/> is read-only; 
        /// otherwise, false.</returns>
        public bool IsReadOnly
        {
            get { return Implementation.IsReadOnly; }
        }

        /// <summary>
        /// Removes the first occurrence of a specific object from the 
        /// <see cref="ICollection{T}"/>.
        /// </summary>
        /// <param name="item">The object to remove from the 
        /// <see cref="ICollection{T}"/>.</param>
        /// <returns>
        /// True if <paramref name="item"/> was successfully removed from the 
        /// <see cref="ICollection{T}"/>; otherwise, false. This method also 
        /// returns false if <paramref name="item"/> is not found in the 
        /// original <see cref="ICollection{T}"/>.
        /// </returns>
        /// <exception cref="NotSupportedException">
        /// The <see cref="ICollection{T}"/> is read-only.
        /// </exception>
        public bool Remove(T item)
        {
            return Implementation.Remove(item);
        }

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>
        /// A <see cref="IEnumerator{T}"/> that can be used to iterate through 
        /// the collection.
        /// </returns>
        public IEnumerator<T> GetEnumerator()
        {
            return Implementation.GetEnumerator();
        }

        /// <summary>
        /// Returns an enumerator that iterates through a collection.
        /// </summary>
        /// <returns>
        /// An <see cref="IEnumerator"/> object that can be used to iterate 
        /// through the collection.
        /// </returns>
        IEnumerator IEnumerable.GetEnumerator()
        {
            return Implementation.GetEnumerator();
        }

        /// <summary>
        /// The implementation of this <see cref="ICollection{T}"/>.
        /// </summary>
        protected abstract ICollection<T> Implementation { get; }
    }
}