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

namespace Chernobyl.Creation.Collections
{
    /// <summary>
    /// An <see cref="IBuilder{TItem}" /> and <see cref="IEnumerable{T}" /> that stores
    /// other <see cref="IBuilder{TItem}" /> instances and acts as a composite
    /// (http://en.wikipedia.org/wiki/Composite_pattern) for those instances.
    /// </summary>
    /// <typeparam name="TFactory">The <see cref="IFactory{T}"/> type that is to
    /// be held by this <see cref="IEnumerable{T}"/>.</typeparam>
    /// <typeparam name="TItem">The type that is created by the <see cref="IBuilder{TItem}" />
    /// instances that will be contained within this instance.</typeparam>
    public class BuilderEnumerable<TFactory, TItem> : Builder<TItem>, IEnumerable<TFactory>
        where TFactory : IBuilder<TItem>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="BuilderEnumerable{TFactory, TItem}"/> class.
        /// </summary>
        /// <param name="builders">The <see cref="IBuilder{TItem}"/> instance whose
        /// <see cref="IBuilder{TItem}.Created"/> event is to be forwarded through 
        /// this instance.</param>
        public BuilderEnumerable(IEnumerable<TFactory> builders)
        {
            builders.ThrowIfNull("builders");

            _builders = builders;
            foreach (TFactory builder in _builders)
                builder.Created += OnItemCreated;
        }

        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="BuilderEnumerable{TFactory, TItem}"/> class. If you invoke
        /// this constructor, you must override <see cref="Builders"/> to provide
        /// the appropriate <see cref="IEnumerable{TItem}"/>.
        /// </summary>
        protected BuilderEnumerable()
        {}

        /// <summary>
        /// Returns an enumerator that iterates through the collection.
        /// </summary>
        /// <returns>A <see cref="IEnumerator{TItem}" /> that can be used to iterate
        /// through the collection.</returns>
        public IEnumerator<TFactory> GetEnumerator()
        {
            return Builders.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>
        /// An event handler that can be assigned to any event which notifies
        /// client code of created items. This method will raise this instance's
        /// <see cref="IBuilder{TResult}.Created"/> event.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The arguments containing the event data.</param>
        protected void OnItemCreated(object sender, CreationEventArgs<TItem> e)
        {
            if (CreatedMethod != null)
                CreatedMethod(this, e);
        }

        /// <summary>
        /// The <see cref="ICollection{TItem}" /> of <see cref="IBuilder{TItem}"/>
        /// instances whose <see cref="IBuilder{TItem}.Created"/> event is being 
        /// listened to by this instance.
        /// </summary>
        protected virtual IEnumerable<TFactory> Builders
        {
            get { return _builders; }
        }

        /// <summary>
        /// The backing field to <see cref="Builders"/>.
        /// </summary>
        readonly IEnumerable<TFactory> _builders;
    }
}