using System;

using System.Diagnostics;

using System.Runtime.InteropServices; 

using System.Windows.Forms;

namespace GenericHid

{

	/// <summary>

	/// Routine for detecting devices using Win32 SetupDi functions.

	/// </summary>

	/// 

	sealed internal partial class DeviceManagement

	{

		private const String ModuleName = "Device Management";

		///  <summary>

		///  Provides a central mechanism for exception handling.

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

		///  </summary>

		///  

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

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

		internal static void DisplayException(String name, Exception e)

		{

			try

			{

				//  Create an error message.

				String message = "Exception: " + e.Message + Environment.NewLine + "Module: " + name + Environment.NewLine + "Method: " +

						  e.TargetSite.Name;

				const String caption = "Unexpected Exception";

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

				Debug.Write(message);

			}

			catch (Exception ex)

			{

				DisplayException(ModuleName, ex);

				throw;

			}

		}

		///  <summary>

		///  Use SetupDi API functions to retrieve the device path name of an

		///  attached device that belongs to a device interface class.

		///  </summary>

		///  

		///  <param name="myGuid"> an interface class GUID. </param>

		///  <param name="devicePathName"> a pointer to the device path name 

		///  of an attached device. </param>

		///  

		///  <returns>

		///   True if a device is found, False if not. 

		///  </returns>

		internal Boolean FindDeviceFromGuid(Guid myGuid, ref String[] devicePathName)

		{

			Int32 bufferSize = 0;

			var deviceInfoSet = new IntPtr();

			Boolean lastDevice = false;

			var myDeviceInterfaceData = new NativeMethods.SP_DEVICE_INTERFACE_DATA();

			try

			{

				Int32 memberIndex;

				// ***

				//  API function

				//  summary 

				//  Retrieves a device information set for a specified group of devices.

				//  SetupDiEnumDeviceInterfaces uses the device information set.

				//  parameters 

				//  Interface class GUID.

				//  Null to retrieve information for all device instances.

				//  Optional handle to a top-level window (unused here).

				//  Flags to limit the returned information to currently present devices 

				//  and devices that expose interfaces in the class specified by the GUID.

				//  Returns

				//  Handle to a device information set for the devices.

				// ***

				deviceInfoSet = NativeMethods.SetupDiGetClassDevs(ref myGuid, IntPtr.Zero, IntPtr.Zero, NativeMethods.DIGCF_PRESENT | NativeMethods.DIGCF_DEVICEINTERFACE);

				bool deviceFound = false;

				memberIndex = 0;

				// The cbSize element of the MyDeviceInterfaceData structure must be set to

				// the structure's size in bytes. 

				// The size is 28 bytes for 32-bit code and 32 bits for 64-bit code.

				myDeviceInterfaceData.cbSize = Marshal.SizeOf(myDeviceInterfaceData);

				do

				{

					// Begin with 0 and increment through the device information set until

					// no more devices are available.

					// ***

					//  API function

					//  summary

					//  Retrieves a handle to a SP_DEVICE_INTERFACE_DATA structure for a device.

					//  On return, MyDeviceInterfaceData contains the handle to a

					//  SP_DEVICE_INTERFACE_DATA structure for a detected device.

					//  parameters

					//  DeviceInfoSet returned by SetupDiGetClassDevs.

					//  Optional SP_DEVINFO_DATA structure that defines a device instance 

					//  that is a member of a device information set.

					//  Device interface GUID.

					//  Index to specify a device in a device information set.

					//  Pointer to a handle to a SP_DEVICE_INTERFACE_DATA structure for a device.

					//  Returns

					//  True on success.

					// ***

					Boolean success = NativeMethods.SetupDiEnumDeviceInterfaces

						(deviceInfoSet,

						 IntPtr.Zero,

						 ref myGuid,

						 memberIndex,

						 ref myDeviceInterfaceData);

					// Find out if a device information set was retrieved.

					if (!success)

					{

						lastDevice = true;

					}

					else

					{

						// A device is present.

						// ***

						//  API function: 

						//  summary:

						//  Retrieves an SP_DEVICE_INTERFACE_DETAIL_DATA structure

						//  containing information about a device.

						//  To retrieve the information, call this function twice.

						//  The first time returns the size of the structure.

						//  The second time returns a pointer to the data.

						//  parameters

						//  DeviceInfoSet returned by SetupDiGetClassDevs

						//  SP_DEVICE_INTERFACE_DATA structure returned by SetupDiEnumDeviceInterfaces

						//  A returned pointer to an SP_DEVICE_INTERFACE_DETAIL_DATA 

						//  Structure to receive information about the specified interface.

						//  The size of the SP_DEVICE_INTERFACE_DETAIL_DATA structure.

						//  Pointer to a variable that will receive the returned required size of the 

						//  SP_DEVICE_INTERFACE_DETAIL_DATA structure.

						//  Returned pointer to an SP_DEVINFO_DATA structure to receive information about the device.

						//  Returns

						//  True on success.

						// ***                     

						NativeMethods.SetupDiGetDeviceInterfaceDetail

							(deviceInfoSet,

							 ref myDeviceInterfaceData,

							 IntPtr.Zero,

							 0,

							 ref bufferSize,

							 IntPtr.Zero);

						// Allocate memory for the SP_DEVICE_INTERFACE_DETAIL_DATA structure using the returned buffer size.

						IntPtr detailDataBuffer = Marshal.AllocHGlobal(bufferSize);

						// Store cbSize in the first bytes of the array. Adjust for 32- and 64-bit systems.

                        Int32 cbsize;

                        if (IntPtr.Size == 4)

                        {

                            cbsize = 4 + Marshal.SystemDefaultCharSize;

                        }

                        else

                        {

                            cbsize = 8;

                        }

						Marshal.WriteInt32(detailDataBuffer, cbsize);                        

						// Call SetupDiGetDeviceInterfaceDetail again.

						// This time, pass a pointer to DetailDataBuffer

						// and the returned required buffer size.

						NativeMethods.SetupDiGetDeviceInterfaceDetail

							(deviceInfoSet,

							 ref myDeviceInterfaceData,

							 detailDataBuffer,

							 bufferSize,

							 ref bufferSize,

							 IntPtr.Zero);

						// Get the address of the devicePathName.

						var pDevicePathName = new IntPtr(detailDataBuffer.ToInt64() + 4);

						// Get the String containing the devicePathName.

						devicePathName[memberIndex] = Marshal.PtrToStringAuto(pDevicePathName);

						if (detailDataBuffer != IntPtr.Zero)

						{

							// Free the memory allocated previously by AllocHGlobal.

							Marshal.FreeHGlobal(detailDataBuffer);

						}

						deviceFound = true;

					}

					memberIndex = memberIndex + 1;

				}

				while (!lastDevice);

				return deviceFound;

			}

			finally

			{

				// ***

				//  API function

				//  summary

				//  Frees the memory reserved for the DeviceInfoSet returned by SetupDiGetClassDevs.

				//  parameters

				//  DeviceInfoSet returned by SetupDiGetClassDevs.

				//  returns

				//  True on success.

				// ***

				if (deviceInfoSet != IntPtr.Zero)

				{

					NativeMethods.SetupDiDestroyDeviceInfoList(deviceInfoSet);

				}

			}

		}

	}

}