// The following code was taken from here: http://www.gamedev.net/community/forums/topic.asp?topic_id=457783
// and modified for use within Chernobyl. This code is used to generate buffered 
// input on Windows when using XNA since XNA has no buffered input.
// Note that, this code may not work correctly in 64 bit. 
// TODO: test in 64 bit

using System;
using System.Runtime.InteropServices;
using Chernobyl.Collections.Generic.Event;
using Chernobyl.Dependency;
using Chernobyl.Event;
using Chernobyl.Plugin;
using Microsoft.Xna.Framework;

namespace Chernobyl.Input.Xna.Controls.Keyboard
{
    /// <summary>
    /// The class responsible for inject in Keyboard input from Windows.
    /// </summary>
    public class WindowsKeyboardInput : IPlugin
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="WindowsKeyboardInput"/> class.
        /// </summary>
        /// <param name="services">The <see cref="IEventCollection{T}"/> 
        /// instance that gives and takes services.</param>
        public WindowsKeyboardInput(IEventCollection<object> services)
        {
            services.Inject(this);
        }

        /// <summary>
        /// The XNA <see cref="GameWindow"/> that describes the window.
        /// </summary>
        [Inject]
        public GameWindow Window
        {
            set
            {
                _hookProcDelegate = new WndProc(HookProc);
                _prevWndProc = (IntPtr)SetWindowLong(value.Handle, GWL_WNDPROC,
                    (int)Marshal.GetFunctionPointerForDelegate(_hookProcDelegate));

                _hImc = ImmGetContext(value.Handle);
            }
        }

        /// <summary>
        /// The services provided by this plug-in or null if no services are
        /// provided.
        /// </summary>
        public IEventCollection<object> Services { get; private set; }

        /// <summary>
        /// An event that is raised when a character has been entered.
        /// </summary>
        public event EventHandler<CharacterEventArgs> CharEntered;

        /// <summary>
        /// A delegate that defines the Window's procedure used to received all 
        /// Input directed at a window.
        /// </summary>
        delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

        /// <summary>
        /// This function retrieves the input context associated with the 
        /// specified window. See 
        /// http://msdn.microsoft.com/en-us/library/aa913345.aspx for more 
        /// information.
        /// </summary>
        /// <param name="hWnd">Handle to the window to retrieve the input 
        /// context for.</param>
        /// <returns>The handle to the input context indicates success.</returns>
        [DllImport("Imm32.dll")]
        static extern IntPtr ImmGetContext(IntPtr hWnd);

        /// <summary>
        /// Associates the specified input context with the specified window. 
        /// By default, the operating system associates the default input context 
        /// with each window as it is created. See 
        /// http://msdn.microsoft.com/en-us/library/dd318171%28v=vs.85%29.aspx 
        /// for more information.
        /// </summary>
        /// <param name="hWnd">Handle to the window to associate with the input 
        /// context.</param>
        /// <param name="hImc">Handle to the input context. If hIMC is NULL, the 
        /// function removes any association the window has with an input context. 
        /// Thus IME cannot be used in the window.</param>
        /// <returns>Returns the handle to the input context previously 
        /// associated with the window.</returns>
        [DllImport("Imm32.dll")]
        static extern IntPtr ImmAssociateContext(IntPtr hWnd, IntPtr hImc);

        /// <summary>
        /// Passes message information to the specified window procedure. See 
        /// http://msdn.microsoft.com/en-us/library/ms633571%28v=vs.85%29.aspx 
        /// for more information.
        /// </summary>
        /// <param name="lpPrevWndFunc">The previous window procedure. If this 
        /// value is obtained by calling the GetWindowLong function with the 
        /// nIndex parameter set to GWL_WNDPROC or DWL_DLGPROC, it is actually 
        /// either the address of a window or dialog box procedure, or a special 
        /// internal value meaningful only to 
        /// <see cref="CallWindowProc(IntPtr, IntPtr, uint, IntPtr, IntPtr)"/>.</param>
        /// <param name="hWnd">A handle to the window procedure to receive the 
        /// message. </param>
        /// <param name="msg">The message.</param>
        /// <param name="wParam">Additional message-specific information. The 
        /// contents of this parameter depend on the value of the Msg parameter. </param>
        /// <param name="lParam">Additional message-specific information. The 
        /// contents of this parameter depend on the value of the Msg parameter. </param>
        /// <returns></returns>
        [DllImport("user32.dll")]
        static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

