// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
// Copyright (c) 2004-2006 Novell, Inc.
//
// Authors:
//  Jackson Harper (jackson@ximian.com)
//  Peter Dennis Bartok (pbartok@novell.com)
//  Chris Toshok (toshok@ximian.com)
//

using System;
using System.Threading;
using System.Collections;

namespace System.Windows.Forms.X11Internal {

	internal class X11ThreadQueue {

		XEventQueue xqueue;
		PaintQueue paint_queue;
		ConfigureQueue configure_queue;
		ArrayList timer_list;
		Thread thread;
		bool quit_posted;
		bool dispatch_idle;
		bool need_dispatch_idle = true;
		object lockobj = new object ();

		static readonly int InitialXEventQueueSize = 128;
		static readonly int InitialHwndQueueSize = 50;

		public X11ThreadQueue (Thread thread)
		{
			xqueue = new XEventQueue (InitialXEventQueueSize);
			paint_queue = new PaintQueue (InitialHwndQueueSize);
			configure_queue = new ConfigureQueue (InitialHwndQueueSize);
			timer_list = new ArrayList ();
			this.thread = thread;
			this.quit_posted = false;
			this.dispatch_idle = true;
		}

		public int CountUnlocked {
			get { return xqueue.Count + paint_queue.Count; }
		}

		public Thread Thread {
			get { return thread; }
		}

		public void EnqueueUnlocked (XEvent xevent)
		{
			switch (xevent.type) {
			case XEventName.KeyPress:
			case XEventName.KeyRelease:
			case XEventName.ButtonPress:
			case XEventName.ButtonRelease:
				NeedDispatchIdle = true;
				break;
			case XEventName.MotionNotify:
				if (xqueue.Count > 0) {
					XEvent peek = xqueue.Peek ();
					if (peek.AnyEvent.type == XEventName.MotionNotify)
						return; // we've already got a pending motion notify.
				}

				// otherwise fall through and enqueue
				// the event.
				break;
			}

			xqueue.Enqueue (xevent);
			// wake up any thread blocking in DequeueUnlocked
			Monitor.PulseAll (lockobj);
		}

		public void Enqueue (XEvent xevent)
		{
			lock (lockobj) {
				EnqueueUnlocked (xevent);
			}
		}

		public bool Dequeue (out XEvent xevent)
		{
		StartOver:
			bool got_xevent = false;

			lock (lockobj) {
				if (xqueue.Count > 0) {
					got_xevent = true;
					xevent = xqueue.Dequeue ();
				}
				else
					xevent = new XEvent (); /* not strictly needed, but mcs complains */
			}

			if (got_xevent) {
				if (xevent.AnyEvent.type == XEventName.Expose) {
#if spew
					Console.Write ("E");
					Console.Out.Flush ();
#endif
					X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window);
					hwnd.AddExpose (xevent.AnyEvent.window == hwnd.ClientWindow,
							xevent.ExposeEvent.x, xevent.ExposeEvent.y,
							xevent.ExposeEvent.width, xevent.ExposeEvent.height);
					goto StartOver;
				}
				else if (xevent.AnyEvent.type == XEventName.ConfigureNotify) {
#if spew
					Console.Write ("C");
					Console.Out.Flush ();
#endif
					X11Hwnd hwnd = (X11Hwnd)Hwnd.GetObjectFromWindow (xevent.AnyEvent.window);
					hwnd.AddConfigureNotify (xevent);
					goto StartOver;
				}
				else {
#if spew
					Console.Write ("X");
					Console.Out.Flush ();
#endif
					/* it was an event we can deal with directly, return it */
					return true;
				}
			}
			else {
				if (paint_queue.Count > 0) {
					xevent = paint_queue.Dequeue ();
#if spew
					Console.Write ("e");
					Console.Out.Flush ();
#endif
					return true;
				}
				else if (configure_queue.Count > 0) {
					xevent = configure_queue.Dequeue ();
#if spew
					Console.Write ("c");
					Console.Out.Flush ();
#endif
					return true;
				}
			}

