#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_DIRECTINPUTGAMEPAD_H
#define NUCLEX_INPUT_DEVICES_DIRECTINPUTGAMEPAD_H

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

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

#include <comdef.h>
#define DIRECTINPUT_VERSION 0x800
#include <dinput.h>

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

/// <summary>Smart pointer for the main DirectInput8 interface</summary>
_COM_SMARTPTR_TYPEDEF(IDirectInput8, IID_IDirectInput8);
/// <summary>Smart pointer for a DirectInputDevice8</summary>
_COM_SMARTPTR_TYPEDEF(IDirectInputDevice8, IID_IDirectInputDevice8);

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

namespace Nuclex { namespace Input { namespace Devices {

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

  /// <summary>Implements a game pad on top of the DirectInput API</summary>
  class DirectInputGamePad : public GamePad {

    /// <summary>Initializes a new DirectInput game pad for the specified player</summary>
    /// <param name="directInput">
    ///   DirectInput interface the game pad will be constructed with
    /// </param>
    /// <param name="deviceInstance">Device this game pad will query data from</param>
    public: DirectInputGamePad(
      const IDirectInput8Ptr &directInput, const DIDEVICEINSTANCE &deviceInstance
    );

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

    /// <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 { 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>Builds the mappers from device objects to the game pad state</summary>
    private: void buildMappers();

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

    /// <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<GamePadState *> snapshots;
    /// <summary>Pool containing already allocated snapshots</summary>
    private: ConcurrentQueue<GamePadState *> pool;
    /// <summary>The name of this game pad</summary>
    private: std::string name;
    /// <summary>DirectInput interface the device was constructed by</summary>
    private: IDirectInput8Ptr directInput;
    /// <summary>Direct input device this game pad is querying</summary>
    private: IDirectInputDevice8Ptr directInputDevice;
    /// <summary>Whether the device is currently acquired</summary>
    private: bool isAcquired;

  };

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

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

#endif // NUCLEX_INPUT_DEVICES_DIRECTINPUTGAMEPAD_H