#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_XINPUTGAMEPAD_H
#define NUCLEX_INPUT_DEVICES_XINPUTGAMEPAD_H

#include "Nuclex/Input/Devices/GamePad.h"

#include "../../ConcurrentQueue.h"

#include <wrl/client.h>
#include <Xinput.h>

namespace Nuclex { namespace Input { namespace Devices {

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

  /// <summary>Implements a game pad in top of the XINPUT API</summary>
  class XInputGamePad : public GamePad {

    /// <summary>Initializes a new XInput game pad for the specified player</summary>
    /// <param name="playerIndex">Index of the player whose game pad will be queried</param>
    public: XInputGamePad(std::size_t playerIndex);

    /// <summary>Frees all resources owned by the instance</summary>
    public: virtual ~XInputGamePad();

    /// <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 this->isAttached; }

    /// <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 { return this->name; }

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

    /// <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>Reads the current state of the game pad</summary>
    private: void readState(XINPUT_STATE &state);

    /// <summary>Generates events to report the changes between the two states</summary>
    /// <param name="previous">Previous state of the game pad</param>
    /// <param name="current">Current state of the game pad</param>
    private: void generateEvents(const XINPUT_STATE &previous, const XINPUT_STATE &current);

    /// <summary>Generates a button event for the specified button</summary>
    /// <param name="pressed">
    ///   True if the button has been pressed, false if it has been released
    /// </param>
    /// <param name="buttonIndex">Index of the button that has changed state</param>
    private: void generateButtonEvent(bool pressed, std::size_t buttonIndex);

    /// <summary>Converts the current XINPUT state to a game pad state</summary>
    private: void convertState();

    /// <summary>Converts the XINPUT triggers to the game pad triggers</summary>
    private: void convertTriggers();
    /// <summary>Converts the left XINPUT thumb stick to a game pad axis</summary>
    private: void convertLeftThumbStick();
    /// <summary>Converts the right XINPUT thumb stick to a game pad axis</summary>
    private: void convertRightThumbStick();
    /// <summary>Converts the XINPUT buttons to the game pad buttons</summary>
    private: void convertButtons();
    /// <summary>Converts the XINPUT directional pad to the game pad directional pad</summary>
    private: void convertDirectionalPad();

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

    /// <summary>Index of the player represented by this game pad</summary>
    private: DWORD playerIndex;
    /// <summary>Stores the current state of the XInput game pad</summary>
    private: XINPUT_STATE *xInputState;
    /// <summary>Current state of the game pad in our own structure</summary>
    private: GamePadState currentState;
    /// <summary>Snapshots that have been recorded for the game pad</summary>
    private: ConcurrentQueue<XINPUT_STATE *> snapshots;
    /// <summary>Pool containing already allocated snapshots</summary>
    private: ConcurrentQueue<XINPUT_STATE *> pool;
    /// <summary>Whether the game pad is currently attached</summary>
    private: bool isAttached;
    /// <summary>The name of this game pad</summary>
    private: std::string name;

  };

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

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

#endif // NUCLEX_INPUT_DEVICES_XINPUTGAMEPAD_H