			if (dispatch_idle && need_dispatch_idle) {
				OnIdle (EventArgs.Empty);
				need_dispatch_idle = false;
			}

			lock (lockobj) {
				if (CountUnlocked > 0)
					goto StartOver;

				if (Monitor.Wait (lockobj, NextTimeout (), true)) {
					// the lock was reaquired before the
					// timeout.  meaning an event was
					// enqueued by X11Display.XEventThread.
					goto StartOver;
				}
				else {
					CheckTimers ();
					return false;
				}
			}
		}

		public void RemovePaint (Hwnd hwnd)
		{
			paint_queue.Remove (hwnd);
		}

		public void AddPaint (Hwnd hwnd)
		{
			paint_queue.Enqueue (hwnd);
		}

		public void AddConfigure (Hwnd hwnd)
		{
			configure_queue.Enqueue (hwnd);
		}

		public ConfigureQueue Configure {
			get { return configure_queue; }
		}

		public PaintQueue Paint {
			get { return paint_queue; }
		}

		public void Lock ()
		{
			Monitor.Enter (lockobj);
		}

		public void Unlock ()
		{
			Monitor.Exit (lockobj);
		}

		private int NextTimeout ()
		{
			int timeout = Int32.MaxValue; 
			DateTime now = DateTime.UtcNow;

			foreach (Timer timer in timer_list) {
				int next = (int) (timer.Expires - now).TotalMilliseconds;
				if (next < 0)
					return 0; // Have a timer that has already expired

				if (next < timeout)
					timeout = next;
			}

			if (timeout < Timer.Minimum) {
				timeout = Timer.Minimum;
			}

			if (timeout == Int32.MaxValue)
				timeout = Timeout.Infinite;

			return timeout;
		}

		public void CheckTimers ()
		{
			int count;
			DateTime now = DateTime.UtcNow;

			count = timer_list.Count;

			if (count == 0)
				return;

			for (int i = 0; i < timer_list.Count; i++) {
				Timer timer;

				timer = (Timer) timer_list [i];

				if (timer.Enabled && timer.Expires <= now) {
					timer.Update (now);
					timer.FireTick ();
				}
			}
		}

		public void SetTimer (Timer timer)
		{
			lock (lockobj) {
				timer_list.Add (timer);

				// we need to wake up any thread waiting in DequeueUnlocked,
				// since it might need to wait for a different amount of time.
				Monitor.PulseAll (lockobj);
			}

		}

		public void KillTimer (Timer timer)
		{
			lock (lockobj) {
				timer_list.Remove (timer);

				// we need to wake up any thread waiting in DequeueUnlocked,
				// since it might need to wait for a different amount of time.
				Monitor.PulseAll (lockobj);
			}
		}

		public event EventHandler Idle;
		public void OnIdle (EventArgs e)
		{
			if (Idle != null)
				Idle (thread, e);
		}

		public bool NeedDispatchIdle {
			get { return need_dispatch_idle; }
			set { need_dispatch_idle = value; }
		}

		public bool DispatchIdle {
			get { return dispatch_idle; }
			set { dispatch_idle = value; }
		}

		public bool PostQuitState {
			get { return quit_posted; }
			set { quit_posted = value; }
		}

		public abstract class HwndEventQueue {
			protected ArrayList hwnds;
#if DebugHwndEventQueue
			protected ArrayList stacks;
#endif
			public HwndEventQueue (int size)
			{
				hwnds = new ArrayList (size);
#if DebugHwndEventQueue
				stacks = new ArrayList (size);
#endif
			}

			public int Count {
				get { return hwnds.Count; }
			}

			public void Enqueue (Hwnd hwnd)
			{
				if (hwnds.Contains (hwnd)) {
#if DebugHwndEventQueue
					Console.WriteLine ("hwnds can only appear in the queue once.");
					Console.WriteLine (Environment.StackTrace);
					Console.WriteLine ("originally added here:");
					Console.WriteLine (stacks[hwnds.IndexOf (hwnd)]);
#endif

					return;
				}
				hwnds.Add(hwnd);
#if DebugHwndEventQueue
				stacks.Add(Environment.StackTrace);
#endif
			}

