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.Values;

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

        /// <summary>
        /// Initializes a new instance of the <see cref="Axis3DControl"/> class.
        /// </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 Axis3DControl(IEventCollection<object> services, ICollection<IControl> controlChildren)
            : base(services, controlChildren)
        { }

        /// <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 override void Update(TimeSpan deltaTime)
        {
            if (X.CurrentValue != X.PreviousValue ||
                Y.CurrentValue != Y.PreviousValue ||
                Z.CurrentValue != Z.PreviousValue)
            {
                IsUpdateNeeded = true;

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

            base.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(X.CurrentValue, Y.CurrentValue,
                                     Z.CurrentValue, local.Row3.W);
            SetTransformation(ref local);
        }

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

        /// <summary>
        /// The (X, Y, Z) position of the mechanism.
        /// </summary>
        public Vector3 Xyz
        {
            get { return new Vector3(X.CurrentValue, Y.CurrentValue, Z.CurrentValue); }
        }

        /// <summary>
        /// Invoked when this control moves in either the X, Y, Z or all three
        /// directions.
        /// </summary>
        public new event EventHandler<EventArgs<IAxis3D>> OnMove;

        /// <summary>
        /// The Z axis of the 3 dimensions of this mechanism.
        /// </summary>
        IAxis IAxis3D.Z
        {
            get { return Z; }
        }
    }
}