#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_WINRTINPUTMANAGER_H
#define NUCLEX_INPUT_WINRTINPUTMANAGER_H

#include "Config.h"

#if !defined(NUCLEX_INPUT_WINRT)
#error This header is intended for WinRT/Metro apps written in C++/CX
#endif

#include "InputManager.h"

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

#include <memory>

namespace Nuclex { namespace Input {

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

  /// <summary>Listens to input received from a WinRT/Metro CoreWindow</summary>
  /// <remarks>
  ///   The WinRT/Metro input manager simply subscribes to the events of the WinRT
  ///   CoreWindow class. Therefore, it's mainly useful in those cases where you want to
  ///   route input through the InputManager in order to be able to support other platforms
  ///   at a later time or if you're porting a game to WinRT/Metro.
  /// </remarks>
  class WinRTInputManager : public InputManager {

    /// <summary>Initializes a new WinRT input manager</summary>
    public: NUCLEX_INPUT_API WinRTInputManager(Windows::UI::Core::CoreWindow ^window);

    /// <summary>Destroys the WinRT input manager</summary>
    public: NUCLEX_INPUT_API virtual ~WinRTInputManager();

    /// <summary>Counts the number of keyboards present</summary>
    /// <returns>The number of keyboards present on the system</returns>
    /// <remarks>
    ///   You are guaranteed at least 1 keyboard in all cases, including on mobile
    ///   platforms, where you will be provided with a dummy.
    /// </remarks>
    public: NUCLEX_INPUT_API std::size_t CountKeyboards() const;

    /// <summary>Accesses a keyboard</summary>
    /// <param name="index">Index of the keyboard that will be returned</param>
    /// <returns>The keyboard with the specified index</returns>
    public: NUCLEX_INPUT_API const Devices::Keyboard &GetKeyboard(std::size_t index) const;

    /// <summary>Accesses a keyboard</summary>
    /// <param name="index">Index of the keyboard that will be returned</param>
    /// <returns>The keyboard with the specified index</returns>
    public: NUCLEX_INPUT_API Devices::Keyboard &GetKeyboard(std::size_t index);

    /// <summary>Counts the number of mice present</summary>
    /// <returns>The number of mice present on the system</returns>
    /// <remarks>
    ///   You are guaranteed at least 1 mouse in all cases, including on mobile
    ///   platforms, where you will be provided with a dummy.
    /// </remarks>
    public: NUCLEX_INPUT_API std::size_t CountMice() const;

    /// <summary>Accesses a mouse</summary>
    /// <param name="index">Index of the mouse that will be returned</param>
    /// <returns>The mouse with the specified index</returns>
    public: NUCLEX_INPUT_API const Devices::Mouse &GetMouse(std::size_t index) const;

    /// <summary>Accesses a mouse</summary>
    /// <param name="index">Index of the mouse that will be returned</param>
    /// <returns>The mouse with the specified index</returns>
    public: NUCLEX_INPUT_API Devices::Mouse &GetMouse(std::size_t index);

    /// <summary>Counts the number of game pads present</summary>
    /// <returns>The number of game pads present on the system</returns>
    /// <remarks>
    ///   You are guaranteed at least 4 game pads in all cases, including on mobile
    ///   platforms. If fewer than 4 game pads are connected, dummies will take
    ///   the place of the missing devices.
    /// </remarks>
    public: NUCLEX_INPUT_API std::size_t CountGamePads() const;

    /// <summary>Accesses a game pad</summary>
    /// <param name="index">Index of the game pad that will be returned</param>
    /// <returns>The game pad with the specified index</returns>
    public: NUCLEX_INPUT_API const Devices::GamePad &GetGamePad(std::size_t index) const;

    /// <summary>Accesses a game pad</summary>
    /// <param name="index">Index of the game pad that will be returned</param>
    /// <returns>The game pad with the specified index</returns>
    public: NUCLEX_INPUT_API Devices::GamePad &GetGamePad(std::size_t index);

    /// <summary>Counts the number of touch panels present</summary>
    /// <returns>The number of touch panels present on the system</returns>
    /// <remarks>
    ///   You are guaranteed at least 1 touch panel in all cases, including on
    ///   gaming consoles, where you will be provided with a dummy.
    /// </remarks>
    public: NUCLEX_INPUT_API std::size_t CountTouchPanels() const;

    /// <summary>Accesses a touch panel</summary>
    /// <param name="index">Index of the touch panel that will be returned</param>
    /// <returns>The game pad with the specified index</returns>
    public: NUCLEX_INPUT_API const Devices::TouchPanel &GetTouchPanel(std::size_t index) const;

    /// <summary>Accesses a touch panel</summary>
    /// <param name="index">Index of the touch panel that will be returned</param>
    /// <returns>The game pad with the specified index</returns>
    public: NUCLEX_INPUT_API Devices::TouchPanel &GetTouchPanel(std::size_t index);

    private: ref struct Impl; // hides private implementation details from the user
    /// <summary>Private implementation details of the input manager</summary>
    private: Impl ^impl;

  };

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

}} // namespace Nuclex::Input

#endif // NUCLEX_INPUT_WINDOWSINPUTMANAGER_H