using System;
using System.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Graphics;
using Chernobyl.Graphics.Drawing;
using Chernobyl.Graphics.Material.Shader.Parameters;
using Chernobyl.Graphics.Texture;
using Chernobyl.Mathematics;
using Chernobyl.Mathematics.Collision;
using Chernobyl.Mathematics.Geometry;
using Chernobyl.Mathematics.Mechanics;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Readiness;
using Chernobyl.Update;

namespace Chernobyl.Interface.Tool
{
    /// <summary>
    /// The default implementation of the ICursor. Represents an on screen 
    /// cursor that is driven by some input device like a mouse or gamepad. Do 
    /// NOT handle the type <see cref="Cursor"/> because not all cursors derive
    /// from <see cref="Cursor"/>. Instead, handle the type <see cref="ICursor"/>.
    /// </summary>
    public class Cursor : Sprite, ICursor
    {
        /// <summary>
        /// Constructs a Cursor instance that uses a sprite for its drawing and
        /// transformations.
        /// </summary>
        /// <param name="services">The service holder instance that takes
        /// services and gives them out.</param>
        /// <param name="textureFilePathOrName">The path to the texture file or 
        /// the name of the texture resource to use as the <see cref="Sprite"/> 
        /// instance's image.</param>
        /// <param name="control">The <see cref="ITransform"/> that drives this 
        /// <see cref="ICursor"/>.</param>
        public Cursor(IEventCollection<object> services, string textureFilePathOrName, ITransform control)
            : this(services, new Texture2D(services, textureFilePathOrName), control, null)
        { }

        /// <summary>
        /// Constructs a Cursor instance that uses a sprite for its drawing and
        /// transformations.
        /// </summary>
        /// <param name="services">The service holder instance that takes
        /// services and gives them out.</param>
        /// <param name="texture">The texture to use for the image of the 
        /// <see cref="ICursor"/>.</param>
        /// <param name="control">The <see cref="ITransform"/> that drives this 
        /// <see cref="ICursor"/>.</param>
        public Cursor(IEventCollection<object> services, ITexture texture, ITransform control)
            : this(services, texture, control, null)
        { }

        /// <summary>
        /// Constructs a Cursor instance that uses a sprite for its drawing and
        /// transformations.
        /// </summary>
        /// <param name="services">The service holder instance that takes
        /// services and gives them out.</param>
        /// <param name="texture">The texture to use for the image of the 
        /// <see cref="ICursor"/>.</param>
        /// <param name="control">The <see cref="ITransform"/> that drives this 
        /// <see cref="ICursor"/>.</param>
        /// <param name="collisionGroupScaleAmount">The amount to scale the
        /// <see cref="CollidableCollection"/> by in the both the X and Y axes or null
        /// if the default scale amount specified by
        ///  <see cref="DefaultCollisionGroupScaleAmount"/> is to be used.</param>
        public Cursor(IEventCollection<object> services, ITexture texture, ITransform control, Vector2? collisionGroupScaleAmount)
            : base(services, texture)
        {
            Control = control;

            // create the Point2D at the upper left corner of the sprite. Note 
            // that, this only works if the sprite is using a mesh element 
            // square that is 1x1 (which is what it uses if you specify a simple 
            // texture).
            Point = new Point2D(-.5f, .5f);

            PreviousCollidables = new LinkedList<IExtendedCollidable<Point2D>>();

            if (collisionGroupScaleAmount.HasValue == true)
                _collisionCollectionScaleAmount = collisionGroupScaleAmount.Value;

            _services = services;
            _services.Inject(this);
        }

        /// <summary>
        /// Updates the cursor by performing a collision check against the 
        /// collidableCollection held by this cursor and calling the 
        /// ICollidable.HandleCollision() method on all the collided with objects
        /// including this cursor.
        /// </summary>
        /// <param name="deltaTime">The change in time since last update.</param>
        public void Update(TimeSpan deltaTime)
        {
            if(CollidableCollection != null)
            {
                // get our collision point and update our collidable with this new
                // point
                IEnumerable<IExtendedCollidable<Point2D>> collidables = CollidableCollection.GetCollidables(Point);

                // inform both sides of the collision.
                LinkedList<IExtendedCollidable<Point2D>> currentCollidables = new LinkedList<IExtendedCollidable<Point2D>>();
                foreach (IExtendedCollidable<Point2D> coll in collidables)
                {
                    if (PreviousCollidables.Remove(coll) == false)
                    {
                        // we have never hit this collidable; call the start of the
                        // collision handling and add it to our previous collidables
                        // list
                        HandleCollisionStarted(coll);
                        coll.HandleCollisionStarted(this);
                    }

                    // add this to our current collidables list
                    currentCollidables.AddLast(coll);
                }

                // Any collidables left were not hit this time around so we handle
                // the collision ending and remove them from our previous collidables 
                // list
                foreach (ICollidable2D coll in PreviousCollidables)
                {
                    HandleCollisionEnded(coll);
                    coll.HandleCollisionEnded(this);
                }

                // now update our previous collidable list with our current collidables
                PreviousCollidables = currentCollidables;   
            }
        }