        /// <summary>
        /// Changes an attribute of the specified window. The function also sets
        /// the 32-bit (long) value at the specified offset into the extra window 
        /// memory. Fore more information, see 
        /// http://msdn.microsoft.com/en-us/library/ms633591%28v=vs.85%29.aspx
        /// </summary>
        /// <param name="hWnd">A handle to the window and, indirectly, the class 
        /// to which the window belongs.</param>
        /// <param name="nIndex">The zero-based offset to the value to be set. 
        /// Valid values are in the range zero through the number of bytes of 
        /// extra window memory, minus the size of an integer. To set any other 
        /// value, specify one of the following values. </param>
        /// <param name="dwNewLong">The replacement value.</param>
        /// <returns>If the function succeeds, the return value is the previous 
        /// value of the specified 32-bit integer. If the function fails, the 
        /// return value is zero. To get extended error information, call 
        /// GetLastError. If the previous value of the specified 32-bit integer 
        /// is zero, and the function succeeds, the return value is zero, but 
        /// the function does not clear the last error information. This makes 
        /// it difficult to determine success or failure. To deal with this, you 
        /// should clear the last error information by calling SetLastError with 
        /// 0 before calling SetWindowLong. Then, function failure will be 
        /// indicated by a return value of zero and a GetLastError result that 
        /// is nonzero.</returns>
        [DllImport("user32.dll")]
        static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

        /// <summary>
        /// The Window's hook procedure that handles Window's messages. See 
        /// http://msdn.microsoft.com/en-us/library/ms632589%28v=vs.85%29.aspx 
        /// for more information.
        /// </summary>
        /// <param name="hWnd">The handle to the window the message is for.</param>
        /// <param name="msg">The message.</param>
        /// <param name="wParam">Additional message-specific information. The 
        /// contents of this parameter depend on the value of the Msg parameter.</param>
        /// <param name="lParam">Additional message-specific information. The 
        /// contents of this parameter depend on the value of the Msg parameter.</param>
        /// <returns></returns>
        IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)
        {
            IntPtr returnCode = CallWindowProc(_prevWndProc, hWnd, msg, wParam, lParam);

            switch (msg)
            {
                case WM_GETDLGCODE:
                    returnCode = (IntPtr)(returnCode.ToInt32() | DLGC_WANTALLKEYS);
                    break;

                case WM_CHAR:
                    char character = (char)wParam;
                    if (character != VK_ESCAPE && character != VK_BACK)
                    {
                        if (CharEntered != null)
                            CharEntered(null, new CharacterEventArgs(character, lParam.ToInt32()));
                    }
                    break;

                case WM_IME_SETCONTEXT:
                    if (wParam.ToInt32() == 1)
                        ImmAssociateContext(hWnd, _hImc);
                    break;

                case WM_INPUTLANGCHANGE:
                    ImmAssociateContext(hWnd, _hImc);
                    returnCode = (IntPtr)1;
                    break;
            }

            return returnCode;
        }

        /// <summary>
        /// The previous windows messaging procedure before we set our custom 
        /// window procedure, <see cref="_hookProcDelegate"/>.
        /// </summary>
        IntPtr _prevWndProc;

        /// <summary>
        /// Our custom windows procedure.
        /// </summary>
        WndProc _hookProcDelegate;

        /// <summary>
        /// The input context for our window.
        /// </summary>
        IntPtr _hImc;

