using Microsoft.Win32.SafeHandles;

 using System;

 using System.Diagnostics;

 using System.IO;

 using System.Runtime.InteropServices;

 using System.Threading;

 using System.Threading.Tasks;

 using System.Windows.Forms;

 namespace GenericHid

 {

 	///  <summary>

 	///  Supports Windows API functions for accessing HID-class USB devices.

 	///  Includes routines for retrieving information about the configuring a HID and 

 	///  sending and receiving reports via control and interrupt transfers. 

 	///  </summary>

 	internal sealed partial class Hid

 	{

 		//  Used in error messages.

 		private const String ModuleName = "Hid";

 		internal NativeMethods.HIDP_CAPS Capabilities;

 		internal NativeMethods.HIDD_ATTRIBUTES DeviceAttributes;

 		//  For viewing results of API calls in debug.write statements:

 		internal static Debugging MyDebugging = new Debugging();

 		///  <summary>

 		///  Provides a central mechanism for exception handling.

 		///  Displays a message box that describes the exception.

 		///  </summary>

 		///  

 		///  <param name="moduleName">  the module where the exception occurred. </param>

 		///  <param name="e"> the exception </param>

 		internal static void DisplayException(String moduleName, Exception e)

 		{

 			//  Create an error message.

 			String message = "Exception: " + e.Message + Environment.NewLine + "Module: " + moduleName + Environment.NewLine + "Method: " + e.TargetSite.Name;

 			const String caption = "Unexpected Exception";

 			MessageBox.Show(message, caption, MessageBoxButtons.OK);

 			Debug.Write(message);

 			// Get the last error and display it. 

 			Int32 error = Marshal.GetLastWin32Error();

 			Debug.WriteLine("The last Win32 Error was: " + error);

 		}

 		///  <summary>

 		///  Remove any Input reports waiting in the buffer.

 		///  </summary>

 		///  <param name="hidHandle"> a handle to a device.   </param>

 		///  <returns>

 		///  True on success, False on failure.

 		///  </returns>

 		internal Boolean FlushQueue(SafeFileHandle hidHandle)

 		{

 			try

 			{

 				//  ***

 				//  API function: HidD_FlushQueue

 				//  Purpose: Removes any Input reports waiting in the buffer.

 				//  Accepts: a handle to the device.

 				//  Returns: True on success, False on failure.

 				//  ***

 				Boolean success = NativeMethods.HidD_FlushQueue(hidHandle);

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		/// <summary>

 		/// Get HID attributes.

 		/// </summary>

 		/// <param name="hidHandle"> HID handle retrieved with CreateFile </param>

 		/// <param name="deviceAttributes"> HID attributes structure </param>

 		/// <returns> true on success </returns>

 		internal Boolean GetAttributes(SafeFileHandle hidHandle, ref NativeMethods.HIDD_ATTRIBUTES deviceAttributes)

 		{

 			Boolean success;

 			try

 			{

 				//  ***

 				//  API function:

 				//  HidD_GetAttributes

 				//  Purpose:

 				//  Retrieves a HIDD_ATTRIBUTES structure containing the Vendor ID, 

 				//  Product ID, and Product Version Number for a device.

 				//  Accepts:

 				//  A handle returned by CreateFile.

 				//  A pointer to receive a HIDD_ATTRIBUTES structure.

 				//  Returns:

 				//  True on success, False on failure.

 				//  ***                            

 				success = NativeMethods.HidD_GetAttributes(hidHandle, ref deviceAttributes);

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 			return success;

 		}

 		///  <summary>

 		///  Retrieves a structure with information about a device's capabilities. 

 		///  </summary>

 		///  

 		///  <param name="hidHandle"> a handle to a device. </param>

 		///  

 		///  <returns>

 		///  An HIDP_CAPS structure.

 		///  </returns>

 		internal NativeMethods.HIDP_CAPS GetDeviceCapabilities(SafeFileHandle hidHandle)

 		{

 			var preparsedData = new IntPtr();

 			try

 			{

 				//  ***

 				//  API function: HidD_GetPreparsedData

 				//  Purpose: retrieves a pointer to a buffer containing information about the device's capabilities.

 				//  HidP_GetCaps and other API functions require a pointer to the buffer.

 				//  Requires: 

 				//  A handle returned by CreateFile.

 				//  A pointer to a buffer.

 				//  Returns:

 				//  True on success, False on failure.

 				//  ***

 				NativeMethods.HidD_GetPreparsedData(hidHandle, ref preparsedData);

 				//  ***

 				//  API function: HidP_GetCaps

 				//  Purpose: find out a device's capabilities.

 				//  For standard devices such as joysticks, you can find out the specific

 				//  capabilities of the device.

 				//  For a custom device where the software knows what the device is capable of,

 				//  this call may be unneeded.

 				//  Accepts:

 				//  A pointer returned by HidD_GetPreparsedData

 				//  A pointer to a HIDP_CAPS structure.

 				//  Returns: True on success, False on failure.

 				//  ***

 				Int32 result = NativeMethods.HidP_GetCaps(preparsedData, ref Capabilities);

 				if ((result != 0))

 				{

 					Debug.WriteLine("");

 					Debug.WriteLine("  Usage: " + Convert.ToString(Capabilities.Usage, 16));

 					Debug.WriteLine("  Usage Page: " + Convert.ToString(Capabilities.UsagePage, 16));

 					Debug.WriteLine("  Input Report Byte Length: " + Capabilities.InputReportByteLength);

 					Debug.WriteLine("  Output Report Byte Length: " + Capabilities.OutputReportByteLength);

 					Debug.WriteLine("  Feature Report Byte Length: " + Capabilities.FeatureReportByteLength);

 					Debug.WriteLine("  Number of Link Collection Nodes: " + Capabilities.NumberLinkCollectionNodes);

 					Debug.WriteLine("  Number of Input Button Caps: " + Capabilities.NumberInputButtonCaps);

 					Debug.WriteLine("  Number of Input Value Caps: " + Capabilities.NumberInputValueCaps);

 					Debug.WriteLine("  Number of Input Data Indices: " + Capabilities.NumberInputDataIndices);

 					Debug.WriteLine("  Number of Output Button Caps: " + Capabilities.NumberOutputButtonCaps);

 					Debug.WriteLine("  Number of Output Value Caps: " + Capabilities.NumberOutputValueCaps);

 					Debug.WriteLine("  Number of Output Data Indices: " + Capabilities.NumberOutputDataIndices);

 					Debug.WriteLine("  Number of Feature Button Caps: " + Capabilities.NumberFeatureButtonCaps);

 					Debug.WriteLine("  Number of Feature Value Caps: " + Capabilities.NumberFeatureValueCaps);

 					Debug.WriteLine("  Number of Feature Data Indices: " + Capabilities.NumberFeatureDataIndices);

 					//  ***

 					//  API function: HidP_GetValueCaps

 					//  Purpose: retrieves a buffer containing an array of HidP_ValueCaps structures.

 					//  Each structure defines the capabilities of one value.

 					//  This application doesn't use this data.

 					//  Accepts:

 					//  A report type enumerator from hidpi.h,

 					//  A pointer to a buffer for the returned array,

 					//  The NumberInputValueCaps member of the device's HidP_Caps structure,

 					//  A pointer to the PreparsedData structure returned by HidD_GetPreparsedData.

 					//  Returns: True on success, False on failure.

 					//  ***                    

 					Int32 vcSize = Capabilities.NumberInputValueCaps;

 					var valueCaps = new Byte[vcSize];

 					NativeMethods.HidP_GetValueCaps(NativeMethods.HidP_Input, valueCaps, ref vcSize, preparsedData);

 					// (To use this data, copy the ValueCaps byte array into an array of structures.)              

 				}

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 			finally

 			{

 				//  ***

 				//  API function: HidD_FreePreparsedData

 				//  Purpose: frees the buffer reserved by HidD_GetPreparsedData.

 				//  Accepts: A pointer to the PreparsedData structure returned by HidD_GetPreparsedData.

 				//  Returns: True on success, False on failure.

 				//  ***

 				if (preparsedData != IntPtr.Zero)

 				{

 					NativeMethods.HidD_FreePreparsedData(preparsedData);

 				}

 			}

 			return Capabilities;

 		}

 		///  <summary>

 		///  reads a Feature report from the device.

 		///  </summary>

 		///  

 		///  <param name="hidHandle"> the handle for learning about the device and exchanging Feature reports. </param>	

 		///  <param name="inFeatureReportBuffer"> contains the requested report.</param>

 		internal Boolean GetFeatureReport(SafeFileHandle hidHandle, ref Byte[] inFeatureReportBuffer)

 		{

 			try

 			{

 				Boolean success = false;

 				//  ***

 				//  API function: HidD_GetFeature

 				//  Attempts to read a Feature report from the device.

 				//  Requires:

 				//  A handle to a HID

 				//  A pointer to a buffer containing the report ID and report

 				//  The size of the buffer. 

 				//  Returns: true on success, false on failure.

 				//  ***                    

 				if (!hidHandle.IsInvalid && !hidHandle.IsClosed)

 				{

 					success = NativeMethods.HidD_GetFeature(hidHandle, inFeatureReportBuffer, inFeatureReportBuffer.Length);

 					Debug.Print("HidD_GetFeature success = " + success);

 				}

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		/// <summary>

 		/// Get the HID-class GUID

 		/// </summary>

 		/// <returns> the GUID </returns>

 		internal Guid GetHidGuid()

 		{

 			Guid hidGuid = Guid.Empty;

 			try

 			{

 				//  ***

 				//  API function: 'HidD_GetHidGuid

 				//  Purpose: Retrieves the interface class GUID for the HID class.

 				//  Accepts: A System.Guid object for storing the GUID.

 				//  ***

 				NativeMethods.HidD_GetHidGuid(ref hidGuid);

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 			return hidGuid;

 		}

 		///  <summary>

 		///  Creates a 32-bit Usage from the Usage Page and Usage ID. 

 		///  Determines whether the Usage is a system mouse or keyboard.

 		///  Can be modified to detect other Usages.

 		///  </summary>

 		///  

 		///  <param name="myCapabilities"> a HIDP_CAPS structure retrieved with HidP_GetCaps. </param>

 		///  

 		///  <returns>

 		///  A String describing the Usage.

 		///  </returns>

 		internal String GetHidUsage(NativeMethods.HIDP_CAPS myCapabilities)

 		{

 			String usageDescription = "";

 			try

 			{

 				//  Create32-bit Usage from Usage Page and Usage ID.

 				Int32 usage = myCapabilities.UsagePage * 256 + myCapabilities.Usage;

 				if (usage == Convert.ToInt32(0X102))

 				{

 					usageDescription = "mouse";

 				}

 				if (usage == Convert.ToInt32(0X106))

 				{

 					usageDescription = "keyboard";

 				}

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 			return usageDescription;

 		}

 		///  <summary>

 		///  reads an Input report from the device using a control transfer.

 		///  </summary>  

 		///  <param name="hidHandle"> the handle for learning about the device and exchanging Feature reports. </param>

 		/// <param name="inputReportBuffer"> contains the requested report. </param>

 		internal Boolean GetInputReportViaControlTransfer(SafeFileHandle hidHandle, ref Byte[] inputReportBuffer)

 		{

 			var success = false;

 			try

 			{

 				//  ***

 				//  API function: HidD_GetInputReport

 				//  Purpose: Attempts to read an Input report from the device using a control transfer.

 				//  Requires:

 				//  A handle to a HID

 				//  A pointer to a buffer containing the report ID and report

 				//  The size of the buffer. 

 				//  Returns: true on success, false on failure.

 				//  ***

 				if (!hidHandle.IsInvalid && !hidHandle.IsClosed)

 				{

 					success = NativeMethods.HidD_GetInputReport(hidHandle, inputReportBuffer, inputReportBuffer.Length + 1);

 					Debug.Print("HidD_GetInputReport success = " + success);

 				}

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		///  <summary>

 		///  Reads an Input report from the device using an interrupt transfer.

 		///  </summary>

 		///  

 		///  <param name="deviceData"> the Filestream for writing data. </param> 

 		///  <param name="inputReportBuffer"> contains the report ID and report data. </param>

 		/// <returns>

 		///   True on success. False on failure.

 		///  </returns>  

 		internal async Task<Int32> GetInputReportViaInterruptTransfer(FileStream deviceData, Byte[] inputReportBuffer, CancellationTokenSource cts)

 		{

 			try

 			{

 				Int32 bytesRead = 0;

 					// Begin reading an Input report. 

 					Task<Int32> t = deviceData.ReadAsync(inputReportBuffer, 0, inputReportBuffer.Length, cts.Token);

 					bytesRead = await t;

 					// Gets to here only if the read operation completed before a timeout.

 					Debug.Print("Asynchronous read completed. Bytes read = " + Convert.ToString(bytesRead));

 					// The operation has one of these completion states:

 					switch (t.Status)

 					{

 						case TaskStatus.RanToCompletion:

 							Debug.Print("Input report received from device");

 							break;

 						case TaskStatus.Canceled:

 							Debug.Print("Task canceled");

 							break;

 						case TaskStatus.Faulted:

 							Debug.Print("Unhandled exception");

 							break;

 					}

 				return bytesRead;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		///  <summary>

 		///  Retrieves the number of Input reports the HID driver will store.

 		///  </summary>

 		///  

 		///  <param name="hidDeviceObject"> a handle to a device  </param>

 		///  <param name="numberOfInputBuffers"> an integer to hold the returned value. </param>

 		///  

 		///  <returns>

 		///  True on success, False on failure.

 		///  </returns>

 		internal Boolean GetNumberOfInputBuffers(SafeFileHandle hidDeviceObject, ref Int32 numberOfInputBuffers)

 		{

 			try

 			{

 				//  ***

 				//  API function: HidD_GetNumInputBuffers

 				//  Purpose: retrieves the number of Input reports the host can store.

 				//  Not supported by Windows 98 Gold.

 				//  If the buffer is full and another report arrives, the host drops the 

 				//  ldest report.

 				//  Accepts: a handle to a device and an integer to hold the number of buffers. 

 				//  Returns: True on success, False on failure.

 				//  ***

 				Boolean success = NativeMethods.HidD_GetNumInputBuffers(hidDeviceObject, ref numberOfInputBuffers);

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		/// <summary>

 		/// Timeout if read or write via interrupt transfer doesn't return.

 		/// </summary>

 		internal void OnTimeout()

 		{

 			try

 			{

 				// No action required.

 				Debug.Print("timeout");

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		/// <summary>

 		/// Attempts to open a handle to a HID.

 		/// </summary>

 		/// <param name="devicePathName"> device path name returned by SetupDiGetDeviceInterfaceDetail </param>

 		/// <param name="readAndWrite"> true if requesting read/write access for Input and Output reports </param>

 		/// <returns> hidHandle - a handle to the HID </returns>

 		internal SafeFileHandle OpenHandle(String devicePathName, Boolean readAndWrite)

 		{

 			SafeFileHandle hidHandle;

 			try

 			{

 				if (readAndWrite)

 				{

 					//  ***

 					//  API function:

 					//  CreateFile

 					//  Purpose:

 					//  Retrieves a handle to a device.

 					//  Accepts:

 					//  A device path name returned by SetupDiGetDeviceInterfaceDetail

 					//  The type of access requested (read/write).

 					//  FILE_SHARE attributes to allow other processes to access the device while this handle is open.

 					//  A Security structure or IntPtr.Zero. 

 					//  A creation disposition value. Use OPEN_EXISTING for devices.

 					//  Flags and attributes for files. Not used for devices.

 					//  Handle to a template file. Not used.

 					//  Returns: a handle without read or write access.

 					//  This enables obtaining information about all HIDs, even system

 					//  keyboards and mice. 

 					//  Separate handles are used for reading and writing.

 					//  ***

 					hidHandle = FileIo.CreateFile(devicePathName, FileIo.GenericRead | FileIo.GenericWrite, FileIo.FileShareRead | FileIo.FileShareWrite, IntPtr.Zero, FileIo.OpenExisting, 0, IntPtr.Zero);

 				}

 				else

 				{

 					hidHandle = FileIo.CreateFile(devicePathName, 0, FileIo.FileShareRead | FileIo.FileShareWrite, IntPtr.Zero, FileIo.OpenExisting, 0, IntPtr.Zero);

 				}

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 			return hidHandle;

 		}

 		///  <summary>

 		///  Writes a Feature report to the device.

 		///  </summary>

 		///  

 		///  <param name="outFeatureReportBuffer"> contains the report ID and report data. </param>

 		///  <param name="hidHandle"> handle to the device.  </param>

 		///  

 		///  <returns>

 		///   True on success. False on failure.

 		///  </returns>            

 		internal Boolean SendFeatureReport(SafeFileHandle hidHandle, Byte[] outFeatureReportBuffer)

 		{

 			try

 			{

 				//  ***

 				//  API function: HidD_SetFeature

 				//  Purpose: Attempts to send a Feature report to the device.

 				//  Accepts:

 				//  A handle to a HID

 				//  A pointer to a buffer containing the report ID and report

 				//  The size of the buffer. 

 				//  Returns: true on success, false on failure.

 				//  ***

 				Boolean success = NativeMethods.HidD_SetFeature(hidHandle, outFeatureReportBuffer, outFeatureReportBuffer.Length);

 				Debug.Print("HidD_SetFeature success = " + success);

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		///  <summary>

 		///  Writes an Output report to the device using a control transfer.

 		///  </summary>

 		///  

 		///  <param name="outputReportBuffer"> contains the report ID and report data. </param>

 		///  <param name="hidHandle"> handle to the device.  </param>

 		///  

 		///  <returns>

 		///   True on success. False on failure.

 		///  </returns>            

 		internal Boolean SendOutputReportViaControlTransfer(SafeFileHandle hidHandle, Byte[] outputReportBuffer)

 		{

 			try

 			{

 				//  ***

 				//  API function: HidD_SetOutputReport

 				//  Purpose: 

 				//  Attempts to send an Output report to the device using a control transfer.

 				//  Accepts:

 				//  A handle to a HID

 				//  A pointer to a buffer containing the report ID and report

 				//  The size of the buffer. 

 				//  Returns: true on success, false on failure.

 				//  ***                    

 				Boolean success = NativeMethods.HidD_SetOutputReport(hidHandle, outputReportBuffer, outputReportBuffer.Length);

 				Debug.Print("HidD_SetOutputReport success = " + success);

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		///  <summary>

 		///  Writes an Output report to the device using an interrupt transfer.

 		///  </summary>

 		///  

 		///  <param name="fileStreamDeviceData"> the Filestream for writing data. </param> 

 		///  <param name="hidHandle"> SafeFileHandle to the device.  </param>

 		///  <param name="outputReportBuffer"> contains the report ID and report data. </param>

 		///  <param name="cts"> CancellationTokenSource </param>

 		///  

 		///  <returns>

 		///   1 on success. 0 on failure.

 		///  </returns>            

 		internal async Task<Boolean> SendOutputReportViaInterruptTransfer

 			(FileStream fileStreamDeviceData, SafeFileHandle hidHandle, Byte[] outputReportBuffer, CancellationTokenSource cts)

 		{

 			try

 			{

 				var success = false;

 					// Begin writing the Output report. 

 					Task t = fileStreamDeviceData.WriteAsync(outputReportBuffer, 0, outputReportBuffer.Length, cts.Token);

 					await t;

 					// Gets to here only if the write operation completed before a timeout.

 					Debug.Print("Asynchronous write completed");

 					// The operation has one of these completion states:

 					switch (t.Status)

 					{

 						case TaskStatus.RanToCompletion:

 							success = true;

 							Debug.Print("Output report written to device");

 							break;

 						case TaskStatus.Canceled:

 							Debug.Print("Task canceled");

 							break;

 						case TaskStatus.Faulted:

 							Debug.Print("Unhandled exception");

 							break;

 					}

 				return success;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 		///  <summary>

 		///  sets the number of input reports the host HID driver store.

 		///  </summary>

 		///  

 		///  <param name="hidDeviceObject"> a handle to the device.</param>

 		///  <param name="numberBuffers"> the requested number of input reports.  </param>

 		///  

 		///  <returns>

 		///  True on success. False on failure.

 		///  </returns>

 		internal Boolean SetNumberOfInputBuffers(SafeFileHandle hidDeviceObject, Int32 numberBuffers)

 		{

 			try

 			{

 				//  ***

 				//  API function: HidD_SetNumInputBuffers

 				//  Purpose: Sets the number of Input reports the host can store.

 				//  If the buffer is full and another report arrives, the host drops the 

 				//  oldest report.

 				//  Requires:

 				//  A handle to a HID

 				//  An integer to hold the number of buffers. 

 				//  Returns: true on success, false on failure.

 				//  ***

 				NativeMethods.HidD_SetNumInputBuffers(hidDeviceObject, numberBuffers);

 				return true;

 			}

 			catch (Exception ex)

 			{

 				DisplayException(ModuleName, ex);

 				throw;

 			}

 		}

 	}

 }