/// <summary>
/// Object to handle timing operations.
/// </summary>
public class Timer : NamedObject 
{
	#region Variables.
	private Stopwatch _timer;			// Actual timer object.
	private long _milliseconds;			// Milliseconds.
	private long _ticks;				// Clock ticks.
	private TimeSpan _span;				// Time span.
	#endregion

	#region Properties.
	/// <summary>
	/// Property to get the number of milliseconds elapsed since the timer was started.
	/// </summary>
	public long Milliseconds
	{
		get
		{
			GetTime();
			return _milliseconds;
		}
	}

	/// <summary>
	/// Property to get the number of microseconds elapsed since the timer was started.
	/// </summary>
	public long Microseconds
	{
		get
		{
			return Milliseconds * 1000;
		}
	}

	/// <summary>
	/// Property to return the number of ticks since the timer was started.
	/// </summary>
	public long Ticks
	{
		get
		{
			GetTime();
			return _ticks;
		}
	}

	/// <summary>
	/// Property to return the time elapsed since the timer was started.
	/// </summary>
	public TimeSpan Elapsed
	{
		get
		{
			GetTime();
			return _span;
		}
	}
	#endregion

	#region Methods.
	/// <summary>
	/// Function to start the timing process.
	/// </summary>
	private void GetTime()
	{
		// Stop the timer and get the timings.
		_timer.Stop();
		_milliseconds  += _timer.ElapsedMilliseconds;
		_ticks += _timer.ElapsedTicks;
		_span += _timer.Elapsed;
		// Reset and start over.
		_timer.Reset();
		_timer.Start();
	}

	/// <summary>
	/// Function to reset the timer.
	/// </summary>
	public void Reset()
	{
		_timer.Stop();
		_timer.Reset();
		_milliseconds = 0;
		_ticks = 0;
		_span = TimeSpan.MinValue;
	}

	/// <summary>
	/// Function to convert the desired frames per second to milliseconds.
	/// </summary>
	/// <param name="FPS">Desired frames per second.</param>
	/// <returns>Frames per second in milliseconds.</returns>
	public static double FPSToMilliseconds(double FPS)
	{
		if (FPS > 0)
			return (1000/(FPS + 3));
		else
			return 0;
	}

	/// <summary>
	/// Function to convert the desired frames per second to microseconds.
	/// </summary>
	/// <param name="FPS">Desired frames per second.</param>
	/// <returns>Frames per second in microseconds.</returns>
	public static double FPSToMicroseconds(double FPS)
	{
		if (FPS > 0)
			return (1000000/(FPS + 3));
		else
			return 0;
	}
	#endregion

	#region Constructors/Destructors.
	/// <summary>
	/// Constructor.
	/// </summary>
	/// <param name="timerName">Name of this timer.</param>
	internal Timer(string timerName) : base(timerName)
	{
		_timer = Stopwatch.StartNew();
		Reset();
	}
	#endregion
}

/// <summary>
/// Object for timing data like FPS, # of frames, etc...
/// </summary>
public class TimingData
{
	#region Variables.
	private double _lastFrameTime;		// Last frame time.
	private double _currentFrameTime;	// Current frame time.
	private double _frameDrawTime;		// Time to draw a frame in milliseconds.
	private double _lastFPSFrameTime;	// Last FPS.
	private double _averageFPS;			// Average FPS.
	private double _highestFPS;			// Highest FPS.
	private double _lowestFPS;			// Lowest FPS.
	private double _currentFPS;			// Current FPS.
	private long _frameCount;			// Frame count.
	private Timer _timer;				// FPS timer.
	#endregion

	#region Properties.
	/// <summary>
	/// Property to return the amount of time to draw a frame in milliseconds.
	/// </summary>
	public double FrameDrawTime
	{
		get
		{
			return _frameDrawTime;
		}
	}

	/// <summary>
	/// Property to return the average Frames Per Second.
	/// </summary>
	public double AverageFPS
	{
		get
		{
			return _averageFPS;
		}
	}

	/// <summary>
	/// Property to return the highest Frames Per Second.
	/// </summary>
	public double HighestFPS
	{
		get
		{
			return _highestFPS;
		}
	}

	/// <summary>
	/// Property to return the lowest Frames Per Second.
	/// </summary>
	public double LowestFPS
	{
		get
		{
			return _lowestFPS;
		}
	}

	/// <summary>
	/// Property to return the current Frames Per Second.
	/// </summary>
	public double CurrentFPS
	{
		get
		{
			return _currentFPS;
		}
	}

	/// <summary>
	/// Property to return the current number of frames drawn.
	/// </summary>
	public long FrameCount
	{
		get
		{
			return _frameCount;
		}
	}
	#endregion

	#region Methods.
	/// <summary>
	/// Function to calculate the frames per second.
	/// </summary>
	private void GetFPS()
	{
		_frameCount++;

		if ((_currentFrameTime - _lastFPSFrameTime) >= 1000)
		{
			_currentFPS = ((double)_frameCount / (_currentFrameTime - _lastFPSFrameTime)) * 1000.0;

			if (_averageFPS == 0.0)
				_averageFPS = _currentFPS;
			else
			{
				_averageFPS = (_averageFPS + _currentFPS) / 2.0;

				if (_currentFPS > _highestFPS)
					_highestFPS = _currentFPS;

				if ((_currentFPS < _lowestFPS) || (_lowestFPS == 0))
					_lowestFPS = _currentFPS;
			}

			_lastFPSFrameTime = _currentFrameTime;
			_frameCount = 0;
		}
	}