// ReSharper disable InconsistentNaming

        /// <summary>
        /// For more information, see 
        /// http://msdn.microsoft.com/en-us/library/ms633591%28v=vs.85%29.aspx
        /// </summary>
        const int GWL_WNDPROC = -4;

        /// <summary>
        /// For more information, 
        /// see http://msdn.microsoft.com/en-us/library/ms646276%28v=vs.85%29.aspx 
        /// </summary>
        const int WM_CHAR = 0x102;

        /// <summary>
        /// For more information, 
        /// see http://msdn.microsoft.com/en-us/library/aa915455.aspx
        /// </summary>
        const int WM_IME_SETCONTEXT = 0x0281;

        /// <summary>
        /// For more information, 
        /// see http://msdn.microsoft.com/en-us/library/ms632629%28v=vs.85%29.aspx
        /// </summary>
        const int WM_INPUTLANGCHANGE = 0x51;

        /// <summary>
        /// For more information, 
        /// see http://msdn.microsoft.com/en-us/library/ms645425%28v=vs.85%29.aspx
        /// </summary>
        const int WM_GETDLGCODE = 0x87;

        /// <summary>
        /// For more information, 
        /// see http://msdn.microsoft.com/en-us/library/dd374133%28v=vs.85%29.aspx
        /// </summary>
        const int WM_IME_COMPOSITION = 0x10f;

        /// <summary>
        /// For more information, 
        /// see http://support.microsoft.com/kb/83302
        /// </summary>
        const int DLGC_WANTALLKEYS = 4;

        /// <summary>
        /// The virtual-key code for the escape key.
        /// </summary>
        const int VK_ESCAPE = 0x1B;

        /// <summary>
        /// The virtual-key code for the backspace key.
        /// </summary>
        const int VK_BACK = 0x08;
        
// ReSharper restore InconsistentNaming
    }

    /// <summary>
    /// An <see cref="EventArgs"/> class for containing event data on input 
    /// related functionality from the Windows API.
    /// </summary>
    public class CharacterEventArgs : ItemsEventArgs<char>
    {
        /// <summary>
        /// Initializes a new instance of the <see cref="CharacterEventArgs"/> 
        /// class.
        /// </summary>
        /// <param name="character">The keyboard character that was pressed.</param>
        /// <param name="lParam">Extra information on the keyboard character 
        /// that was pressed.</param>
        public CharacterEventArgs(char character, int lParam)
            : base(character)
        {
            _character = character;
            _lParam = lParam;
        }

        /// <summary>
        /// The keyboard character that was pressed.
        /// </summary>
        public char Character
        {
            get { return _character; }
        }

        /// <summary>
        /// Extra information on the keyboard character that was pressed.
        /// </summary>
        public int Param
        {
            get { return _lParam; }
        }

        /// <summary>
        /// The repeat count for the current message. The value is the number of 
        /// times the keystroke is auto-repeated as a result of the user holding 
        /// down the key. If the keystroke is held long enough, multiple messages 
        /// are sent. However, the repeat count is not cumulative.
        /// </summary>
        public int RepeatCount
        {
            get { return _lParam & 0xffff; }
        }

        /// <summary>
        /// Indicates whether the key is an extended key, such as the right-hand 
        /// ALT and CTRL keys that appear on an enhanced 101- or 102-key keyboard. 
        /// The value is true if it is an extended key; otherwise, it is false.
        /// </summary>
        public bool ExtendedKey
        {
            get { return (_lParam & (1 << 24)) > 0; }
        }

        /// <summary>
        /// The context code. The value is true if the ALT key is held down while 
        /// the key is pressed; otherwise, the value is false.
        /// </summary>
        public bool AltPressed
        {
            get { return (_lParam & (1 << 29)) > 0; }
        }

        /// <summary>
        /// The previous key state. The value is true if the key is down before  
        /// the message is sent, or it is false if the key is up.
        /// </summary>
        public bool PreviousState
        {
            get { return (_lParam & (1 << 30)) > 0; }
        }

        /// <summary>
        /// The transition state. The value is true if the key is being released, 
        /// or it is false if the key is being pressed.
        /// </summary>
        public bool TransitionState
        {
            get { return (_lParam & (1 << 31)) > 0; }
        }

        /// <summary>
        /// The keyboard character that was pressed.
        /// </summary>
        readonly char _character;

        /// <summary>
        /// Extra information on the keyboard character that was pressed.
        /// </summary>
        readonly int _lParam;
    }
}