using System;
using System.Runtime.InteropServices;
using System.ComponentModel;
using System.Threading;

namespace lib
{

    public class MicroStopwatch : System.Diagnostics.Stopwatch
    {
        readonly double _microSecPerTick
            = 1000000D / System.Diagnostics.Stopwatch.Frequency;

        public MicroStopwatch()
        {
            if (!System.Diagnostics.Stopwatch.IsHighResolution)
            {
                throw new Exception("On this system the high-resolution " +
                                    "performance counter is not available");
            }
        }

        public long ElapsedMicroseconds
        {
            get
            {
                return (long)(ElapsedTicks * _microSecPerTick);
            }
        }
    }

    /// <summary>
    /// MicroTimer class
    /// </summary>
    public class MicroTimer
    {
        public delegate void MicroTimerElapsedEventHandler(
                             object sender,
                             MicroTimerEventArgs timerEventArgs);
        public event MicroTimerElapsedEventHandler MicroTimerElapsed;

        System.Threading.Thread _threadTimer = null;
        long _ignoreEventIfLateBy = long.MaxValue;
        long _timerIntervalInMicroSec = 0;
        bool _stopTimer = true;

        public MicroTimer()
        {
        }

        public MicroTimer(long timerIntervalInMicroseconds)
        {
            Interval = timerIntervalInMicroseconds;
        }

        public long Interval
        {
            get
            {
                return System.Threading.Interlocked.Read(
                    ref _timerIntervalInMicroSec);
            }
            set
            {
                System.Threading.Interlocked.Exchange(
                    ref _timerIntervalInMicroSec, value);
            }
        }

        public long IgnoreEventIfLateBy
        {
            get
            {
                return System.Threading.Interlocked.Read(
                    ref _ignoreEventIfLateBy);
            }
            set
            {
                System.Threading.Interlocked.Exchange(
                    ref _ignoreEventIfLateBy, value <= 0 ? long.MaxValue : value);
            }
        }

        public bool Enabled
        {
            set
            {
                if (value)
                {
                    Start();
                }
                else
                {
                    Stop();
                }
            }
            get
            {
                return (_threadTimer != null && _threadTimer.IsAlive);
            }
        }

        public void Start()
        {
            if (Enabled || Interval <= 0)
            {
                return;
            }

            _stopTimer = false;

            System.Threading.ThreadStart threadStart = delegate()
            {
                NotificationTimer(ref _timerIntervalInMicroSec,
                                  ref _ignoreEventIfLateBy,
                                  ref _stopTimer);
            };

            _threadTimer = new System.Threading.Thread(threadStart);
            _threadTimer.Priority = System.Threading.ThreadPriority.Highest;
            _threadTimer.Start();
        }

        public void Stop()
        {
            _stopTimer = true;

            if (_threadTimer != null && _threadTimer.ManagedThreadId ==
                System.Threading.Thread.CurrentThread.ManagedThreadId)
            {
                return;
            }

            while (Enabled)
            {
                System.Threading.Thread.SpinWait(10);
            }
        }

        void NotificationTimer(ref long timerIntervalInMicroSec,
                               ref long ignoreEventIfLateBy,
                               ref bool stopTimer)
        {
            int  timerCount = 0;
            long nextNotification = 0;

            MicroStopwatch microStopwatch = new MicroStopwatch();
            microStopwatch.Start();

            while (!stopTimer)
            {
                long callbackFunctionExecutionTime =
                    microStopwatch.ElapsedMicroseconds - nextNotification;

                long timerIntervalInMicroSecCurrent =
                    System.Threading.Interlocked.Read(ref timerIntervalInMicroSec);
                long ignoreEventIfLateByCurrent =
                    System.Threading.Interlocked.Read(ref ignoreEventIfLateBy);

                nextNotification += timerIntervalInMicroSecCurrent;
                timerCount++;
                long elapsedMicroseconds = 0;

                while ( (elapsedMicroseconds = microStopwatch.ElapsedMicroseconds)
                        < nextNotification)
                {
                    System.Threading.Thread.SpinWait(10);
                }

                long timerLateBy = elapsedMicroseconds - nextNotification;

                if (timerLateBy >= ignoreEventIfLateByCurrent)
                {
                    continue;
                }

                MicroTimerEventArgs microTimerEventArgs =
                     new MicroTimerEventArgs(timerCount,
                                             elapsedMicroseconds,
                                             timerLateBy,
                                             callbackFunctionExecutionTime);
                MicroTimerElapsed(this, microTimerEventArgs);
            }

            microStopwatch.Stop();
        }
    }

