using System;
using System.Collections.Generic;
using System.Linq;
using Chernobyl.Collections.Generic;
using Chernobyl.ComponentModel;
using Chernobyl.Creation;
using Chernobyl.Event;
using Chernobyl.Readiness;
using Chernobyl.Switch;
using Chernobyl.Update;
using Chernobyl.Values;

namespace Chernobyl.Mathematics.Collision
{
    /// <summary>
    /// A type that actively checks for collisions between the <see cref="Collider"/>
    /// and the <typeparamref name="TContainedCollidable"/> instances contained
    /// within <see cref="Collidables"/>.
    /// </summary>
    /// <typeparam name="TContainedCollidable">The type of the
    /// <see cref="ICollidable"/> instances that are to be checked against for
    /// collision with <see cref="Collider"/>. This ICollidable type must derive
    /// from <see cref="IExtendedCollidable{T}"/>.</typeparam>
    /// <typeparam name="TCollider">The <see cref="ICollidable"/> type that will
    /// be checked for collisions against the
    /// <typeparamref name="TContainedCollidable"/> instances contained within
    /// <see cref="Collidables"/>.</typeparam>
    public class CollisionChecker<TContainedCollidable, TCollider> : Updateable
        where TContainedCollidable : IExtendedCollidable<TCollider>
    {

        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="CollisionChecker{TContainedCollidable, TCollider}"/> class.
        /// </summary>
        /// <param name="collidables">The objects that are to be checked for
        /// collision against <see cref="Collider"/>.</param>
        /// <param name="collider">The object that is to be checked for collision
        /// against the objects in <see cref="Collidables"/>.</param>
        public CollisionChecker(ICollidableEnumerable<TContainedCollidable, TCollider> collidables,
                                TCollider collider)
        {
            _previousCollidables = new LinkedList<TContainedCollidable>();
            _currentCollidables = new LinkedList<TContainedCollidable>();
            _startedColliding = new LinkedList<TContainedCollidable>();

            Collider = collider;
            Collidables = collidables;
        }

        /// <summary>
        /// An event that is raised when the <see cref="Collider"/> has began
        /// colliding with one or more <typeparamref name="TContainedCollidable"/>
        /// instances in <see cref="Collidables"/>. Any
        /// <see cref="EventHandler{TEventArgs}"/> that is added to this event
        /// will get invoked immediately if a collision is already occurring.
        /// </summary>
        public event EventHandler<CollisionEventArgs> CollisionStarted
        {
            add
            {
                _collisionStarted += value;

                if (_startedColliding.Any() == true)
                    value(this, new CollisionEventArgs(_startedColliding, Collider));
            }
            remove { _collisionStarted -= value; }
        }

        /// <summary>
        /// An event that is raised when the <see cref="Collider"/> has stopped
        /// colliding with one or more <typeparamref name="TContainedCollidable"/>
        /// instances in <see cref="Collidables"/> that were previously being
        /// collided with.
        /// </summary>
        public event EventHandler<CollisionEventArgs> CollisionEnded;

        /// <summary>
        /// The objects that are to be checked for collision against
        /// <see cref="Collider"/>.
        /// </summary>
        public ICollidableEnumerable<TContainedCollidable, TCollider> Collidables
        {
            get { return _collidables; }
            private set
            {
                if(value == null)
                    throw new ArgumentNullException("value", "You must provide " +
                    "a non-null collection of collidables.");

                _collidables = value;
            }
        }

        /// <summary>
        /// The object that is to be checked for collision against the objects
        /// in <see cref="Collidables"/>.
        /// </summary>
        public TCollider Collider { get; private set; }

        /// <summary>
        /// Figures out which items are currently colliding and which are no
        /// longer colliding. The events <see cref="CollisionStarted"/> and
        /// <see cref="CollisionEnded"/> as needed from this method.
        /// </summary>
        /// <param name="deltaTime">The amount of time that has
        /// passed since this update was last called.</param>
        public override void Update(TimeSpan deltaTime)
        {
            // get our collision point and update our collidable with this new
            // point
            IEnumerable<TContainedCollidable> collidables = Collidables.GetCollidables(Collider);

            // Inform both sides of the collision, collect the items that have
            // just started colliding with each other, and removed
            _startedColliding.Clear();
            foreach (TContainedCollidable coll in collidables)
            {
                if (_previousCollidables.Remove(coll) == false)
                {
                    // Note that we could perform the ICollidable.HandleCollisionStarted(ICollidable)
                    // but that would create problems if a user removed an instance
                    // from Collidables while we are iterating through it. So we
                    // invoke those method later in this method.

                    _startedColliding.AddLast(coll);
                }

                // Save this collidable for the next update.
                _currentCollidables.AddLast(coll);
            }

            // Let client code know of the newly hit items.
            if (_startedColliding.Any() == true)
            {
                foreach (TContainedCollidable collidable in _startedColliding)
                {
                    // we have never hit this collidable; call the start of the
                    // collision handling and add it to our previous collidables
                    // list
                    Collidables.HandleCollisionStarted(collidable);
                    collidable.HandleCollisionStarted(Collidables);
                }

                if(_collisionStarted != null)
                    _collisionStarted(this, new CollisionEventArgs(_startedColliding, Collider));
            }

            // Any collidables left were not hit this time around so we handle
            // the collision ending and remove them from our previous collidables
            // list
            if (_previousCollidables.Any() == true)
            {
                if(CollisionEnded != null)
                    CollisionEnded(this, new CollisionEventArgs(_previousCollidables, Collider));

                foreach (ICollidable2D coll in _previousCollidables)
                {
                    Collidables.HandleCollisionEnded(coll);
                    coll.HandleCollisionEnded(Collidables);
                }
            }

            // now update our previous collidable list with our current collidables
            _previousCollidables.AddRange(_currentCollidables);
            _currentCollidables.Clear();

            // The base class will update the children.
            base.Update(deltaTime);
        }

        /// <summary>
        /// An <see cref="EventArgs"/> that contains data regarding collision.
        /// </summary>
        public class CollisionEventArgs : EventArgs
        {
            /// <summary>
            /// Initializes a new instance of the
            /// <see cref="CollisionChecker{TContainedCollidable, TCollider}.CollisionEventArgs"/>
            /// class.
            /// </summary>
            /// <param name="collidables">The instances that were involved in the
            /// collision.</param>
            /// <param name="collider">The instance that collided with the
            /// <paramref name="collidables"/>.</param>
            public CollisionEventArgs(IEnumerable<TContainedCollidable> collidables,
                                      TCollider collider)
            {
                Collider = collider;
                Collidables = collidables;
            }

            /// <summary>
            /// The instances that were involved in the collision.
            /// </summary>
            public IEnumerable<TContainedCollidable> Collidables { get; private set; }

            /// <summary>
            /// The instance that collided with the <see cref="Collidables"/>.
            /// </summary>
            public TCollider Collider { get; private set; }
        }

        /// <summary>
        /// <typeparamref name="TContainedCollidable"/> instances that were hit
        /// previously and may need to have their
        /// <see cref="ICollidable.HandleCollisionEnded(ICollidable)"/> method
        /// invoked when they have stopped colliding.
        /// </summary>
        LinkedList<TContainedCollidable> _previousCollidables;

        /// <summary>
        /// The list that is used to hold the <typeparamref name="TContainedCollidable"/>
        /// currently being collided with in the <see cref="Update(TimeSpan)"/>
        /// method.
        /// </summary>
        LinkedList<TContainedCollidable> _currentCollidables;

        /// <summary>
        /// The list of <typeparamref name="TContainedCollidable"/> instances
        /// from <see cref="Collidables"/> that have just started colliding with
        /// <see cref="Collider"/>.
        /// </summary>
        LinkedList<TContainedCollidable> _startedColliding;

        /// <summary>
        /// The backing field to <see cref="Collidables"/>.
        /// </summary>
        ICollidableEnumerable<TContainedCollidable, TCollider> _collidables;

        /// <summary>
        /// The backing field to <see cref="CollisionStarted"/>.
        /// </summary>
        EventHandler<CollisionEventArgs> _collisionStarted;
    }
}