			public void Remove(Hwnd hwnd)
			{
#if DebugHwndEventQueue
				int index = hwnds.IndexOf(hwnd);
				if (index != -1)
					stacks.RemoveAt(index);
#endif
				hwnds.Remove(hwnd);
			}

			protected abstract XEvent Peek ();

			public virtual XEvent Dequeue ()
			{
				if (hwnds.Count == 0)
					throw new Exception ("Attempt to dequeue empty queue.");

				return Peek ();
			}
		}


		public class ConfigureQueue : HwndEventQueue
		{
			public ConfigureQueue (int size) : base (size)
			{
			}

			protected override XEvent Peek ()
			{
				X11Hwnd hwnd = (X11Hwnd)hwnds[0];

				XEvent xevent = new XEvent ();
				xevent.AnyEvent.type = XEventName.ConfigureNotify;

				xevent.ConfigureEvent.window = hwnd.ClientWindow;
				xevent.ConfigureEvent.x = hwnd.X;
				xevent.ConfigureEvent.y = hwnd.Y;
				xevent.ConfigureEvent.width = hwnd.Width;
				xevent.ConfigureEvent.height = hwnd.Height;
				
				return xevent;
			}

			public override XEvent Dequeue ()
			{
				XEvent xev = base.Dequeue ();


				hwnds.RemoveAt(0);
#if DebugHwndEventQueue
				stacks.RemoveAt(0);
#endif

				return xev;
			}
		}

		public class PaintQueue : HwndEventQueue
		{
			public PaintQueue (int size) : base (size)
			{
			}

			protected override XEvent Peek ()
			{
				X11Hwnd hwnd = (X11Hwnd)hwnds[0];

				XEvent xevent = new XEvent ();

				xevent.AnyEvent.type = XEventName.Expose;

				if (hwnd.PendingExpose) {
					xevent.ExposeEvent.window = hwnd.ClientWindow;
				} else {
					xevent.ExposeEvent.window = hwnd.WholeWindow;
					xevent.ExposeEvent.x = hwnd.nc_invalid.X;
					xevent.ExposeEvent.y = hwnd.nc_invalid.Y;
					xevent.ExposeEvent.width = hwnd.nc_invalid.Width;
					xevent.ExposeEvent.height = hwnd.nc_invalid.Height;
				}

				return xevent;
			}

			// don't override Dequeue like ConfigureQueue does.
		}

		/* a circular queue for holding X events for processing by GetMessage */
		private class XEventQueue {

			XEvent[] xevents;
			int head;
			int tail;
			int size;
			
			public XEventQueue (int initial_size)
			{
				if (initial_size % 2 != 0)
					throw new Exception ("XEventQueue must be a power of 2 size");

				xevents = new XEvent [initial_size];
			}

			public int Count {
				get { return size; }
			}

			public void Enqueue (XEvent xevent)
			{
				if (size == xevents.Length)
					Grow ();

				xevents [tail] = xevent;
				tail = (tail + 1) & (xevents.Length - 1);
				size++;
			}

			public XEvent Dequeue ()
			{
				if (size < 1)
					throw new Exception ("Attempt to dequeue empty queue.");

				XEvent res = xevents [head];
				head = (head + 1) & (xevents.Length - 1);
				size--;
				return res;
			}

			public XEvent Peek()
			{
				if (size < 1)
					throw new Exception ("Attempt to peek at empty queue.");

				return xevents[head];
			}

			private void Grow ()
			{
				int newcap = (xevents.Length * 2);
				XEvent [] na = new XEvent [newcap];

				if (head + size > xevents.Length) {
					Array.Copy (xevents, head, na, 0, xevents.Length - head);
					Array.Copy (xevents, 0, na, xevents.Length - head, head + size - xevents.Length);
				}
				else {
					Array.Copy (xevents, head, na, 0, size);
				}

				xevents = na;
				head = 0;
				tail = head + size;
			}
		}
	}
}