using System;
using System.Collections.Generic;
using Chernobyl.Event;

namespace Chernobyl.Collections.Generic.Event
{
    /// <summary>
    /// Type that is designed to make the implementation of new 
    /// <see cref="IEventCollection{T}"/> easier to create.
    /// </summary>
    /// <typeparam name="T">The type that is to be held within this 
    /// <see cref="ICollection{T}"/>.</typeparam>
    public abstract class EventCollection<T> : EventEnumerable<T>, IEventCollection<T>
    {
        /// <summary>
        /// Adds an item to the <see cref="ICollection{T}"/>. After the 
        /// item is added, the event <see cref="IEventEnumerable{T}.ItemsAdded"/> 
        /// will be invoked.
        /// </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)
        {
            CollectionDecorated.Add(item);

            if (ItemsAddedHandler != null)
                ItemsAddedHandler(this, new ItemsEventArgs<T>(item));
        }

        /// <summary>
        /// Removes all items from the <see cref="ICollection{T}"/>. If any 
        /// items are cleared from the list, the event 
        /// <see cref="IEventEnumerable{T}.ItemsRemoved"/> will be invoked.
        /// </summary>
        /// <exception cref="NotSupportedException">The 
        /// <see cref="ICollection{T}"/> is read-only. </exception>
        public void Clear()
        {
            if (CollectionDecorated.Count > 0)
            {
                if (ItemsRemovedHandler != null)
                {
                    // grab all the items that are being removed then clear the list
                    T[] items = new T[CollectionDecorated.Count];
                    CollectionDecorated.CopyTo(items, 0);
                    CollectionDecorated.Clear();

                    // send out the event
                    ItemsRemovedHandler(this, new ItemsEventArgs<T>(items));
                }
                else
                    CollectionDecorated.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 CollectionDecorated.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)
        {
            CollectionDecorated.CopyTo(array, arrayIndex);
        }

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

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

        /// <summary>
        /// Removes the first occurrence of a specific object from the 
        /// <see cref="ICollection{T}"/>. If the 
        /// item is successfully removed, then the event 
        /// <see cref="IEventEnumerable{T}.ItemsRemoved"/> will be invoked.
        /// </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)
        {
            bool returnResult = CollectionDecorated.Remove(item);

            if (returnResult && ItemsRemovedHandler != null)
                ItemsRemovedHandler(this, new ItemsEventArgs<T>(item));

            return returnResult;
        }

        /// <summary>
        /// The <see cref="ICollection{T}"/> being decorated or extended with
        /// event capabilities.
        /// </summary>
        protected abstract ICollection<T> CollectionDecorated { get; }

        /// <summary>
        /// The <see cref="IEventEnumerable{T}" /> being decorated or extended
        /// with event capabilities.
        /// </summary>
        protected override IEnumerable<T> GenericEnumerableDecorated
        {
            get { return CollectionDecorated; }
        }
    }
}