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

namespace Chernobyl.Input.Controls
{
    /// <summary>
    /// Makes creating new IButton classes easier by implementing
    /// some of the properties and methods and making allowing for
    /// the button to be (de)serialized to/from an XML file. Do NOT
    /// work with the class "ButtonControl" (like use it as a method parameter) 
    /// because not every button will derive from "ButtonControl". Instead, 
    /// work with "IButton".
    /// </summary>
    public abstract class ButtonControl : Control, IButtonControl
    {

        /// <summary>
        /// Initializes a new instance of the <see cref="ButtonControl"/> class.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        protected ButtonControl(IEventCollection<object> services)
            : this(services, new List<IControl>())
        {
        }

        /// <summary>
        /// Constructor.
        /// </summary>
        /// <param name="services">The instance that gives out services for use 
        /// by this type and takes services from this type for use by other systems.</param>
        /// <param name="childList">The list to use to hold the children controls.</param>
        protected ButtonControl(IEventCollection<object> services, ICollection<IControl> childList)
            : base(childList)
        {
        }

        /// <summary>
        /// Checks to see if a buttons state has been changed and fires the
        /// necessary events if so. Also calls update on the children buttons.
        /// </summary>
        /// <param name="deltaTime">The amount of time that has passed 
        /// since the last call to update.</param>
        public override void Update(TimeSpan deltaTime)
        {
            // update the previous state
            bool previousState = WasDown;
            WasDown = IsDown;

            // check if the new button state has changed
            if (IsDown != previousState)
            {
                // yes it has
                EventArgs<IButton> e = new EventArgs<IButton>(this);

                if (OnChangeMethod != null)
                    OnChangeMethod(this, EventArgs.Empty);

                if (IsDown == true && OnDownMethod != null)
                    OnDownMethod(this, EventArgs.Empty);
                else if (OnUpMethod != null)
                    OnUpMethod(this, e);
            }

            base.Update(deltaTime);
        }

        /// <summary>
        /// True if the button was down, false
        /// if otherwise (set to the previous 
        /// value of "IsDown").
        /// </summary>
        public virtual bool WasDown { get; protected set; }

        /// <summary>
        /// True if the button is down, false
        /// if otherwise.
        /// </summary>
        public abstract bool IsDown { get; protected set; }

        /// <summary>
        /// An event that is raised when this button 
        /// is pushed down or turned on.
        /// </summary>
        public virtual event EventHandler OnDown
        {
            add { OnDownMethod += value; }
            remove { OnDownMethod -= value; }
        }

        /// <summary>
        /// An event that is raised when this button
        /// has stopped being pushed down or is off.
        /// </summary>
        public virtual event EventHandler OnUp
        {
            add { OnUpMethod += value; }
            remove { OnUpMethod -= value; }
        }

        /// <summary>
        /// An event that is raised when this button's
        /// state has changed.
        /// </summary>
        public virtual event EventHandler OnChange
        {
            add { OnChangeMethod += value; }
            remove { OnChangeMethod -= value; }
        }

        /// <summary>
        /// Allows derived classes access to the <see cref="OnDown"/> event.
        /// </summary>
        protected EventHandler OnDownMethod { get; set; }

        /// <summary>
        /// Allows derived classes access to the <see cref="OnUp"/> event.
        /// </summary>
        protected EventHandler OnUpMethod { get; set; }

        /// <summary>
        /// Allows derived classes access to the <see cref="OnChange"/> event.
        /// </summary>
        protected EventHandler OnChangeMethod { get; set; }
    }
}