#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_BUFFEREDMOUSE_H
#define NUCLEX_INPUT_DEVICES_BUFFEREDMOUSE_H

#include "Nuclex/Input/Devices/Mouse.h"
#include "../../ConcurrentQueue.h"

namespace Nuclex { namespace Input { namespace Devices {

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

  /// <summary>Mouse that buffers changes until an Update call happens</summary>
  class BufferedMouse : public Mouse {

    /// <summary>A snapshot has been recorded</summary>
    private: static const int SnapshotNotification = 0;
    /// <summary>Mouse button has been pressed</summary>
    private: static const int ButtonPressNotification = 1;
    /// <summary>Mouse button has been pressed</summary>
    private: static const int ButtonReleaseNotification = 2;
    /// <summary>Mouse cursor has been moved</summary>
    private: static const int CursorMoveNotification = 3;
    /// <summary>Mouse has been moved</summary>
    private: static const int MoveNotification = 4;
    /// <summary>Mouse wheel has been rotated</summary>
    private: static const int WheelRotationNotification = 5;

    #pragma region struct Event

    /// <summary>Stores a buffered change notification</summary>
    private: struct Event {

      /// <summary>Type of event that has been recorded</summary>
      public: int Type;

      union {
        /// <summary>Button that has been pressed or released</summary>
        public: MouseButtons::Enum PressedOrReleasedButtons;
        /// <summary>Absolute position of the mouse cursor</summary>
        struct {
          /// <summary>X coordinate of the mouse cursor</summary>
          public: int X;
          /// <summary>Y coordinate of the mouse cursor</summary>
          public: int Y;
        } Position;
        /// <summary>Relative movement of the mouse</summary>
        struct {
          /// <summary>Amount the mouse was moved on the X axis</summary>
          public: float DeltaX;
          /// <summary>Amount the mouse was moved on the Y axis</summary>
          public: float DeltaY;
        } Movement;
        /// <summary>Amount the mouse wheel has been rotated</summary>
        public: float WheelDelta;
      } State;
    };

    #pragma endregion // struct Event

    /// <summary>Initializes a new buffered mouse</summary>
    protected: BufferedMouse() {}
    /// <summary>Frees all resources owned by the buffered mouse</summary>
    public: virtual ~BufferedMouse() {}

    /// <summary>Retrieves the current state of the input device</summary>
    /// <returns>The input device's current state</returns>
    public: virtual const MouseState &GetState() const {
      return this->currentState;
    }

    /// <summary>Buffers a button press notification</summary>
    /// <param name="pressedButton">Button that has been pressed</param>
    protected: void BufferButtonPress(MouseButtons::Enum pressedButton);
    /// <summary>Buffers a button release notification</summary>
    /// <param name="releasedButton">Button that has been released</param>
    protected: void BufferButtonRelease(MouseButtons::Enum releasedButton);
    /// <summary>Buffers a cursor movement notification</summary>
    /// <param name="x">New X coordinate of the mouse cursor</param>
    /// <param name="y">New Y coordinate of the mouse cursor</param>
    protected: void BufferCursorMovement(int x, int y);
    /// <summary>Buffers a movement notification</summary>
    /// <param name="deltaX">Amount the mouse was moved on the X axis</param>
    /// <param name="deltaY">Amount the mouse was moved on the Y axis</param>
    protected: void BufferMovement(float deltaX, float deltaY);
    /// <summary>Buffers a wheel rotation notification</summary>
    /// <param name="delta">Amount the mouse wheel was rotated</param>
    protected: void BufferWheelRotation(float delta);

    /// <summary>Updates the state of the input device</summary>
    protected: void Update();
    /// <summary>Takes a snapshot of the input device's current state</summary>
    protected: void TakeSnapshot();
    /// <summary>Removes all snapshots the device has taken</summary>
    protected: void ClearSnapshots();

    /// <summary>Plays back an event, updating the mouse's state</summary>
    /// <param name="recordedEvent">Event that will be played back</param>
    private: void playbackEvent(const Event &recordedEvent);
    /// <summary>Plays back a button press event, updating the mouse's state</summary>
    /// <param name="buttonPressEvent">Event that will be played back</param>
    private: void playbackButtonPressEvent(const Event &buttonPressEvent);
    /// <summary>Plays back a button release event, updating the mouse's state</summary>
    /// <param name="buttonReleaseEvent">Event that will be played back</param>
    private: void playbackButtonReleaseEvent(const Event &buttonPressEvent);

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

    /// <summary>Events that have been buffered</summary>
    private: ConcurrentQueue<Event> bufferedEvents;
    /// <summary>Current state of the mouse</summary>
    private: MouseState currentState;

  };

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

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

#endif // NUCLEX_INPUT_DEVICES_BUFFEREDMOUSE_H