using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace CarFire
{
    /// <summary>
    /// A simple timer class.  I'm not sure why .NET or at least
    /// XNA doesn't already have one of these.
    /// </summary>
    public class Timer<T> : IComparable<Timer<T>> where T : IComparable<T>
    {
        #region Public Properties

        /// <summary>
        /// Get and set the expiration time.  If the time is already set
        /// and the timer is registered, you cannot push the expiration time
        /// further back, but you can decrease it.
        /// </summary>
        public T Time
        {
            get
            {
                return mTime;
            }
            set
            {
                if (mTime.CompareTo(value) > 0)
                {
                    mTime = value;
                    gTimers.Promote(this);
                }
            }
        }

        /// <summary>
        /// Get the current absolute time, accurate up until
        /// the last time Timer.FireAll was called.
        /// </summary>
        public static T Now { get { return gNow; } }

        /// <summary>
        /// Get and set the events that will be called when the
        /// timer expires.
        /// </summary>
        public event ExpiredEventHandler Expired;

        /// <summary>
        /// Get and set a user contextual object.
        /// </summary>
        public object Context;

        #endregion


        #region Public Types

        /// <summary>
        /// The type for an event handler for timers that expire.
        /// </summary>
        /// <param name="timer">The timer that expired.</param>
        public delegate void ExpiredEventHandler(Timer<T> timer);

        #endregion


        #region Public Methods

        /// <summary>
        /// Construct a timer with an absolute time (in seconds)
        /// when the timer should expire.
        /// </summary>
        /// <param name="time">Absolute time, in seconds.</param>
        public Timer(T time)
        {
            mTime = time;
            gTimers.Add(this);
        }

        /// <summary>
        /// Construct a timer with an absolute time (in seconds)
        /// when the timer should expire, and an event handler.
        /// </summary>
        /// <param name="time">Absolute time, in seconds.</param>
        /// <param name="expired">An event handler.</param>
        public Timer(T time, ExpiredEventHandler expired)
        {
            mTime = time;
            Expired += expired;
            gTimers.Add(this);
        }

        /// <summary>
        /// Construct a timer with an absolute time (in seconds)
        /// when the timer should expire, and a contextual object.
        /// </summary>
        /// <param name="time">Absolute time, in seconds.</param>
        /// <param name="context">A user contextual object.</param>
        public Timer(T time, object context)
        {
            mTime = time;
            Context = context;
            gTimers.Add(this);
        }

        /// <summary>
        /// Construct a timer with an absolute time (in seconds)
        /// when the timer should expire, an event handler, and a
        /// contextual object.
        /// </summary>
        /// <param name="time">Absolute time, in seconds.</param>
        /// <param name="expired">An event handler.</param>
        /// <param name="context">A user contextual object.</param>
        public Timer(T time, ExpiredEventHandler expired, object context)
        {
            mTime = time;
            Expired += expired;
            Context = context;
            gTimers.Add(this);
        }


        /// <summary>
        /// Fire all outstanding timers which should be expired
        /// before a certain time.
        /// </summary>
        /// <param name="time">Absolute time, in seconds.</param>
        public static void FireExpired(T time)
        {
            gNow = time;

            while (gTimers.Count > 0)
            {
                Timer<T> timer = gTimers.Peek();
                if (timer.Time.CompareTo(Now) <= 0)
                {
                    if (timer.Expired != null) timer.Expired(timer);
                    if (timer.Time.CompareTo(Now) <= 0) gTimers.GetNext();
                }
                else
                {
                    break;
                }
            }
        }


        /// <summary>
        /// Unregister all registered timers without firing any events.
        /// </summary>
        public static void Clear()
        {
            gTimers.Clear();
        }


        /// <summary>
        /// Compare a timer with another, based on the expiration
        /// times of both timers.
        /// </summary>
        /// <param name="other">The timer to compare against.</param>
        /// <returns>A negative value if this timer is less than the
        /// other, a positive value if this timer is greater than the
        /// other, or zero if they are the same.</returns>
        public int CompareTo(Timer<T> other)
        {
            return Time.CompareTo(other.Time);
        }

        #endregion


        #region Private Variables

        T mTime;

        static IPriorityQueue<Timer<T>> gTimers = new BinaryHeap<Timer<T>>(10);
        static T gNow;

        #endregion
    }
}