#pragma region CPL License
/*
Nuclex Native Framework
Copyright (C) 2002-2013 Nuclex Development Labs

This library is free software; you can redistribute it and/or
modify it under the terms of the IBM Common Public License as
published by the IBM Corporation; either version 1.0 of the
License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
IBM Common Public License for more details.

You should have received a copy of the IBM Common Public
License along with this library
*/
#pragma endregion // CPL License

#ifndef NUCLEX_INPUT_DEVICES_WINDOWMESSAGEMOUSE_H
#define NUCLEX_INPUT_DEVICES_WINDOWMESSAGEMOUSE_H

#include "../Buffered/BufferedMouse.h"

#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#include <windows.h>

namespace Nuclex { namespace Input { namespace Devices {

  // ------------------------------------------------------------------------------------------- //

  /// <summary>Mouse that listens in on window messages</summary>
  class WindowMessageMouse : public BufferedMouse {

    /// <summary>Initializes a new window message based mouse</summary>
    /// <param name="windowHandle">Handle of the game's main window</param>
    public: WindowMessageMouse(HWND windowHandle);

    /// <summary>Frees all resources used by the window message based mouse</summary>
    public: virtual ~WindowMessageMouse();

    /// <summary>Updates the mouse's state in accordance to a window message</summary>
    /// <param name="message">Type of message being sent to the window</param>
    /// <param name="parameter1">First message-dependent parameter</param>
    /// <param name="parameter2">Second message-dependent parameter</param>
    /// <returns>True if the message was consumed, false if not</returns>
    public: bool ProcessWindowMessage(UINT message, WPARAM parameter1, LPARAM parameter2);

    /// <summary>Locks the mouse cursor to the window for FPS control</summary>
    /// <param name="locked">Whether to lock the mouse cursor to the window</param>
    public: void SetLocked(bool locked = true);

    /// <summary>Whether the mouse cursor is currently locked to the window</summary>
    /// <returns>True if the mouse cursor is locked to the window, otherwise false</returns>
    public: bool IsLocked() const { return this->isLocked; }

    /// <summary>Whether the input device is currently attached</summary>
    /// <returns>True if the input device is attached, otherwise false</returns>
    public: bool IsAttached() const { return true; }

    /// <summary>Retrieves the human-readable name of the input device</summary>
    /// <returns>The human-readable name of the input device</returns>
    public: const std::string &GetName() const;

    /// <summary>Called when the window gains or loses the focus</summary>
    /// <param name="activationAction">Describes what has happened to the window</param>
    private: void windowActivationStateChanged(WORD activationAction);

    /// <summary>Processes raw input delivered to the process</summary>
    /// <param name="rawInputHandle">Handle for the raw input being delivered</param>
    private: void processRawInput(HRAWINPUT rawInputHandle);

    /// <summary>Registers the window to receive raw input messages</summary>
    private: void registerForRawInput();

    /// <summary>Called the mouseMoved() method if the cursor position has changed</summary>
    /// <param name="parameter">Contains the X and Y coordinate of the mouse</param>
    private: void callMouseMovedIfPositionChanged(LPARAM parameter);

    /// <summary>Determines whether the mouse cursor is restricted currently</summary>
    /// <returns>True if the mouse cursor is restricted, false otherwise</returns>
    private: bool isMouseRestricted() const;

    /// <summary>Restricts the movement of the mouse cursor to the client area</summary>
    private: void restrictMouse();

    /// <summary>Lets the mouse move across the whole screen again</summary>
    private: void freeMouse();

    /// <summary>Begins tracking the mouse cursor for when it leaves the window</summary>
    private: void startTrackingMouseLeave();

    /// <summary>Stops tracking the mouse cursor for when it leaves the window</summary>
    /// <param name="throwOnError">Whether to throw an exception when the method fails</param>
    private: void stopTrackingMouseLeave(bool throwOnError = true);
    
    /// <summary>Determines a window's client area in screen coordinates</summary>
    /// <returns>A rectangle containing the bounds of the window's client area</returns>
    private: void updateClientRectangleInScreenCoordinates();

    private: WindowMessageMouse(const WindowMessageMouse &);
    private: WindowMessageMouse &operator =(const WindowMessageMouse &);

    /// <summary>Handle of the game's main window</summary>
    private: HWND windowHandle;
    /// <summary>The current client rectangle of the window in screen coordinates</summary>
    private: RECT clientRectangleInScreenCoordinates;
    /// <summary>Used to be notified when the mouse leaves the client area</summary>
    private: TRACKMOUSEEVENT trackMouseEvent;
    /// <summary>Whether the user wants the mouse to be locked direct motion control</summary>
    private: bool isLocked;
    /// <summary>Whether the game's main window has the focus</summary>
    private: bool hasFocus;
    /// <summary>Whether the window is currently dealing with the menu loop</summary>
    private: bool isInsideMenuLoop;
    /// <summary>Whether the mouse is currently being tracked by the window</summary>
    private: bool isTrackingMouse;
    /// <summary>Whether the mouse cursor is inside the window's client area</summary>
    private: bool isMouseInsideClientArea;
    /// <summary>Last known X coordinate of the mouse cursor</summary>
    private: int lastKnownMouseX;
    /// <summary>Last known Y coordinate of the mouse cursor</summary>
    private: int lastKnownMouseY;

  };

  // ------------------------------------------------------------------------------------------- //

}}} // namespace Nuclex::Input::Devices

#endif // NUCLEX_INPUT_DEVICES_WINDOWMESSAGEMOUSE_H