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

namespace Chernobyl.DesignPatterns.Command
{
    /// <summary>
    /// An <see cref="ICommand"/> that implements the composite design pattern 
    /// (see http://en.wikipedia.org/wiki/Composite_pattern) for 
    /// <see cref="ICommand"/> objects. This type takes in several 
    /// <see cref="ICommand"/> objects. When <see cref="Execute()"/> is called 
    /// on this class, it goes through it's list of <see cref="ICommand"/> objects 
    /// and invokes <see cref="Execute()"/> on them in FIFO (first in, first out) 
    /// order. When <see cref="Undo()"/> is called on this class, it goes through 
    /// it's list of <see cref="ICommand"/> objects and invokes <see cref="Undo()"/> 
    /// on them in LIFO (last in, first out) order. Note that <see cref="Undo()"/> 
    /// is only called if the <see cref="ICommand"/> instance supports undo.
    /// </summary>
    public class CommandCollection : ICommand, ICollection<ICommand>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CommandCollection"/> 
        /// class that uses an <see cref="List{T}"/> for implementing it's 
        /// collection.
        /// </summary>
        public CommandCollection() : this(new List<ICommand>())
        { }

        /// <summary>
        /// Initializes a new instance of the <see cref="CommandCollection"/> class.
        /// </summary>
        /// <param name="collection">The <see cref="ICollection{T}"/> to use when 
        /// storing <see cref="ICommand"/> objects.</param>
        public CommandCollection(ICollection<ICommand> collection)
        {
            Collection = collection;
        }

        /// <summary>
        /// Calls <see cref="Execute()"/> on all of the <see cref="ICommand"/> 
        /// instances contained within this <see cref="ICollection{T}"/> in 
        /// FIFO (first in, first out) order.
        /// </summary>
        public void Execute()
        {
            foreach (ICommand command in Collection)
                command.Execute();
        }

        /// <summary>
        /// Calls <see cref="Undo()"/> on all of the <see cref="ICommand"/> 
        /// instances contained within this <see cref="ICollection{T}"/> in 
        /// LIFO (last in, first out) order. Note that this method will skip 
        /// <see cref="ICommand"/>s that do not support undo (i.e., 
        /// <see cref="CanUndo"/> is set to false).
        /// </summary>
        /// <exception cref="CannotUndoException">Thrown if any
        /// <see cref="ICommand"/> in this <see cref="ICollection{T}"/>does not 
        /// support undo (i.e., <see cref="CanUndo"/> is false).</exception>
        public void Undo()
        {
            foreach (ICommand command in Collection.Where(comm => comm.CanUndo).Reverse())
                command.Undo();
        }

        /// <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(ICommand item)
        {
            Collection.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()
        {
            Collection.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(ICommand item)
        {
            return Collection.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, <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"/>.
        /// </exception>
        public void CopyTo(ICommand[] array, int arrayIndex)
        {
            Collection.CopyTo(array, arrayIndex);
        }

        /// <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(ICommand item)
        {
            return Collection.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<ICommand> GetEnumerator()
        {
            return Collection.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 GetEnumerator();
        }

        /// <summary>
        /// True if at least one of the <see cref="ICommand"/> instances within  
        /// this <see cref="ICollection{T}"/> can be reverted after a call to
        /// <see cref="Execute()"/>, false if otherwise.
        /// </summary>
        public bool CanUndo
        {
            get { return Collection.Any(comm => comm.CanUndo); }
        }

        /// <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 Collection.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 Collection.IsReadOnly; }
        }

        /// <summary>
        /// The collection of <see cref="ICommand"/> objects.
        /// </summary>
        ICollection<ICommand> Collection { get; set; }
    }
}