using System;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Threading;
using System.Windows.Input;


namespace libWin32.Win32.Input
{
    public class InputSender
    {

        public const int KEYUP_WAIT_TIME = 0;

        #region INPUTTYPE CONSTANTS
        public const uint INPUT_MOUSE = 0x0;
        public const int INPUT_KEYBOARD = 0x1;
        public const int INPUT_HARDWARE = 0x2;
        #endregion
        #region KEYEVENTF CONSTANTS
        public const uint KEYEVENTF_EXTENDEDKEY = 0x1;
        public const uint KEYEVENTF_KEYDOWN = 0x0;
        public const uint KEYEVENTF_KEYUP = 0x2;
        public const uint KEYEVENTF_UNICODE = 0x4;
        public const uint KEYEVENTF_SCANCODE = 0x8;
        #endregion
        #region XBUTTON CONSTANTS
        public const uint XBUTTON1 = 0x1;
        public const uint XBUTTON2 = 0x2;
        #endregion
        #region MOUSEEVENTF CONSTANTS
        public const uint MOUSEEVENTF_MOVE = 0x1;
        public const uint MOUSEEVENTF_LEFTDOWN = 0x2;
        public const uint MOUSEEVENTF_LEFTUP = 0x4;
        public const uint MOUSEEVENTF_RIGHTDOWN = 0x8;
        public const uint MOUSEEVENTF_RIGHTUP = 0x10;
        public const uint MOUSEEVENTF_MIDDLEDOWN = 0x20;
        public const uint MOUSEEVENTF_MIDDLEUP = 0x40;
        public const uint MOUSEEVENTF_XDOWN = 0x80;
        public const uint MOUSEEVENTF_XUP = 0x100;
        public const uint MOUSEEVENTF_WHEEL = 0x800;
        public const uint MOUSEEVENTF_VIRTUALDESK = 0x4000;
        public const uint MOUSEEVENTF_ABSOLUTE = 0x8000;
        #endregion

        [StructLayout(LayoutKind.Explicit)]
        struct INPUT
        {
            [FieldOffset(0)]
            public int dwType;
            [FieldOffset(4)]
            public MOUSEINPUT mouseInput;
            [FieldOffset(4)]
            public KEYBDINPUT keyboardInput;
            [FieldOffset(4)]
            public HARDWAREINPUT hardwareInput;
        }
        [StructLayout(LayoutKind.Explicit)]
        struct KEYBDINPUT
        {
            [FieldOffset(0)]
            public short wVk;
            [FieldOffset(2)]
            public short wScan;
            [FieldOffset(4)]
            public uint dwFlags;
            [FieldOffset(8)]
            public int time;
            [FieldOffset(12)]
            public IntPtr dwExtraInfo;
        }
        [StructLayout(LayoutKind.Explicit)]
        struct HARDWAREINPUT
        {
            [FieldOffset(0)]
            public int uMsg;
            [FieldOffset(4)]
            public short wParamL;
            [FieldOffset(6)]
            public short wParamH;
        }
        /// <summary>
        /// The mouse data structure
        /// </summary>
        [StructLayout(LayoutKind.Explicit)]
        struct MOUSEINPUT
        {
            [FieldOffset(0)]
            public int dx;
            [FieldOffset(4)]
            public int dy;
            [FieldOffset(8)]
            public int mouseData;
            [FieldOffset(12)]
            public int dwFlags;
            [FieldOffset(16)]
            public int time;
            [FieldOffset(20)]
            public IntPtr dwExtraInfo;
        }

        [DllImport("user32.dll")]
        static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo);
        [DllImport("user32.dll", SetLastError = true)]
        static extern uint SendInput(uint nInputs, ref INPUT pInputs, int cbSize);
        [DllImport("user32.dll")]
        static extern bool BlockInput(bool fBlockIt);

        public void BlockUserInput() { BlockInput(true); }
        public void UnBlockUserInput() { BlockInput(false); }


