/*
 * Util.ParallelPortWriter.cs
 * Authors: Adam Nabinger
 * Copyright (c) 2007-2008 Cornell University

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
*/

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace Util
{
	/// <summary>
	/// Access to write individual bytes of data to the parallel port.
	/// </summary>
	public sealed class ParallelPortWriter : IDisposable
	{
		#region Enums

		/// <summary>
		/// An Internal flag to holding the current state of the parallel port.
		/// </summary>
		private enum ModeFlags
		{
			/// <summary>
			/// The parallel port is currently being held low, and the duration has passed since the transition.
			/// So any data received may be written immediately.
			/// </summary>
			Waiting,
			/// <summary>
			/// The parallel port is currently being held high with a data write.
			/// </summary>
			High,
			/// <summary>
			/// The parallel port is currently being held low immediately following a data write.
			/// </summary>
			Low
		}

		#endregion

		#region Constants

		/// <summary>
		/// The identifier for the driver file.
		/// </summary>
		internal const string DriverFile = @"inpout32.dll";

		/// <summary>
		/// The duration to hold each high and low written, in milliseconds.
		/// </summary>
		private const float DurationMilliseconds = 5.0f;

		/// <summary>
		/// How long the thread should sleep in between checks while holding the port for DurationMilliseconds.
		/// Due to the nature of threading, this is not an absolute amount of time, but rather a request.
		/// It may be less time, or more, before the thread is reawakened.
		/// So this value should be small, to ensure the actual time is close to the specified duration.
		/// </summary>
		private const int SleepMilliseconds = 1;

		#endregion

		#region Fields

		/// <summary>
		/// The duration, in CPU ticks. This will vary based on the speed of the processor,
		/// but is faster and more accurate to check than clock time.
		/// </summary>
		private static readonly long DurationTicks = (long)(Stopwatch.Frequency * DurationMilliseconds / 1000.0);

		/// <summary>
		/// Internal count of how many live references there are to the parallel port writer.
		/// The final dispose call will block until all pending data is written.
		/// </summary>
		private static int references;

		/// <summary>
		/// The thread that will do all of the writing.
		/// </summary>
		private static Thread WorkerThread;

		/// <summary>
		/// The Queue for storing the pending data to be written.
		/// </summary>
		private static Queue<byte> MyQueue;

		/// <summary>
		/// The current status of the parallel port.
		/// </summary>
		private static ModeFlags Status = ModeFlags.Waiting;

		/// <summary>
		/// The CPU tick time at which the next transition may take place.
		/// </summary>
		private static long NextTransition;

		/// <summary>
		/// Should the background worker currently be running.
		/// </summary>
		private static bool run;

		/// <summary>
		/// Has this writer been initialized.
		/// </summary>
		private bool initialized;

		/// <summary>
		/// Has this writer been disposed.
		/// </summary>
		private bool disposed;

		#endregion

		#region Initialization

		/// <summary>
		/// Initialize this device to be ready to recieve data.
		/// </summary>
		public void Initialize()
		{
			if (initialized)
			{
				return;
			}
			initialized = true;
			if (++references != 1)
			{
				return;
			}
			MyQueue = new Queue<byte>();
			run = true;
			WorkerThread = new Thread(ParallelPortBackgroundThread);
            WorkerThread.Priority = ThreadPriority.AboveNormal;
            WorkerThread.Name = "ParallelPortWriter WorkerThread";
			WorkerThread.Start();
			strobe(false);
		}

		#endregion

		#region Management

		/// <summary>
		/// Dispose of this device, to write all pending data.
		/// </summary>
		public void Dispose()
		{
			if (!initialized || disposed)
			{
				return;
			}
			disposed = true;
			if (--references != 0)
			{
				return;
			}
			run = false;
			lock (WorkerThread)
			{
				Monitor.Pulse(WorkerThread);
            }

            WorkerThread.Join();
		}

		#endregion

		#region Read/Write

		/// <summary>
		/// Reads in a bye of data from the parallel port
		/// </summary>
		/// <returns>The byte currently stored in the parallel port</returns>
		internal static byte read()
		{
			return NativeMethods.Inp32((short)Settings.ParallelPort);
		}

		/// <summary>
		/// Writes a byte of data to the parallel port
		/// </summary>
		/// <param name="data">The byte to write to the parallel port</param>
		private static void write(byte data)
		{
			NativeMethods.Out32((short)Settings.ParallelPort, data);
		}

		/// <summary>
		/// Writes this code out the parallel port.
		/// </summary>
		/// <param name="code">The numeric event code to right out.</param>
		public void Write(byte code)
		{
#if DEBUG
			if (!initialized || disposed)
			{
				throw new InvalidOperationException("Writer was not initialized, or was disposed.");
			}
#endif
			MyQueue.Enqueue(code);
			lock (WorkerThread)
			{
				Monitor.Pulse(WorkerThread);
			}
		}

		#endregion

		#region Strobe

		/// <summary>
		/// Set the strobe pin, according to documentation.
		/// Untested.
		/// </summary>
		/// <param name="low">Should the strobe be low, as when writing data.</param>
		private static void strobe(bool low)
		{
			if (low)
			{
				NativeMethods.Out32((short)(Settings.ParallelPort + 2), (byte)(NativeMethods.Inp32((short)(Settings.ParallelPort + 2)) & 0xFE));
			}
			else
			{
				NativeMethods.Out32((short)(Settings.ParallelPort + 2), (byte)(NativeMethods.Inp32((short)(Settings.ParallelPort + 2)) | 0x01));
			}
		}

		#endregion

		#region Writer Thread

		/// <summary>
		/// The code for the background thread to run.
		/// </summary>
		private static void ParallelPortBackgroundThread()
		{
			do
			{
				lock (WorkerThread)
				{
					// Wait until pulsed to indicate some data is waiting to be written.
					if(run) Monitor.Wait(WorkerThread);
				}
				// The thread may be awoken early, so check.
				if (MyQueue.Count <= 0)
				{
					continue;
				}
				// If there is data, write it.
#if DEBUG
				Console.WriteLine("Parallel Port Output:\t" + MyQueue.Dequeue());
#else
				write(MyQueue.Dequeue());
#endif
				strobe(true);
				// Next Transition is the earliest point we should change the parallel port to a different value.
				NextTransition = Stopwatch.GetTimestamp() + DurationTicks;
				// Set our status to remember we are currently writing to the port.
				Status = ModeFlags.High;
				do
				{
					switch (Status)
					{
						case ModeFlags.High:
							// Sleep until the NextTransition time has passed.
							while (Stopwatch.GetTimestamp() < NextTransition) { Thread.Sleep(SleepMilliseconds); }
							// Reset to 0 and hold.
							strobe(false);
							write(0);
							NextTransition = Stopwatch.GetTimestamp() + DurationTicks;
							Status = ModeFlags.Low;
							break;
						case ModeFlags.Low:
							if (MyQueue.Count > 0)
							{
								while (Stopwatch.GetTimestamp() < NextTransition) { Thread.Sleep(SleepMilliseconds); }
#if DEBUG
								Console.WriteLine("Parallel Port Output:\t" + MyQueue.Dequeue());
#else
								write(MyQueue.Dequeue());
#endif
								strobe(true);
								NextTransition = Stopwatch.GetTimestamp() + DurationTicks;
								Status = ModeFlags.High;
							}
							else
							{
								while (Stopwatch.GetTimestamp() < NextTransition) { Thread.Sleep(SleepMilliseconds); }
								// Another event may have been queued while we were sleeping, check before waiting.
								if (MyQueue.Count > 0)
								{
#if DEBUG
									Console.WriteLine("Parallel Port Output:\t" + MyQueue.Dequeue());
#else
									write(MyQueue.Dequeue());
#endif
									strobe(true);
									NextTransition = Stopwatch.GetTimestamp() + DurationTicks;
									Status = ModeFlags.High;
								}
								else // No events in the queue, we can go back to waiting.
								{
									Status = ModeFlags.Waiting;
								}
							}
							break;
					}
				} while (Status != ModeFlags.Waiting);
			} while (run);
		}

		#endregion
	}
}