        /// <summary>
        /// The first button on the cursor. This button is used to click on objects,
        /// select those objects, choose from lists, etc. This button is often
        /// the left mouse button.
        /// </summary>
        public IButton FirstButton
        {
            // TODO: get rid of this property. Do the same for ICursor.
            get
            {
                throw new NotSupportedException("Cursor.FirstButton has " + 
                "been deprecated.");
            }
            set
            {
                throw new NotSupportedException("Cursor.FirstButton has " +
                    "been deprecated.");
            }
        }

        /// <summary>
        /// The second button on the cursor. This button is used to click on
        /// objects, select those objects, choose from lists, etc. This button
        /// is often the right mouse button.
        /// </summary>
        public IButton SecondButton
        {
            // TODO: get rid of this property. Do the same for ICursor.
            get
            {
                throw new NotSupportedException("Cursor.SecondButton has " +
                "been deprecated.");
            }
            set
            {
                throw new NotSupportedException("Cursor.SecondButton has " +
                    "been deprecated.");
            }
        }

        /// <summary>
        /// The third button on the cursor. This button is used to click on
        /// objects, select those objects, choose from lists, etc. This button
        /// is often the middle mouse button.
        /// </summary>
        public IButton ThirdButton
        {
            // TODO: get rid of this property. Do the same for ICursor.
            get
            {
                throw new NotSupportedException("Cursor.ThirdButton has " +
                "been deprecated.");
            }
            set
            {
                throw new NotSupportedException("Cursor.ThirdButton has " +
                    "been deprecated.");
            }
        }

        /// <summary>
        /// The parent of this IUpdateable or null if this IUpdateable does not
        /// have a parent.
        /// </summary>
        public IUpdateable UpdateableParent { get; set; }

        /// <summary>
        /// The updateable children of this cursor.
        /// </summary>
        public ICollection<IUpdateable> UpdateableChildren { get; private set; }

        /// <summary>
        /// The collision group whose collidables are checked for collisions.
        /// </summary>
        public ICollidableCollection<IExtendedCollidable<Point2D>, Point2D> CollidableCollection { get; private set; }

        /// <summary>
        /// Sets the <see cref="IUpdateable"/> that will become the 
        /// <see cref="UpdateableParent"/>  of this cursor.
        /// </summary>
        [Inject(Type = typeof(IRootUpdateable))]
        public IUpdateable UpdateableService
        {
            set
            {
                Updateable.MakeParentChild(value, this);
            }
        }

        /// <summary>
        /// The instance that gives information about the back buffer viewport.
        /// </summary>
        [Inject]
        public IBackBufferViewport BackBufferViewport
        {
            set
            {
                IBackBufferViewport previousBackBufferViewport = _backBufferViewport;
                _backBufferViewport = value;

                // Unconfigure from the old IBackBufferViewport
                if(previousBackBufferViewport != null)
                    Transform.SeperateParentChild(previousBackBufferViewport.ViewArea, _viewArea);

                // Configure with the new IBackBufferViewport
                if (_backBufferViewport != null)
                {
                    // Create the collidable collection for this cursor, this 
                    // collidable collection will cover the entire plus the scale 
                    // amount specified by _collisionCollectionScaleAmount.

                    _viewArea = new Rectangle(-_collisionCollectionScaleAmount.X * .5f, -_collisionCollectionScaleAmount.Y * .5f,
                                               _collisionCollectionScaleAmount.X, _collisionCollectionScaleAmount.Y);

                    Transform.MakeParentChild(_backBufferViewport.ViewArea, _viewArea);

                    ICollidableCollection<IExtendedCollidable<Point2D>, Point2D> previousCollidableCollection =
                        CollidableCollection;
                    CollidableCollection = new QuadTree<IExtendedCollidable<Point2D>, Point2D>(_viewArea);

                    // If we had a previous CollidableCollection than we need
                    // to add the items from it to the new CollidableCollection.
                    if (previousCollidableCollection != null)
                    {
                        foreach (IExtendedCollidable<Point2D> extendedCollidable in previousCollidableCollection)
                            CollidableCollection.Add(extendedCollidable);
                    }

                    // Attach together the controller and the IRender's parent.
                    // The Render.TransformParent is not set until 
                    // Sprite.TextureParameterValueBecameReady(object, EventArgs)
                    // has been invoked. So we will not parent the Render.TransformParent
                    // if it is not ready. That will be done in the 
                    // Cursor.TextureParameterValueBecameReady(object, EventArgs)
                    // method.
                    if (Render.TransformParent != null)
                        Transform.MakeParentChild(Control, Render.TransformParent);

                    // attach together this cursor and the point
                    Transform.MakeParentChild(this, Point);
                }
            }
        }