        public static bool isExtendedVKKey(Key VKKey)
        {
            if (VKKey == Key.Insert || VKKey == Key.Left || VKKey == Key.Home || VKKey == Key.End ||
                VKKey == Key.Up || VKKey == Key.Down || VKKey == Key.PageUp || VKKey == Key.PageDown || VKKey == Key.Right)
            {
                return true;
            }
            return false;

        }
        public static bool isExtendedScanCode(short ScanCode)
        {
            DXKeysToScanCodes t = (DXKeysToScanCodes)ScanCode;
            if (ScanCode == 0)
                t = DXKeysToScanCodes.DIK_UNKOWN;
            if (t == DXKeysToScanCodes.DIK_UP ||
                 t == DXKeysToScanCodes.DIK_DOWN ||
                 t == DXKeysToScanCodes.DIK_LEFT ||
                 t == DXKeysToScanCodes.DIK_RIGHT ||
                 t == DXKeysToScanCodes.DIK_HOME ||
                 t == DXKeysToScanCodes.DIK_END ||
                 t == DXKeysToScanCodes.DIK_NUMPADENTER ||
                 t == DXKeysToScanCodes.DIK_RCONTROL ||
                 t == DXKeysToScanCodes.DIK_RMENU ||
                 t == DXKeysToScanCodes.DIK_LEFT ||
                 t == DXKeysToScanCodes.DIK_PRIOR ||
                 t == DXKeysToScanCodes.DIK_NEXT ||
                 t == DXKeysToScanCodes.DIK_INSERT ||
                 t == DXKeysToScanCodes.DIK_DELETE)
            {
                return true;
            }
            return false; 
        }
        static void DXKeyDown(short DXScanCode)
        {
            INPUT inputs = new INPUT();
            inputs.dwType = INPUT_KEYBOARD;

            if (isExtendedScanCode(DXScanCode))
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYDOWN | KEYEVENTF_EXTENDEDKEY;
            }
            else
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYDOWN;
            }


            inputs.keyboardInput.wScan = DXScanCode;
            int cbSize = Marshal.SizeOf(typeof(INPUT));
            SendInput(1, ref inputs, cbSize);
        }
        static void DXKeyUp(short DXScanCode, TimeSpan wait)
        {
            if (wait.TotalMilliseconds > 0)
                Thread.Sleep(wait);

            INPUT inputs = new INPUT();
            inputs.dwType = INPUT_KEYBOARD;
            if (isExtendedScanCode(DXScanCode))
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP | KEYEVENTF_EXTENDEDKEY;
            }
            else
            {
                inputs.keyboardInput.dwFlags = KEYEVENTF_SCANCODE | KEYEVENTF_KEYUP;
            }
            inputs.keyboardInput.wScan = DXScanCode;
            int cbSize = Marshal.SizeOf(typeof(INPUT));
            SendInput(1, ref inputs, cbSize);
        }

        public static void SendDXKey(short DXKey)
        {
            PressDXKey(DXKey);
        }
        public static void SendDXKey(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                PressDXKey(DXKey);
            }
        }
        public static void PressDXKey(short DXKey)
        {
            DXKeyDown((short)DXKey);
            DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(250));
        }
        public static void PressDXKey(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                DXKeyDown((short)DXKey);
                DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(250));
            }
        }

        public static void PressDXKey_NoRelease(short DXKey)
        {
            DXKeyDown((short)DXKey);
            //DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
        }
        public static void PressDXKey_NoRelease(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                DXKeyDown((short)DXKey);
                //DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
            }
        }
        public static void ReleaseDXKey(short DXKey)
        {
            //DXKeyDown((short)DXKey);
            DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
        }
        public static void ReleaseDXKey(List<short> DXKeys)
        {
            foreach (short DXKey in DXKeys)
            {
                //DXKeyDown((short)DXKey);
                DXKeyUp((short)DXKey, TimeSpan.FromMilliseconds(KEYUP_WAIT_TIME));
            }
        }
    }
}