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

namespace Chernobyl.Mathematics.Collision
{
    /// <summary>
    /// An <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/> 
    /// that holds 
    /// <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
    /// instances. This class acts like a composite; for example, calling 
    /// <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}.GetCollidables(TCollider)"/>
    /// returns the <typeparamref name="TContainedCollidable"/> instances from 
    /// the contained <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
    /// that were collided against.
    /// </summary>
    /// <typeparam name="TContainedCollidable">The type of 
    /// <see cref="ICollidable"/> being held 
    /// within this <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>. 
    /// This type must derive from <see cref="IExtendedCollidable{T}"/>.</typeparam>
    /// <typeparam name="TCollider">The <see cref="ICollidable"/> type that will 
    /// be passed in to check for collisions against the 
    /// <typeparamref name="TContainedCollidable"/> instances contained within 
    /// this <see cref="ICollection{T}"/>.</typeparam>
    public class CollidableCollectionComposite<TContainedCollidable, TCollider>
        : CollidableEnumerableComposite<TContainedCollidable, TCollider>,
          ICollidableCollection<TContainedCollidable, TCollider>
          where TContainedCollidable : IExtendedCollidable<TCollider>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="CollidableCollectionComposite{TContainedCollidable, TCollider}"/>
        /// class.
        /// </summary>
        /// <param name="collidables">The <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// this list is composed of.</param>
        public CollidableCollectionComposite(IEnumerable<ICollidableCollection<TContainedCollidable, TCollider>> collidables)
            : base(collidables.Cast<ICollidableEnumerable<TContainedCollidable, TCollider>>())
        {
            Collidables = collidables;
        }

        /// <summary>
        /// Adds the argument passed in to all
        /// <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// instances contained within this <see cref="ICollection{T}"/> provided
        /// they are not read only (if they are the argument is not added to that
        /// instance).
        /// </summary>
        /// <param name="item">The object to add to all (except those that are 
        /// read only) of the <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// instances contained within the <see cref="ICollection{T}"/>.</param>
        public void Add(TContainedCollidable item)
        {
            foreach (ICollidableCollection<TContainedCollidable, TCollider> containedCollidables in Collidables)
            {
                if (containedCollidables.IsReadOnly == false)
                    containedCollidables.Add(item);
            }
        }

        /// <summary>
        /// Removes the argument passed in from all
        /// <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// instances contained within this <see cref="ICollection{T}"/>.
        /// </summary>
        /// <param name="item">The object to remove from all the
        /// <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// instances.</param>
        /// <returns>True if <paramref name="item"/> was successfully removed 
        /// from at least one of the 
        /// <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// instances contained within this <see cref="ICollection{T}"/>.
        /// </returns>
        public bool Remove(TContainedCollidable item)
        {
            bool result = false;

            foreach (ICollidableCollection<TContainedCollidable, TCollider> containedCollidables in Collidables)
            {
                if (containedCollidables.IsReadOnly == false && containedCollidables.Remove(item) == true)
                    result = true;
            }

            return result;
        }

        /// <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(TContainedCollidable item)
        {
            bool result = false;

            using (IEnumerator<ICollidableCollection<TContainedCollidable, TCollider>> enumerator = Collidables.GetEnumerator())
            {
                while (enumerator.MoveNext() == true &&
                       enumerator.Current != null &&
                       result == false)
                    result = enumerator.Current.Contains(item);
            }

            return result;
        }

        /// <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"> Thrown if 
        /// <paramref name="array"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if
        /// <paramref name="arrayIndex"/> is less than 0.</exception>
        /// <exception cref="ArgumentException">Thrown if <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(TContainedCollidable[] array, int arrayIndex)
        {
            // TODO: implement this.
            throw new NotImplementedException("This method is not currently implemented at the moment.");
        }

        /// <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>
        public new IEnumerator GetEnumerator()
        {
            return base.GetEnumerator();
        }

        /// <summary>
        /// The <see cref="ICollidableCollection{TContainedCollidable, TCollider}"/>
        /// this list is composed of.
        /// </summary>
        public new IEnumerable<ICollidableCollection<TContainedCollidable, TCollider>> Collidables { get; private set; }
    }
}