using System;

 using System.Windows.Forms;

 using System.Runtime.InteropServices;

 using System.Diagnostics;

 using System.Text;

 using Microsoft.Win32.SafeHandles;

 using Win32;

 using System.Collections.Generic;

 using System.Timers;

 namespace Hid

 {

     /// <summary>

     /// We provide utility functions to interpret gamepad dpad state.

     /// </summary>

     public enum DirectionPadState

     {

         Rest=-1,

         Up=0,

         UpRight=1,

         Right=2,

         DownRight=3,

         Down=4,

         DownLeft=5,

         Left=6,

         UpLeft=7

     }

     /// <summary>

     /// Represent a HID event.

     /// TODO: Rename this into HidRawInput?

     /// </summary>

     public class HidEvent : IDisposable

     {

         public bool IsValid { get; private set; }

         public bool IsForeground { get; private set; }

         public bool IsBackground { get { return !IsForeground; } }

         public bool IsMouse { get; private set; }

         public bool IsKeyboard { get; private set; }

         /// <summary>

         /// If this not a mouse or keyboard event then it's a generic HID event.

         /// </summary>

         public bool IsGeneric { get; private set; }

         public bool IsButtonDown { get { return Usages.Count == 1 && Usages[0] != 0; } }

         public bool IsButtonUp { get { return Usages.Count == 0; } }

         public bool IsRepeat { get { return RepeatCount != 0; } }

         public uint RepeatCount { get; private set; }

         public HidDevice Device { get; private set; }

         public RAWINPUT RawInput { get {return iRawInput;} } 

         private RAWINPUT iRawInput;

         public ushort UsagePage { get; private set; }

         public ushort UsageCollection { get; private set; }

         public uint UsageId { get { return ((uint)UsagePage << 16 | (uint)UsageCollection); } }

         public List<ushort> Usages { get; private set; }

         /// <summary>

         /// Sorted in the same order as Device.InputValueCapabilities.

         /// </summary>

         public Dictionary<HIDP_VALUE_CAPS,uint> UsageValues { get; private set; }

         //TODO: We need a collection of input report

         public byte[] InputReport { get; private set; }

         //

         public delegate void HidEventRepeatDelegate(HidEvent aHidEvent);

         public event HidEventRepeatDelegate OnHidEventRepeat;

         private System.Timers.Timer Timer { get; set; }

         public DateTime Time { get; private set; }

         public DateTime OriginalTime { get; private set; }

         //Compute repeat delay and speed based on system settings

         //Those computations were taken from the Petzold here: ftp://ftp.charlespetzold.com/ProgWinForms/4%20Custom%20Controls/NumericScan/NumericScan/ClickmaticButton.cs

         private int iRepeatDelay = 250 * (1 + SystemInformation.KeyboardDelay);

         private int iRepeatSpeed = 405 - 12 * SystemInformation.KeyboardSpeed;

         /// <summary>

         /// Tells whether this event has already been disposed of.

         /// </summary>

         public bool IsStray { get { return Timer == null; } }

         /// <summary>

         /// We typically dispose of events as soon as we get the corresponding key up signal.

         /// </summary>

         public void Dispose()

         {

             Timer.Enabled = false;

             Timer.Dispose();

             //Mark this event as a stray

             Timer = null;

         }

         /// <summary>

         /// Initialize an HidEvent from a WM_INPUT message

         /// </summary>

         /// <param name="hRawInputDevice">Device Handle as provided by RAWINPUTHEADER.hDevice, typically accessed as rawinput.header.hDevice</param>

         public HidEvent(Message aMessage, HidEventRepeatDelegate aRepeatDelegate)

         {

             RepeatCount = 0;

             IsValid = false;

             IsKeyboard = false;

             IsGeneric = false;

             Time = DateTime.Now;

             OriginalTime = DateTime.Now;

             Timer = new System.Timers.Timer();

             Timer.Elapsed += (sender, e) => OnRepeatTimerElapsed(sender, e, this);

             Usages = new List<ushort>();

             UsageValues = new Dictionary<HIDP_VALUE_CAPS,uint>();

             OnHidEventRepeat += aRepeatDelegate;

             if (aMessage.Msg != Const.WM_INPUT)

             {

                 //Has to be a WM_INPUT message

                 return;

             }

             if (Macro.GET_RAWINPUT_CODE_WPARAM(aMessage.WParam) == Const.RIM_INPUT)

             {

                 IsForeground = true;

             }

             else if (Macro.GET_RAWINPUT_CODE_WPARAM(aMessage.WParam) == Const.RIM_INPUTSINK)

             {

                 IsForeground = false;

             }

             //Declare some pointers

             IntPtr rawInputBuffer = IntPtr.Zero;

             try

             {

                 //Fetch raw input

                 iRawInput = new RAWINPUT();

                 if (!Win32.RawInput.GetRawInputData(aMessage.LParam, ref iRawInput, ref rawInputBuffer))

                 {

                     Debug.WriteLine("GetRawInputData failed!");

                     return;

                 }

                 //Our device can actually be null.

                 //This is notably happening for some keyboard events

                 if (RawInput.header.hDevice != IntPtr.Zero)

                 {

                     //Get various information about this HID device

                     Device = new Hid.HidDevice(RawInput.header.hDevice);

                 }

                 if (RawInput.header.dwType == Win32.RawInputDeviceType.RIM_TYPEHID)  //Check that our raw input is HID                        

                 {

                     IsGeneric = true;

                     Debug.WriteLine("WM_INPUT source device is HID.");

                     //Get Usage Page and Usage

                     //Debug.WriteLine("Usage Page: 0x" + deviceInfo.hid.usUsagePage.ToString("X4") + " Usage ID: 0x" + deviceInfo.hid.usUsage.ToString("X4"));

                     UsagePage = Device.Info.hid.usUsagePage;

                     UsageCollection = Device.Info.hid.usUsage;

                     if (!(RawInput.hid.dwSizeHid > 1     //Make sure our HID msg size more than 1. In fact the first ushort is irrelevant to us for now

                         && RawInput.hid.dwCount > 0))    //Check that we have at least one HID msg

                     {

                         return;

                     }

                     //Allocate a buffer for one HID input

                     InputReport = new byte[RawInput.hid.dwSizeHid];

                     Debug.WriteLine("Raw input contains " + RawInput.hid.dwCount + " HID input report(s)");

                     //For each HID input report in our raw input

                     for (int i = 0; i < RawInput.hid.dwCount; i++)

                     {

                         //Compute the address from which to copy our HID input

                         int hidInputOffset = 0;

                         unsafe

                         {

                             byte* source = (byte*)rawInputBuffer;

                             source += sizeof(RAWINPUTHEADER) + sizeof(RAWHID) + (RawInput.hid.dwSizeHid * i);

                             hidInputOffset = (int)source;

                         }

                         //Copy HID input into our buffer

                         Marshal.Copy(new IntPtr(hidInputOffset), InputReport, 0, (int)RawInput.hid.dwSizeHid);

                         //

                         ProcessInputReport(InputReport);

                     }

                 }

                 else if (RawInput.header.dwType == RawInputDeviceType.RIM_TYPEMOUSE)

                 {

                     IsMouse = true;

                     Debug.WriteLine("WM_INPUT source device is Mouse.");

                     // do mouse handling...

                 }

                 else if (RawInput.header.dwType == RawInputDeviceType.RIM_TYPEKEYBOARD)

                 {

                     IsKeyboard = true;

                     Debug.WriteLine("WM_INPUT source device is Keyboard.");

                     // do keyboard handling...

                     if (Device != null)

                     {

                         Debug.WriteLine("Type: " + Device.Info.keyboard.dwType.ToString());

                         Debug.WriteLine("SubType: " + Device.Info.keyboard.dwSubType.ToString());

                         Debug.WriteLine("Mode: " + Device.Info.keyboard.dwKeyboardMode.ToString());

                         Debug.WriteLine("Number of function keys: " + Device.Info.keyboard.dwNumberOfFunctionKeys.ToString());

                         Debug.WriteLine("Number of indicators: " + Device.Info.keyboard.dwNumberOfIndicators.ToString());

                         Debug.WriteLine("Number of keys total: " + Device.Info.keyboard.dwNumberOfKeysTotal.ToString());

                     }

                 }

             }

             finally

             {

                 //Always executed when leaving our try block

                 Marshal.FreeHGlobal(rawInputBuffer);

             }

             //

             if (IsButtonDown)

             {

                 //TODO: Make this optional

                 //StartRepeatTimer(iRepeatDelay);

             }

             IsValid = true;

         }

         /// <summary>

         /// 

         /// </summary>

         private void ProcessInputReport(byte[] aInputReport)

         {

             //Print HID input report in our debug output

             //string hidDump = "HID input report: " + InputReportString();

             //Debug.WriteLine(hidDump);

             //Get all our usages, those are typically the buttons currently pushed on a gamepad.

             //For a remote control it's usually just the one button that was pushed.

             GetUsages(aInputReport);

             //Now process direction pad (d-pad, dpad) and axes

             GetUsageValues(aInputReport);

         }

         /// <summary>

         /// Typically fetches values of a joystick/gamepad axis and dpad directions.

         /// </summary>

         /// <param name="aInputReport"></param>

         private void GetUsageValues(byte[] aInputReport)

         {

             if (Device.InputValueCapabilities == null)

             {

                 return;

             }

             foreach (HIDP_VALUE_CAPS caps in Device.InputValueCapabilities)

             {                

                 if (caps.IsRange)

                 {

                     //What should we do with those guys?

                     continue;

                 }

                 //Now fetch and add our usage value

                 uint usageValue = 0;

                 Win32.HidStatus status = Win32.Function.HidP_GetUsageValue(Win32.HIDP_REPORT_TYPE.HidP_Input, caps.UsagePage, caps.LinkCollection, caps.NotRange.Usage, ref usageValue, Device.PreParsedData, aInputReport, (uint)aInputReport.Length);

                 if (status == Win32.HidStatus.HIDP_STATUS_SUCCESS)

                 {

                     UsageValues[caps]=usageValue;

                 }

             }

         }

         /// <summary>

         /// Get all our usages, those are typically the buttons currently pushed on a gamepad.

         /// For a remote control it's usually just the one button that was pushed.

         /// </summary>

         private void GetUsages(byte[] aInputReport)

         {

             //Do proper parsing of our HID report

             //First query our usage count

             uint usageCount = 0;

             Win32.USAGE_AND_PAGE[] usages = null;

             Win32.HidStatus status = Win32.Function.HidP_GetUsagesEx(Win32.HIDP_REPORT_TYPE.HidP_Input, 0, usages, ref usageCount, Device.PreParsedData, aInputReport, (uint)aInputReport.Length);

             if (status == Win32.HidStatus.HIDP_STATUS_BUFFER_TOO_SMALL)

             {

                 //Allocate a large enough buffer 

                 usages = new Win32.USAGE_AND_PAGE[usageCount];

                 //...and fetch our usages

                 status = Win32.Function.HidP_GetUsagesEx(Win32.HIDP_REPORT_TYPE.HidP_Input, 0, usages, ref usageCount, Device.PreParsedData, aInputReport, (uint)aInputReport.Length);

                 if (status != Win32.HidStatus.HIDP_STATUS_SUCCESS)

                 {

                     Debug.WriteLine("Second pass could not parse HID data: " + status.ToString());

                 }

             }

             else if (status != Win32.HidStatus.HIDP_STATUS_SUCCESS)

             {

                 Debug.WriteLine("First pass could not parse HID data: " + status.ToString());

             }

             Debug.WriteLine("Usage count: " + usageCount.ToString());

             //Copy usages into this event

             if (usages != null)

             {

                 foreach (USAGE_AND_PAGE up in usages)

                 {

                     //Debug.WriteLine("UsagePage: 0x" + usages[0].UsagePage.ToString("X4"));

                     //Debug.WriteLine("Usage: 0x" + usages[0].Usage.ToString("X4"));

                     //Add this usage to our list

                     Usages.Add(up.Usage);

                 }

             }

         }

         /// <summary>

         /// 

         /// </summary>

         /// <param name="aUsagePage"></param>

         /// <param name="Usage"></param>

         /// <returns></returns>

         public uint GetUsageValue(ushort aUsagePage, ushort aUsage)

         {

             foreach (HIDP_VALUE_CAPS caps in Device.InputValueCapabilities)

             {                

                 if (caps.IsRange)

                 {

                     //What should we do with those guys?

                     continue;

                 }

                 //Check if we have a match

                 if (caps.UsagePage == aUsagePage && caps.NotRange.Usage == aUsage)

                 {

                     return UsageValues[caps];

                 }

             }

             return 0;

         }

         /// <summary>

         /// 

         /// </summary>

         /// <param name="aUsagePage"></param>

         /// <param name="aUsage"></param>

         /// <returns></returns>

         public int GetValueCapabilitiesIndex(ushort aUsagePage, ushort aUsage)

         {

             int i = -1;

             foreach (HIDP_VALUE_CAPS caps in Device.InputValueCapabilities)

             {

                 i++;

                 if (caps.IsRange)

                 {

                     //What should we do with those guys?

                     continue;

                 }

                 //Check if we have a match

                 if (caps.UsagePage == aUsagePage && caps.NotRange.Usage == aUsage)

                 {

                     return i;

                 }

             }

             return i;

         }        

         /// <summary>

         /// TODO: Move this to another level?

         /// </summary>

         /// <param name="aInterval"></param>

         public void StartRepeatTimer(double aInterval)

         {

             if (Timer == null)

             {

                 return;

             }

             Timer.Enabled = false;

             //Initial delay do not use auto reset

             //After our initial delay however we do setup our timer one more time using auto reset

             Timer.AutoReset = (RepeatCount != 0);

             Timer.Interval = aInterval;

             Timer.Enabled = true;

         }

         static private void OnRepeatTimerElapsed(object sender, ElapsedEventArgs e, HidEvent aHidEvent)

         {

             if (aHidEvent.IsStray)

             {

                 //Skip events if canceled

                 return;

             }

             aHidEvent.RepeatCount++;

             aHidEvent.Time = DateTime.Now;

             if (aHidEvent.RepeatCount == 1)

             {

                 //Re-Start our timer only after the initial delay 

                 aHidEvent.StartRepeatTimer(aHidEvent.iRepeatSpeed);

             }

             //Broadcast our repeat event

             aHidEvent.OnHidEventRepeat(aHidEvent);

         }

         /// <summary>

         /// Provide the state of the dpad or hat switch if any.

         /// If no dpad is found we return 'at rest'.

         /// </summary>

         /// <returns></returns>

         public DirectionPadState GetDirectionPadState()

         {

             int index=GetValueCapabilitiesIndex((ushort)Hid.UsagePage.GenericDesktopControls, (ushort)Hid.Usage.GenericDesktop.HatSwitch);

             if (index < 0)

             {

                 //No hat switch found

                 return DirectionPadState.Rest;

             }

             HIDP_VALUE_CAPS caps=Device.InputValueCapabilities[index];

             if (caps.IsRange)

             {

                 //Defensive

                 return DirectionPadState.Rest;

             }

             uint dpadUsageValue = UsageValues[caps]; 

             if (dpadUsageValue < caps.LogicalMin || dpadUsageValue > caps.LogicalMax)

             {

                 //Out of range means at rest

                 return DirectionPadState.Rest;

             }

             //Normalize value to start at zero

             //TODO: more error check here?

             DirectionPadState res = (DirectionPadState)((int)dpadUsageValue - caps.LogicalMin);            

             return res;

         }

         /// <summary>

         /// Print information about this device to our debug output.

         /// </summary>

         public void DebugWrite()

         {

             if (!IsValid)

             {

                 Debug.WriteLine("==== Invalid HidEvent");

                 return;

             }

             if (Device!=null)

             {

                 Device.DebugWrite();

             }

             if (IsGeneric) Debug.WriteLine("==== Generic");

             if (IsKeyboard) Debug.WriteLine("==== Keyboard");

             if (IsMouse) Debug.WriteLine("==== Mouse");

             Debug.WriteLine("==== Foreground: " + IsForeground.ToString());

             Debug.WriteLine("==== UsagePage: 0x" + UsagePage.ToString("X4"));

             Debug.WriteLine("==== UsageCollection: 0x" + UsageCollection.ToString("X4"));

             Debug.WriteLine("==== InputReport: 0x" + InputReportString());

             foreach (ushort usage in Usages)

             {

                 Debug.WriteLine("==== Usage: 0x" + usage.ToString("X4"));

             }

         }

         /// <summary>

         /// 

         /// </summary>

         /// <returns></returns>

         public string InputReportString()

         {

             if (InputReport == null)

             {

                 return "null";

             }

             string hidDump = "";

             foreach (byte b in InputReport)

             {

                 hidDump += b.ToString("X2");

             }

             return hidDump;

         }

         /// <summary>

         /// Create a list view item describing this HidEvent

         /// </summary>

         /// <returns></returns>

         public ListViewItem ToListViewItem()

         {

             string usageText = "";

             foreach (ushort usage in Usages)

             {

                 if (usageText != "")

                 {

                     //Add a separator

                     usageText += ", ";

                 }

                 UsagePage usagePage = (UsagePage)UsagePage;

                 switch (usagePage)

                 {

                     case Hid.UsagePage.Consumer:

                         usageText += ((Hid.Usage.ConsumerControl)usage).ToString();

                         break;

                     case Hid.UsagePage.WindowsMediaCenterRemoteControl:

                         usageText += ((Hid.Usage.WindowsMediaCenterRemoteControl)usage).ToString();

                         break;

                     default:

                         usageText += usage.ToString("X2");

                         break;

                 }

             }

             //If we are a gamepad display axis and dpad values

             if (Device.IsGamePad)

             {

                 //uint dpadUsageValue = GetUsageValue((ushort)Hid.UsagePage.GenericDesktopControls, (ushort)Hid.Usage.GenericDesktop.HatSwitch);

                 //usageText = dpadUsageValue.ToString("X") + " (dpad), " + usageText;

                 if (usageText != "")

                 {

                     //Add a separator

                     usageText += " (Buttons)";

                 }

                 if (usageText != "")

                 {

                     //Add a separator

                     usageText += ", ";

                 }

                 usageText += GetDirectionPadState().ToString();

                 foreach (KeyValuePair<HIDP_VALUE_CAPS, uint> entry in UsageValues)

                 {

                     if (entry.Key.IsRange)

                     {

                         continue;

                     }

                     Type usageType = Utils.UsageType((UsagePage)entry.Key.UsagePage);

                     if (usageType == null)

                     {

                         //TODO: check why this is happening on Logitech rumble gamepad 2.

                         //Probably some of our axis are hiding in there.

                         continue;

                     }

                     string name = Enum.GetName(usageType, entry.Key.NotRange.Usage);

                     if (usageText != "")

                     {

                         //Add a separator

                         usageText += ", ";

                     }

                     usageText += entry.Value.ToString("X") + " ("+ name +")";        

                 }

             }

             //Now create our list item

             ListViewItem item = new ListViewItem(new[] { usageText, InputReportString(), UsagePage.ToString("X2"), UsageCollection.ToString("X2"), RepeatCount.ToString(), Time.ToString("HH:mm:ss:fff") });

             return item;

         }

     }

 }