using System;
using System.Windows.Forms;

// Beispielaufruf:
//
//   new DelayedCall(new DelayedCall.Function(EineFunktion), 500);
//
// In .NET 2.0 funktioniert auch das:
//
//   new DelayedCall(EineFunktion, 500);
//
// Funktion mit einem Parameter (muss vom Typ object sein):
//
//   new DelayedCall(FunktionMitParameter, 500, argument1);

namespace Unclassified
{
	public class DelayedCall
	{
		public delegate void Function();
		public delegate void Function1(object data1);
		public event Function myEvent = null;
		public event Function1 myEvent1 = null;
		private Timer timer;
		private object _data1;
		private ushort paramCount = 0;

		/// <summary>
		/// Ruft eine Funktion einmalig zu einem späteren Zeitpunkt auf
		/// </summary>
		/// <param name="function">Aufzurufende Funktion</param>
		public DelayedCall(Function function)
		{
			myEvent = function;
			paramCount = 0;

			timer = new Timer();
			timer.Tick += new EventHandler(this.Event);
		}

		/// <summary>
		/// Ruft eine Funktion einmalig zu einem späteren Zeitpunkt auf
		/// </summary>
		/// <param name="function">Aufzurufende Funktion</param>
		/// <param name="delay">Verzögerung in Millisekunden</param>
		public DelayedCall(Function function, int delay)
		{
			myEvent = function;
			paramCount = 0;

			timer = new Timer();
			timer.Tick += new EventHandler(this.Event);
			if (delay > 0)
			{
				timer.Interval = delay;
				timer.Start();
			}
		}

		/// <summary>
		/// Ruft eine Funktion einmalig zu einem späteren Zeitpunkt auf
		/// </summary>
		/// <param name="function">Aufzurufende Funktion</param>
		/// <param name="data">Der Parameter der Funktion</param>
		public DelayedCall(Function1 function, object data)
		{
			myEvent1 = function;
			paramCount = 1;
			_data1 = data;

			timer = new Timer();
			timer.Tick += new EventHandler(this.Event1);
		}

		/// <summary>
		/// Ruft eine Funktion einmalig zu einem späteren Zeitpunkt auf
		/// </summary>
		/// <param name="function">Aufzurufende Funktion</param>
		/// <param name="delay">Verzögerung in Millisekunden</param>
		/// <param name="data">Der Parameter der Funktion</param>
		public DelayedCall(Function1 function, int delay, object data)
		{
			myEvent1 = function;
			paramCount = 1;
			_data1 = data;

			timer = new Timer();
			timer.Tick += new EventHandler(this.Event1);
			if (delay > 0)
			{
				timer.Interval = delay;
				timer.Start();
			}
		}

		/// <summary>
		/// Ermittelt, ob der Timer noch läuft.
		/// </summary>
		public bool IsWaiting
		{
			get
			{
				return timer.Enabled;
			}
		}

		/// <summary>
		/// Bricht den DelayedCall ab.
		/// </summary>
		public void Cancel()
		{
			timer.Stop();
		}

		/// <summary>
		/// Bricht den Timer ab und führt den DelayedCall sofort aus.
		/// </summary>
		public void Fire()
		{
			if (paramCount == 0)
				Event(null, null);
			else if (paramCount == 1)
				Event1(null, null);
		}

		/// <summary>
		/// Startet den Timer erneut.
		/// </summary>
		public void Reset()
		{
			timer.Stop();
			timer.Start();
		}

		/// <summary>
		/// Startet den Timer erneut mit einem neuen Zeitwert.
		/// </summary>
		/// <param name="delay">Verzögerung in Millisekunden</param>
		public void Reset(int delay)
		{
			timer.Stop();
			if (delay > 0)
			{
				timer.Interval = delay;
				timer.Start();
			}
		}

		/// <summary>
		/// Startet den Timer erneut mit einem neuen Parameter.
		/// </summary>
		public void Reset(object data)
		{
			timer.Stop();
			_data1 = data;
			timer.Start();
		}

		/// <summary>
		/// Startet den Timer erneut mit einem neuen Zeitwert und einem neuen Parameter.
		/// </summary>
		public void Reset(int delay, object data)
		{
			timer.Stop();
			_data1 = data;
			if (delay > 0)
			{
				timer.Interval = delay;
				timer.Start();
			}
		}

		/// <summary>
		/// Setzt einen neuen Zeitwert, ohne den Timer zu starten.
		/// </summary>
		public void SetTimeout(int delay)
		{
			timer.Interval = delay;
		}

		private void Event(object o, System.EventArgs e)
		{
			// If the timer was already stopped a very short time ago (but the WM_TIMER was
			// still in the window's message queue), don't fire the event. We can definitely
			// check this here.
			if (!timer.Enabled) return;

			timer.Stop();
			// TODO: Test what happens if this call throws an exception - is it passed on or dropped?
			//try
			//{
				myEvent();
			//}
			//catch (Exception ex)
			//{
			//	MessageBox.Show(ex.ToString(), "DelayedCall Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
			//}
		}

		private void Event1(object o, System.EventArgs e)
		{
			// If the timer was already stopped a very short time ago (but the WM_TIMER was
			// still in the window's message queue), don't fire the event. We can definitely
			// check this here.
			if (!timer.Enabled) return;
			
			timer.Stop();
			//try
			//{
				myEvent1(_data1);
			//}
			//catch (Exception ex)
			//{
			//	MessageBox.Show(ex.ToString(), "DelayedCall Exception", MessageBoxButtons.OK, MessageBoxIcon.Error);
			//}
		}
	}
}