        /// <summary>
        /// The instance that controls the position of interface elements on
        /// the screen. This will be used by <see cref="Cursor"/> to make sure
        /// it is placed at the top of the screen.
        /// </summary>
        [Inject]
        public Interface.LayerBucket Layers
        {
            set
            {
                if (_layerTransform == null)
                {
                    _layerTransform = new MatrixTransform();
                    _layerTransform.TransformDirtied += LayerTransformDirtied;
                }

                Interface.LayerBucket previousValue = _layers;
                _layers = value;

                if(previousValue != null)
                    Transform.SeperateParentChild(previousValue.TopLayerTransform, _layerTransform);

                if(_layers != null)
                    Transform.MakeParentChild(_layers.TopLayerTransform, _layerTransform);
            }
        }

        /// <summary>
        /// An event that is invoked by the <see cref="ITransform.TransformDirtied"/>
        /// event of the <see cref="_layers"/> instance. This method is used to
        /// ensure this <see cref="ICursor"/> maintains its Z axis position 
        /// closer to the screen.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the event data.</param>
        void LayerTransformDirtied(object sender, EventArgs e)
        {
            float zPosition = _layerTransform.WorldMatrix.Translation.Z;
            Matrix4 local = LocalMatrix;
            local.Row3 = new Vector4(local.Row3.X, local.Row3.Y, zPosition, local.Row3.W);
            SetTransformation(ref local);
        }

        /// <summary>
        /// The default amount to scale the <see cref="CollidableCollection"/> by in
        /// the X and Y axes.
        /// </summary>
        public static readonly Vector2 DefaultCollisionGroupScaleAmount = new Vector2(2, 2);

        /// <summary>
        /// An event handler that is invoked when the <see cref="TextureParameter"/>
        /// instance's <see cref="ITexture"/> has become ready (i.e.,
        /// <see cref="IReadyable.BecameReady"/> is raised). This method
        /// ensures the <see cref="Control"/> is the parent of the 
        /// <see cref="Render"/> instances' <see cref="ITransform.TransformParent"/>.
        /// The <see cref="Render"/> instances' <see cref="ITransform.TransformParent"/>
        /// is not set until <see cref="Sprite.TextureParameterValueBecameReady(object, EventArgs)"/> 
        /// has been called.
        /// </summary>
        /// <param name="sender">The instance that generated the event.</param>
        /// <param name="e">The <see cref="System.EventArgs"/> instance containing
        /// the event data.</param>
        protected override void TextureParameterValueBecameReady(object sender, EventArgs e)
        {
            base.TextureParameterValueBecameReady(sender, e);

            // Make sure we've set the Render's parent.
            if(Render.TransformParent.TransformParent != Control)
                Transform.MakeParentChild(Control, Render.TransformParent);
        }

        /// <summary>
        /// The <see cref="ITransform"/> that drives this <see cref="ICursor"/>.
        /// </summary>
        ITransform Control { get; set; }

        /// <summary>
        /// Collidables that were hit previously and may need to have their
        /// HandleCollisionEnded() method called when they have stopped colliding.
        /// </summary>
        LinkedList<IExtendedCollidable<Point2D>> PreviousCollidables { get; set; }

        /// <summary>
        /// The point of this cursor that can be collided against.
        /// </summary>
        Point2D Point { get; set; }

        /// <summary>
        /// The collidable that implements the collision of this object.
        /// </summary>
        protected override ICollidable2D CollidableImplementer { get { return Point; } }

        /// <summary>
        /// The start of the transform chain of this entity. If there is only 
        /// one transform in the chain, then the TransformStart will equal the
        /// TransformEnd.
        /// </summary>
        protected override ITransform TransformStart { get { return Control; } }

        /// <summary>
        /// The amount to scale the <see cref="CollidableCollection"/> by in the 
        /// both the X and Y axes.
        /// </summary>
        Vector2 _collisionCollectionScaleAmount = DefaultCollisionGroupScaleAmount;

        /// <summary>
        /// The <see cref="Rectangle"/> representing the view area after it has
        /// been scaled by <see cref="_collisionCollectionScaleAmount"/>.
        /// </summary>
        Rectangle _viewArea;

        /// <summary>
        /// The <see cref="IEventCollection{T}"/> instance received by this 
        /// <see cref="Cursor"/> in its constructor.
        /// </summary>
        readonly IEventCollection<object> _services;

        /// <summary>
        /// The instance that is added to the 
        /// <see cref="Interface.LayerBucket.TopLayerTransform"/> of 
        /// <see cref="Layers"/>. This instance controls the Z position of this
        /// <see cref="Cursor"/> and is responsible for ensuring this 
        /// <see cref="Cursor"/> stays at the top of the interface.
        /// </summary>
        ITransform _layerTransform;

        /// <summary>
        /// The backing field to <see cref="BackBufferViewport"/>.
        /// </summary>
        IBackBufferViewport _backBufferViewport;

        /// <summary>
        /// The backing field to <see cref="Layers"/>.
        /// </summary>
        Interface.LayerBucket _layers;
    }
}