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 the list.</typeparam>
    public abstract class EventList<T> : EventCollection<T>, IList<T>
    {
        /// <summary>
        /// Determines the index of the specified item within this list.
        /// </summary>
        /// <param name="item">The item to find the index for.</param>
        /// <returns>Returns the index of the item or -1 if the item could
        /// not be found.</returns>
        public int IndexOf(T item)
        {
            return ListDecorated.IndexOf(item);
        }

        /// <summary>
        /// Inserts an item into the list at the specified index. After the item
        /// is inserted, the event EventList{T}.OnItemsAdded will be invoked.
        /// </summary>
        /// <param name="index">The index where the item should be placed in the
        /// list.</param>
        /// <param name="item">The item to insert.</param>
        public void Insert(int index, T item)
        {
            ListDecorated.Insert(index, item);

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

        /// <summary>
        /// Removes an item at the specified index. If the item is removed,
        /// the event <see cref="IEventEnumerable.ItemsRemoved"/> will be 
        /// invoked.
        /// </summary>
        /// <param name="index">The zero-based index of the item to remove.</param>
        public void RemoveAt(int index)
        {
            if (ItemsRemovedHandler != null)
            {
                T item = ListDecorated[index];
                ListDecorated.RemoveAt(index);
                ItemsRemovedHandler(this, new ItemsEventArgs<T>(item));
            }
            else
                ListDecorated.RemoveAt(index);
        }

        /// <summary>
        /// Gets or sets the item at the specified index. If the item is set,
        /// then the event EventList{T}.ItemChangeEventArgs will be invoked.
        /// </summary>
        /// <param name="index">The index of the item to retrieve or set.</param>
        /// <returns>The item at the specified index.</returns>
        public T this[int index]
        {
            get
            {
                return ListDecorated[index];
            }
            set
            {
                // Store the old item but only if we need to since the search
                // for that item could be expensive.
                ItemsEventArgs<T> itemRemoved = null;
                if (ItemsRemovedHandler != null)
                    itemRemoved = new ItemsEventArgs<T>(ListDecorated[index]);

                ListDecorated[index] = value;

                if (ItemsRemovedHandler != null)
                    ItemsRemovedHandler(this, itemRemoved);

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

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

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