using System;
using System.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Mathematics;
using Chernobyl.Mathematics.Mechanics;
using Chernobyl.Mathematics.Movement;
using Chernobyl.Mathematics.Vectors;
using Chernobyl.Update;
using Chernobyl.Values;

namespace Chernobyl.Input.Controls.Axis
{
    /// <summary>
    /// A helper class that allows for easy creation of 
    /// <see cref="Axis2DControl"/> classes.
    /// </summary>
    public class Axis2DControl : MatrixTransform, IAxis2DControl
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services class that contains the 
        /// dependencies that are to be injected into this object.</param>
        public Axis2DControl(IEventCollection<object> services)
            : this(services, new List<IControl>())
        { }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services class that contains the 
        /// dependencies that are to be injected into this object.</param>
        /// <param name="controlChildren">The list to use to hold the children 
        /// controls.</param>
        public Axis2DControl(IEventCollection<object> services, ICollection<IControl> controlChildren)
        {
            ControlChildren = controlChildren;
            UpdateableChildren = new List<IUpdateable>();
        }

        /// <summary>
        /// The X axis of the 2 dimensions of this control.
        /// </summary>
        public virtual IAxisControl X { get; protected set; }

        /// <summary>
        /// The Y axis of the 2 dimensions of this control.
        /// </summary>
        public virtual IAxisControl Y { get; protected set; }

        /// <summary>
        /// The (X, Y) position of the IAxis2D.
        /// </summary>
        public Vector2 Xy { get { return new Vector2(X.CurrentValue, Y.CurrentValue); } }

        /// <summary>
        /// Invoked when this control moves in either the
        /// X, Y, or both directions.
        /// </summary>
        public event EventHandler<EventArgs<IAxis2D>> OnMove;

        /// <summary>
        /// Updates this IUpdateable object and it's children
        /// if the updateable feels it's necessary.
        /// </summary>
        /// <param name="deltaTime">The amount of time that has
        /// passed since this update was last called.</param>
        public virtual void Update(TimeSpan deltaTime)
        {
            if (X.CurrentValue != X.PreviousValue || Y.CurrentValue != Y.PreviousValue)
            {
                IsUpdateNeeded = true;

                if (OnMove != null)
                    OnMove(this, new EventArgs<IAxis2D>(this));
            }

            foreach (IUpdateable child in UpdateableChildren)
                child.Update(deltaTime);
        }

        /// <summary>
        /// This method is invoked during the update of the
        /// <see cref="ITransform.WorldMatrix"/> right before the
        /// <see cref="ITransform.WorldMatrix"/> is actually updated. This
        /// method keeps the position of this instance up to date.
        /// </summary>
        /// <param name="world">The value of the <see cref="ITransform.WorldMatrix"/>.
        /// It is stored in a <see cref="LazyValue{T}"/> so that the calculation can be
        /// avoided if necessary. Don't call <see cref="LazyValue{T}.Value"/> unless
        /// required.</param>
        protected override void PreUpdate(Values.LazyValue<Matrix4> world)
        {
            base.PreUpdate(world);

            Matrix4 local = LocalMatrix;
            local.Row3 = new Vector4(Xy.X, Xy.Y, local.Row3.Z, local.Row3.W);
            SetTransformation(ref local);
        }

        /// <summary>
        /// The parent of this control.
        /// </summary>
        public IControl ControlParent { get; set; }

        /// <summary>
        /// The children of this control
        /// </summary>
        public ICollection<IControl> ControlChildren { get; protected set; }

        /// <summary>
        /// An event that is raised when this <see cref="IControl"/> is
        /// disconnected from the device it was previously connected to and is
        /// no longer available for use. Actions performed on the 
        /// <see cref="IControl"/> after it has been disconnected may result
        /// is an <see cref="DisconnectedException"/> being thrown.
        /// </summary>
        public event EventHandler Disconnected
        {
            add { DisconnectedMethod += value; }
            remove { DisconnectedMethod -= value; }
        }

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

        /// <summary>
        /// Holds a collection of children that should be updated when this 
        /// <see cref="IUpdateable"/> decides they should be updated.
        /// </summary>
        public ICollection<IUpdateable> UpdateableChildren { get; private set; }

        /// <summary>
        /// The method that acts as the backing property to 
        /// <see cref="Disconnected"/>. Use this method if you wish to raise the
        /// <see cref="Disconnected"/> event.
        /// </summary>
        protected EventHandler DisconnectedMethod { get; private set; }

        /// <summary>
        /// The X axis of the 2 dimensions of this mechanism.
        /// </summary>
        IAxis IAxis2D.X { get { return X; } }

        /// <summary>
        /// The Y axis of the 2 dimensions of this mechanism.
        /// </summary>
        IAxis IAxis2D.Y { get { return Y; } }
    }
}