    /// <summary>
    /// MicroTimer Event Argument class
    /// </summary>
    public class MicroTimerEventArgs : EventArgs
    {
        // Simple counter, number times timed event (callback function) executed
        public int  TimerCount { get; private set; }

        // Time when timed event was called since timer started
        public long ElapsedMicroseconds { get; private set; }

        // How late the timer was compared to when it should have been called
        public long TimerLateBy { get; private set; }

        // Time it took to execute previous call to callback function (OnTimedEvent)
        public long CallbackFunctionExecutionTime { get; private set; }

        public MicroTimerEventArgs(int  timerCount,
                                   long elapsedMicroseconds,
                                   long timerLateBy,
                                   long callbackFunctionExecutionTime)
        {
            TimerCount = timerCount;
            ElapsedMicroseconds = elapsedMicroseconds;
            TimerLateBy = timerLateBy;
            CallbackFunctionExecutionTime = callbackFunctionExecutionTime;
        }
    }


		public class Timer
		{
			MicroStopwatch m_watch;
			private long startTime;
			private long stopTime;
			private long freq;
			private long freq_millis;

			public Timer()
			{
				m_watch = new MicroStopwatch();
				//startTime = m_watch.ElapsedMicroseconds;
				//stopTime  = m_watch.ElapsedMicroseconds;
				freq = 1000 * 1000;
				freq_millis = freq / 1000;

				Start();
			}

			// Start the timer

			public Timer Start()
			{
				m_watch.Start();
				startTime = m_watch.ElapsedMicroseconds;
				stopTime  = m_watch.ElapsedMicroseconds;
				return this;
			}

			// Stop the timer

			public Timer Stop()
			{
				m_watch.Stop();
				stopTime  = m_watch.ElapsedMicroseconds;
				return this;
			}

		public double Seconds
			{
				get
				{
					long current = m_watch.ElapsedMicroseconds;
					return (double)( current - startTime ) / freq;
				}
			}

			public long Current
			{
				get
				{
					long current = m_watch.ElapsedMicroseconds;
					return ( current - startTime ) / freq_millis;
				}
			}

			public double Duration
			{
				get
				{
					return (double)( stopTime - startTime ) / (double)freq;
				}
			}

			public long DurationMS
			{
				get { return ( stopTime - startTime ) / freq_millis; }
			}
		}


	public class TimerWin
	{
        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceCounter(
            out long lpPerformanceCount);

        [DllImport("Kernel32.dll")]
        private static extern bool QueryPerformanceFrequency(
            out long lpFrequency);

        private long startTime;
				private long stopTime;
				private long freq;
				private long freq_millis;

        // Constructor

				public TimerWin()
				{
					startTime = 0;
					stopTime  = 0;

					if (QueryPerformanceFrequency(out freq) == false)
					{
						// high-performance counter not supported
						throw new Win32Exception();
					}

					freq_millis = freq / 1000;

				}

        // Start the timer

        public void Start()
        {
            // lets do the waiting threads there work

            //Thread.Sleep(0);

            QueryPerformanceCounter(out startTime);
        }

        // Stop the timer

        public void Stop()
        {
            QueryPerformanceCounter(out stopTime);
        }

		public double Seconds
		{
			get
			{
				long current;

				QueryPerformanceCounter( out current );

				return (double)( current - startTime ) / freq;
			}
		}

		public long Current
		{
			get
			{
				long current;

				QueryPerformanceCounter( out current );

				return ( current - startTime ) / freq_millis;
			}
		}

		public double Duration
		{
			get
			{
				return (double)( stopTime - startTime ) / (double)freq;
			}
		}
		
		public long DurationMS
		{
			get { return (stopTime - startTime) / freq_millis; }
		}
	}
}