using System;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Measures.Time;
using Chernobyl.Update;
using Chernobyl.Utility;

namespace Chernobyl.StateMachine
{
    /// <summary>
    /// An <see cref="IState"/> that performs the following:
    /// <list type="bullet">
    ///     <item>
    ///         <description>When the <see cref="Countdown"/> <see cref="IState"/>
    ///         is entered (i.e. <see cref="IState.Entered"/> is raised) the
    ///         <see cref="Countdown"/> instance will start a countdown (the
    ///         count of which is specified by the user).</description>
    ///     </item>
    ///     <item>
    ///         <description>When the countdown reaches 0, the <see cref="Countdown"/>
    ///         instance will set the <see cref="Next"/> instance onto the
    ///         <see cref="IState.ChildState"/> of its <see cref="IState.ParentState"/>.
    ///         This will, of course, cause the <see cref="Countdown"/> to become
    ///         an inactive <see cref="IState"/> (i.e. <see cref="IState.Left"/> 
    ///         will be raised).</description>
    ///     </item>
    ///     <item>
    ///         <description>If the <see cref="Countdown"/> instance becomes
    ///         an inactive <see cref="IState"/> before the countdown has
    ///         reached 0, the countdown will be paused and <see cref="Next"/>
    ///         will not become the active state. The countdown can be reactivated 
    ///         and returned to its previous count by activating the 
    ///         <see cref="Countdown"/> again.</description>
    ///     </item>
    /// </list>
    /// </summary>
    public class Countdown : UpdateableState
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="Countdown" /> class.
        /// </summary>
        /// <param name="services">The instance that takes services and gives
        /// them out.</param>
        /// <param name="next">The instance that is to become the active state
        /// (i.e. set on the <see cref="IState.ChildState" /> property) of this
        /// <see cref="Countdown" />) after the countdown timer has reached 0 or
        /// null if null is to be set on the <see cref="IState.ChildState"/>
        /// property.</param>
        /// <param name="count">The amount of time, in milliseconds, between this 
        /// <see cref="IState"/> becoming active and the <paramref name="next"/> 
        /// <see cref="IState"/> becoming active.</param>
        /// <exception cref="ArgumentNullException">Thrown if
        /// <paramref name="services"/> is null.</exception>
        /// <exception cref="ArgumentOutOfRangeException">Thrown if
        /// <paramref name="count"/> is less than or equal to zero.</exception>
        public Countdown(IEventCollection<object> services, IState next, Milliseconds count)
        {
            services.ThrowIfNull("services");

            Next = next;
            CurrentCount = Count = count;

            Entered += OnEntered;
            Left += OnLeft;

            services.Inject(this);
        }

        /// <summary>
        /// The instance that is to become the active state (i.e. set on the
        /// <see cref="IState.ChildState" /> property of this <see cref="Countdown" />)
        /// after the countdown timer has reached 0 or null if null is to be set
        /// on the <see cref="IState.ChildState"/> property.
        /// </summary>
        public IState Next { get; set; }

        /// <summary>
        /// The amount of time, in milliseconds, between this <see cref="IState" />
        /// becoming active and the <see cref="Next" /> <see cref="IState" />
        /// becoming active.
        /// </summary>=
        /// <exception cref="ArgumentOutOfRangeException">Thrown if the value set 
        /// on this property is less than or equal to zero.</exception>
        public Milliseconds Count
        {
            get { return _count; }
            set
            {
                if(value <= 0)
                    throw new ArgumentOutOfRangeException("value", value,
                        "The countdown amount cannot be less than or equal to " +
                        "zero. Please provide a value greater than zero.");

                _count = value;
            }
        }

        /// <summary>
        /// The current amount of time, in milliseconds, before this instance 
        /// becomes inactive and makes <see cref="Next"/> the active state.
        /// </summary>
        public Milliseconds CurrentCount { get; private set; }

        /// <summary>
        /// Checks the current countdown and updates this instance's children 
        /// <see cref="IUpdateable"/> instances.
        /// </summary>
        /// <param name="deltaTime">The amount of time that has
        /// passed since the last call to this update.</param>
        public override void Update(TimeSpan deltaTime)
        {
            CurrentCount -= (Milliseconds)deltaTime.Milliseconds;
            
            if(CurrentCount <= 0)
            {
                // Don't let the CurrentCount go below 0 (because it wouldn't
                // make much sense) and make the next state active (deactivating
                // this state in the process).
                CurrentCount = (Milliseconds)0;
                ParentState.ChildState = Next;
            }

            base.Update(deltaTime);
        }

        /// <summary>
        /// The instance that is to be used to time this <see cref="Countdown"/>
        /// instance.
        /// </summary>
        [Inject(Type = typeof(IRootUpdateable))]
        public IUpdateable Updateable
        {
            get { return _updateable; }
            set
            {
                value.ThrowIfNull("value");

                IUpdateable previousValue = _updateable;
                _updateable = value;

                if (previousValue != null)
                    Chernobyl.Update.Updateable.SeparateParentChild(previousValue, this);

                // Only request updates if this IState is active.
                if (this.IsActive())
                    Chernobyl.Update.Updateable.MakeParentChild(Updateable, this);
            }
        }

        /// <summary>
        /// An event handler that is invoked when this instance becomes an active
        /// state. This method ensures the <see cref="CurrentCount"/> is, if
        /// below or equal to zero, set to <see cref="Count"/> and makes sure
        /// this instance is added to <see cref="Updateable"/> (if available) so
        /// that it can be updated.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the 
        /// event data.</param>
        void OnEntered(object sender, EventArgs e)
        {
            if (CurrentCount <= 0)
                CurrentCount = Count;

            // Updates are now needed so that the countdown can proceed.
            if(Updateable != null)
                Chernobyl.Update.Updateable.MakeParentChild(Updateable, this);
        }

        /// <summary>
        /// An event handler that is invoked when this instance becomes an
        /// inactive state. This method ensures this instance is removed from
        /// <see cref="Updateable"/> (if available) so that it will not be
        /// updated.
        /// </summary>
        /// <param name="sender">The sender of the event.</param>
        /// <param name="e">The <see cref="EventArgs"/> instance containing the 
        /// event data.</param>
        void OnLeft(object sender, EventArgs e)
        {
            // Updates are no longer needed. We'll wait for this state to
            // become active again before re-enabling updates.
            if (Updateable != null)
                Chernobyl.Update.Updateable.SeparateParentChild(Updateable, this);
        }

        /// <summary>
        /// The backing field to <see cref="Count"/>.
        /// </summary>
        Milliseconds _count;

        /// <summary>
        /// The backing field to <see cref="Updateable"/>.
        /// </summary>
        IUpdateable _updateable;
    }
}