// 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.
//
// System.Windows.Forms.XEventQueue
//
// Authors:
//  Jackson Harper (jackson@ximian.com)
//  Peter Dennis Bartok (pbartok@novell.com)
//

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

namespace System.Windows.Forms {

	internal class XEventQueue {

		private XQueue		xqueue;
		private XQueue		lqueue;	// Events inserted from threads other then the main X thread
		private PaintQueue	paint;	// Paint-only queue
		internal ArrayList	timer_list;
		private Thread		thread;
		private bool            dispatch_idle;

		private static readonly int InitialXEventSize = 100;
		private static readonly int InitialLXEventSize = 10;
		private static readonly int InitialPaintSize = 50;

		public XEventQueue (Thread thread) {
			xqueue = new XQueue (InitialXEventSize);
			lqueue = new XQueue (InitialLXEventSize);
			paint = new PaintQueue(InitialPaintSize);
			timer_list = new ArrayList ();
			this.thread = thread;
			this.dispatch_idle = true;
		}

		public int Count {
			get {
				lock (lqueue) {
					return xqueue.Count + lqueue.Count;
				}
			}
		}

		public PaintQueue Paint {
			get {
				return paint;
			}
		}

		public Thread Thread {
			get {
				return thread;
			}
		}

		public void Enqueue (XEvent xevent)
		{
			if (Thread.CurrentThread != thread) {
				Console.WriteLine ("Hwnd.Queue.Enqueue called from a different thread without locking.");
				Console.WriteLine (Environment.StackTrace);
			}

			xqueue.Enqueue (xevent);
		}

		public void EnqueueLocked (XEvent xevent)
		{
			lock (lqueue) {
				lqueue.Enqueue (xevent);
			}
		}

		public XEvent Dequeue ()
		{
			if (Thread.CurrentThread != thread) {
				Console.WriteLine ("Hwnd.Queue.Dequeue called from a different thread without locking.");
				Console.WriteLine (Environment.StackTrace);
			}

			if (xqueue.Count == 0) {
				lock (lqueue) {
					return lqueue.Dequeue ();
				}
			}
			return xqueue.Dequeue ();
		}

		public XEvent Peek()
		{
			if (Thread.CurrentThread != thread) {
				Console.WriteLine ("Hwnd.Queue.Peek called from a different thread without locking.");
				Console.WriteLine (Environment.StackTrace);
			}

			if (xqueue.Count == 0) {
				lock (lqueue) {
					return lqueue.Peek ();
				}
			}				
			return xqueue.Peek();
		}

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

		public class PaintQueue {

			private ArrayList	hwnds;
			private XEvent		xevent;
			
			public PaintQueue (int size) {
				hwnds = new ArrayList(size);
				xevent = new XEvent();
				xevent.AnyEvent.type = XEventName.Expose;
			}

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

			public void Enqueue (Hwnd hwnd) {
				hwnds.Add(hwnd);
			}

			public void Remove(Hwnd hwnd) {
				if (!hwnd.expose_pending && !hwnd.nc_expose_pending) {
					hwnds.Remove(hwnd);
				}
			}

			public XEvent Dequeue () {
				Hwnd		hwnd;
				IEnumerator	next;

				if (hwnds.Count == 0) {
					xevent.ExposeEvent.window = IntPtr.Zero;
					return xevent;
				}

				next = hwnds.GetEnumerator();
				next.MoveNext();
				hwnd = (Hwnd)next.Current;

				// We only remove the event from the queue if we have one expose left since
				// a single 'entry in our queue may be for both NC and Client exposed
				if ( !(hwnd.nc_expose_pending && hwnd.expose_pending)) {
					hwnds.Remove(hwnd);
				}
				if (hwnd.expose_pending) {
					xevent.ExposeEvent.window = hwnd.client_window;
#if not
					xevent.ExposeEvent.x = hwnd.invalid.X;
					xevent.ExposeEvent.y = hwnd.invalid.Y;
					xevent.ExposeEvent.width = hwnd.invalid.Width;
					xevent.ExposeEvent.height = hwnd.invalid.Height;
#endif
					return xevent;
				} else {
					xevent.ExposeEvent.window = hwnd.whole_window;
					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;
				}
			}
		}

		private class XQueue {

			private XEvent [] xevents;
			private int head;
			private int tail;
			private int size;
			
			public XQueue (int size)
			{
				xevents = new XEvent [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;
				size++;
			}

			public XEvent Dequeue ()
			{
				if (size < 1)
					throw new Exception ("Attempt to dequeue empty queue.");
				XEvent res = xevents [head];
				head = (head + 1) % xevents.Length;
				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];
				xevents.CopyTo (na, 0);
				xevents = na;
				head = 0;
				tail = head + size;
			}
		}
	}
}