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

namespace Chernobyl.Creation.Collections
{
    /// <summary>
    /// An <see cref="IBuilder{TItem}"/> and <see cref="ICollection{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="ICollection{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 BuilderCollection<TFactory, TItem> : BuilderEnumerable<TFactory, TItem>, ICollection<TFactory>
        where TFactory : IBuilder<TItem>
    {
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="BuilderCollection{TFactory, TItem}"/> class.
        /// </summary>
        public BuilderCollection()
            : this(Enumerable.Empty<TFactory>())
        {}

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="BuilderCollection{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 BuilderCollection(IEnumerable<TFactory> builders)
        {
            builders.ThrowIfNull("builders");

            _builders = new List<TFactory>(builders);
            foreach (TFactory builder in _builders)
                builder.Created += OnItemCreated;
        }

        /// <summary>
        /// Adds an item to the <see cref="ICollection{TItem}" />.
        /// </summary>
        /// <param name="item">The object to add to the 
        /// <see cref="ICollection{TItem}" />.</param>
        public void Add(TFactory item)
        {
            _builders.Add(item);
            item.Created += OnItemCreated;
        }

        /// <summary>
        /// Removes all items from the <see cref="ICollection{TItem}" />.
        /// </summary>
        public void Clear()
        {
            foreach (TFactory builder in _builders)
                builder.Created -= OnItemCreated;
            _builders.Clear();
        }

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

        /// <summary>
        /// Copies the elements of the <see cref="ICollection{TItem}" /> 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{TItem}" />.
        /// 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>
        public void CopyTo(TFactory[] array, int arrayIndex)
        {
            _builders.CopyTo(array, arrayIndex);
        }

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

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

        /// <summary>
        /// Removes the first occurrence of a specific object from the 
        /// <see cref="ICollection{TItem}" />.
        /// </summary>
        /// <param name="item">The object to remove from the 
        /// <see cref="ICollection{TItem}" />.</param>
        /// <returns>
        /// true if <paramref name="item" /> was successfully removed from the 
        /// <see cref="ICollection{TItem}" />; otherwise, false. This method also 
        /// returns false if <paramref name="item" /> is not found in the 
        /// original <see cref="ICollection{TItem}" />.
        /// </returns>
        public bool Remove(TFactory item)
        {
            bool result = _builders.Remove(item);
            
            if (result)
                item.Created -= OnItemCreated;

            return result;
        }

        /// <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 override IEnumerable<TFactory> Builders
        {
            get { return _builders; }
        }

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