using System;
using System.Collections.Generic;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Event;
using Chernobyl.Mathematics.Mechanics;

namespace Chernobyl.Input.Controls.Axis
{
    /// <summary>
    /// A helper class that allows for easy creation of IAxis classes.
    /// </summary>
    public abstract class AxisControl : Control, IAxisControl
    {
        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The services class that contains the 
        /// dependencies that are to be injected into this object.</param>
        protected AxisControl(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="childList">The list to use to hold the children controls.</param>
        protected AxisControl(IEventCollection<object> services, ICollection<IControl> childList)
            : base(childList)
        {
            Sensitivity = 1.0f;
        }

        /// <summary>
        /// The amount the axis was in a certain direction
        /// (the previous value of "CurrentValue").
        /// </summary>
        public float PreviousValue { get; protected set; }

        /// <summary>
        /// The amount the axis is in a certain direction currently.
        /// </summary>
        public float CurrentValue { get; private set; }

        /// <summary>
        /// The amount of change, from the axis' <see cref="PreviousValue"/> to
        /// its <see cref="CurrentValue"/>.
        /// </summary>
        public float ChangeAmount { get; private set; }

        /// <summary>
        /// Invoked when this axis moves.
        /// </summary>
        public event EventHandler<EventArgs<IAxis>> OnMove;

        /// <summary>
        /// Invoked when this axis moves up.
        /// </summary>
        public event EventHandler<EventArgs<IAxis>> OnUp;

        /// <summary>
        /// Invoked when this axis moves down.
        /// </summary>
        public event EventHandler<EventArgs<IAxis>> OnDown;

        /// <summary>
        /// Calculates the new <see cref="CurrentValue"/> and 
        /// <see cref="PreviousValue"/> and raises events if 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)
        {
            // The PreviousValue must be set prior to retrieving the value from
            // OverridableChangeAmount here because a derived class may use
            // PreviousValue to calculate the OverridableChangeAmount (mouse
            // axes may do this for example).
            PreviousValue = CurrentValue;
            ChangeAmount = OverridableChangeAmount * Sensitivity;
            CurrentValue = PreviousValue + ChangeAmount;
            
            // check if the new button state has changed
            if (ChangeAmount != 0.0f)
            {
                // yes it has
                EventArgs<IAxis> e = new EventArgs<IAxis>(this);

                if (ChangeAmount < 0.0f)
                {
                    InvokeOnDown(this, e);
                    InvokeOnMove(this, e);
                }
                else
                {
                    InvokeOnUp(this, e);
                    InvokeOnMove(this, e);
                }
            }

            base.Update(deltaTime);
        }

        /// <summary>
        /// The sensitivity of this axis. A sensitivity of 1 is the default. 
        /// A lower sensitivity (between 0.0 and 1.0) causes this axis to report 
        /// a smaller number for it's current value while a greater sensitivity 
        /// (greater than 1.0) causes the value reported to be greater.
        /// </summary>
        public float Sensitivity { get; set; }

        /// <summary>
        /// The amount of change, from the axis' <see cref="IAxis.PreviousValue"/>
        /// to its <see cref="IAxis.CurrentValue"/>. Implementors should return
        /// the raw change amount and not try to apply 
        /// <see cref="IAxis.Sensitivity"/> to the returned value. The 
        /// <see cref="AxisControl"/> class will apply the 
        /// <see cref="IAxis.Sensitivity"/> value for you.
        /// </summary>
        protected abstract float OverridableChangeAmount { get; }

        /// <summary>
        /// Invokes the OnMove event. This method allows
        /// derived classes to invoke the event which is
        /// not directly allowed.
        /// </summary>
        /// <param name="sender">The invoker of the event.</param>
        /// <param name="e">The events arguments.</param>
        protected void InvokeOnMove(IAxisControl sender, EventArgs<IAxis> e)
        {
            if (OnMove != null)
                OnMove(sender, e);
        }

        /// <summary>
        /// Invokes the OnDown event. This method allows
        /// derived classes to invoke the event which is
        /// not directly allowed.
        /// </summary>
        /// <param name="sender">The invoker of the event.</param>
        /// <param name="e">The events arguments.</param>
        protected void InvokeOnDown(IAxisControl sender, EventArgs<IAxis> e)
        {
            if (OnDown != null)
                OnDown(sender, e);
        }

        /// <summary>
        /// Invokes the OnUp event. This method allows
        /// derived classes to invoke the event which is
        /// not directly allowed.
        /// </summary>
        /// <param name="sender">The invoker of the event.</param>
        /// <param name="e">The events arguments.</param>
        protected void InvokeOnUp(IAxisControl sender, EventArgs<IAxis> e)
        {
            if (OnUp != null)
                OnUp(sender, e);
        }

        /// <summary>
        /// Holds all the action handler delegates that should
        /// be called when the the axis is moved.
        /// </summary>
        Action<IAxisControl> MoveActionHandlers { get; set; }

        /// <summary>
        /// Holds all the action handler delegates that should
        /// be called when the the axis is pressed moved down.
        /// </summary>
        Action<IAxisControl> DownActionHandlers { get; set; }

        /// <summary>
        /// Holds all the action handler delegates that should
        /// be called when the the axis is moved up.
        /// </summary>
        Action<IAxisControl> UpActionHandlers { get; set; }
    }
}