using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Mathematics.Geometry;

namespace Chernobyl.Mathematics.Collision
{
    /// <summary>
    /// An <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/> 
    /// that holds 
    /// <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/>
    /// instances. This class acts like a composite; for example, calling 
    /// <see cref="GetCollidables(TCollider)"/> returns the 
    /// <typeparamref name="TContainedCollidable"/> instances from the contained 
    /// <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/>
    /// that were collided against.
    /// </summary>
    /// <typeparam name="TContainedCollidable">The type of 
    /// <see cref="ICollidable"/> being held 
    /// within this <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/>. 
    /// This ICollidable 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 CollidableEnumerableComposite<TContainedCollidable, TCollider>
        : ShapeCollection, ICollidableEnumerable<TContainedCollidable, TCollider> 
        where TContainedCollidable : IExtendedCollidable<TCollider>
    {
        /// <summary>
        /// Initializes a new instance of the 
        /// <see cref="CollidableEnumerableComposite{TContainedCollidable,TCollider}"/> 
        /// class.
        /// </summary>
        /// <param name="collidables">The 
        /// <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/>
        /// this list is composed of.</param>
        public CollidableEnumerableComposite(IEnumerable<ICollidableEnumerable<TContainedCollidable, TCollider>> collidables)
            : base(collidables.Cast<IShape>().ToList())
        {
            Collidables = collidables;
        }

        /// <summary>
        /// Returns an <see cref="IEnumerable{T}"/> that can be iterated
        /// over to collect the objects that are colliding with the passed in
        /// <paramref name="collidable"/>. Note this method should never
        /// pre-compute the collisions. It should return an
        /// <see cref="IEnumerable{T}"/> that returns an
        /// <see cref="IEnumerator{T}"/> that checks for collisions as it
        /// iterates.
        /// </summary>
        /// <param name="collidable">The <see cref="ICollidable"/> to check
        /// against for collisions.</param>
        /// <returns>
        /// The <see cref="IEnumerable{T}"/> that can be iterated over
        /// to get the <see cref="ICollidable2D"/>s that are being collided
        /// against.
        /// </returns>
        public IEnumerable<TContainedCollidable> GetCollidables(TCollider collidable)
        {
            return Collidables.SelectMany(collidables => collidables.GetCollidables(collidable));
        }

        /// <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 new IEnumerator<TContainedCollidable> GetEnumerator()
        {
            return Collidables.SelectMany(containedCollidables => containedCollidables).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>
        /// Tests for a collision between all of the  and the
        /// <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/>
        /// instances contained within this instance and the
        /// <typeparamref name="TCollider"/> passed in.
        /// </summary>
        /// <param name="collidable">The <typeparamref name="TCollider"/> to
        /// test for collision against.</param>
        /// <returns>
        /// True if there was a collision with any of the contained 
        /// <see cref="ICollidableEnumerable{TContainedCollidable, TCollider}"/>
        /// instances, false if otherwise.
        /// </returns>
        public bool IsColliding(TCollider collidable)
        {
            return Collidables.Any(collidableEnumerables => collidableEnumerables.IsColliding(collidable));
        }

        /// <summary>
        /// An event that is raised when a <see cref="ICollidable"/> has
        /// started colliding with this <see cref="ICollidable"/>. When the
        /// collision has ended, <see cref="OnCollisionEnded"/> will be invoked.
        /// </summary>
        public event EventHandler OnCollisionStarted;

        /// <summary>
        /// An event that is raised when the collision with a
        /// <see cref="ICollidable"/> has ended. This will event will be raised
        /// after the invocation of <see cref="OnCollisionStarted"/>.
        /// </summary>
        public event EventHandler OnCollisionEnded;

        /// <summary>
        /// Called when this <see cref="ICollidable"/> has started colliding
        /// with another <see cref="ICollidable"/>.
        /// </summary>
        /// <param name="collider">The object that was just hit.</param>
        public void HandleCollisionStarted(ICollidable collider)
        {
            if (OnCollisionStarted != null)
                OnCollisionStarted(this, EventArgs.Empty);
        }

        /// <summary>
        /// Called when this <see cref="ICollidable"/> has stopped colliding
        /// with another <see cref="ICollidable"/>.
        /// </summary>
        /// <param name="collider">The object that was just hit.</param>
        public void HandleCollisionEnded(ICollidable collider)
        {
            if (OnCollisionEnded != null)
                OnCollisionEnded(this, EventArgs.Empty);
        }

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