	/// <summary>
	/// Function to reset the timing data.
	/// </summary>
	public void Reset()
	{
		_timer.Reset();
		_lastFPSFrameTime = 0.0;
		_averageFPS = 0.0; 
		_highestFPS = 0.0;
		_lowestFPS = 0.0;
		_currentFPS = 0.0;
		_frameCount = 0;
		_lastFrameTime = 0.0;
		_currentFrameTime = 0.0;
		_frameDrawTime = 0.0;
	}

	/// <summary>
	/// Function to end timing routine.
	/// </summary>
	public void Refresh()
	{
		_lastFrameTime = _currentFrameTime;
		_currentFrameTime = _timer.Milliseconds;
		_frameDrawTime = _currentFrameTime - _lastFrameTime;
		GetFPS();
	}
	#endregion

	#region Constructor.
	/// <summary>
	/// Constructor.
	/// </summary>
	internal TimingData()
	{
		_timer = Gorgon.Timers.SystemTimer("@Gorgon_Timer");
		Reset();			
	}
	#endregion
}

/// <summary>/// Object to handle timing operations./// </summary>public class Timer 	: NamedObject {	#region Variables.	private long _startTime;			// Starting timer time.	private bool _useHighResolution;	// Flag to indicate that we're using a high resolution timer.	private long _frequency;			// Frequency of the timer.	private double _milliseconds;		// Milliseconds.	private long _ticks;				// Clock ticks.	private long _lastTicks;			// Last tick count.	private long _startingTick;			// Starting clock tick.	private long _adjustStartTick;		// Adjustment starting tick.	#endregion	#region Properties.	/// <summary>	/// Property to get the number of milliseconds elapsed since the timer was started.	/// </summary>	public double Milliseconds	{		get		{			GetTime();			return _milliseconds;		}	}	/// <summary>	/// Property to get the number of microseconds elapsed since the timer was started.	/// </summary>	public double Microseconds	{		get		{			return Milliseconds * 1000;		}	}	/// <summary>	/// Property to return the number of ticks since the timer was started.	/// </summary>	public long Ticks	{		get		{			GetTime();			return _ticks;		}	}	/// <summary>	/// Property to set or return whether to use the high resolution timer or not.	/// </summary>	public bool HighResolutionTimer	{		get		{			return _useHighResolution;		}		set		{			_useHighResolution = value;			Reset();		}	}	#endregion	#region Methods.	/// <summary>	/// Function to start the timing process.	/// </summary>	private void GetTime()	{		long currentTime = 0;		// Current time.		if (_useHighResolution)		{			Win32API.QueryPerformanceCounter(ref currentTime);			_ticks = currentTime - _startTime;			_milliseconds = ((double)_ticks/(double)_frequency) * 1000;			// The QueryPerformance counter drifts on some motherboards.			// See Microsoft KB: Q274323 for the explanation.			ulong check = (ulong)Environment.TickCount - (ulong)_adjustStartTick;	// Get tick count.			long msDrift = (long)(check - _milliseconds);							// Get any millisecond drifts.			// If we're out by 100 milliseconds either way, then adjust the time.			if ((msDrift < -100) || (msDrift > 100))			{				// Get adjustment amount.				long adjust = Math.Min(msDrift * _frequency / 1000, _ticks - _lastTicks);				_startingTick += adjust;				_ticks -= adjust;				// Recalcuate the timing.				_milliseconds = ((double)_ticks / (double)_frequency) * 1000;			}			_lastTicks = _ticks;		}		else		{			currentTime = Win32API.timeGetTime();			_milliseconds = currentTime - _startTime;			_ticks = Environment.TickCount - _startingTick;		}	}	/// <summary>	/// Function to reset the timer.	/// </summary>	public void Reset()	{		_milliseconds = 0;		_ticks = 0;		_lastTicks = 0;		_adjustStartTick = _startingTick = Environment.TickCount;		// Determine which type of timer to use.		if (_useHighResolution)		{			// If this fails, then drop to the lower precision timer.			if (!Win32API.QueryPerformanceCounter(ref _startTime))			{				_startTime = Win32API.timeGetTime();				_useHighResolution = false;			}		}		else		{			_startTime = Win32API.timeGetTime();			_useHighResolution = false;		}	}	/// <summary>	/// Function to convert the desired frames per second to milliseconds.	/// </summary>	/// <param name="FPS">Desired frames per second.</param>	/// <returns>Frames per second in milliseconds.</returns>	public static double FPSToMilliseconds(double FPS)	{		if (FPS > 0)			return (1000/(FPS + 3));		else			return 0;	}	/// <summary>	/// Function to convert the desired frames per second to microseconds.	/// </summary>	/// <param name="FPS">Desired frames per second.</param>	/// <returns>Frames per second in microseconds.</returns>	public static double FPSToMicroseconds(double FPS)	{		if (FPS > 0)			return (1000000/(FPS + 3));		else			return 0;	}	#endregion	#region Constructors/Destructors.	/// <summary>	/// Constructor.	/// </summary>	/// <param name="timerName">Name of this timer.</param>	internal Timer(string timerName) 		: base(timerName)	{		_startTime = 0;		_frequency = 0;		_useHighResolution = false;		_adjustStartTick = _startingTick = Environment.TickCount;		_lastTicks = 0;		if (Win32API.QueryPerformanceFrequency(ref _frequency))		{			if (Win32API.QueryPerformanceCounter(ref _startTime))				_useHighResolution = true;		}		// Fall back on the low resolution timer if no high resolution one can be found.		if (!_useHighResolution)			_startTime = Win32API.timeGetTime();					}	#endregion}