#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_INPUTMANAGER_H
#define NUCLEX_INPUT_INPUTMANAGER_H

#include "Config.h"
#include "Devices/GamePad.h"
#include "Devices/Keyboard.h"
#include "Devices/Mouse.h"
#include "Devices/TouchPanel.h"

namespace Nuclex { namespace Input {

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

  /// <summary>Provides access to the system's input devices</summary>
  /// <remarks>
  ///   <para>
  ///     This service provides a uniform way to access all input devices connected
  ///     to the system. Its design philosophy is that the you are guaranteed the existence
  ///     of 1 mouse, 1 keyboard, 8 game pads / joysticks and 1 touch panel. If any
  ///     of these devices are not available, they're replaced by a dummy device which
  ///     returns a neutral state. 
  ///   </para>
  ///   <para>
  ///     So instead of putting the burden of querying the number of input devices,
  ///     adjusting your input handlers to cope with devices disappearing and reappearing
  ///     while the game runs, your game can simply continue. You can optionally query
  ///     IsAttached() if you want to stop the game and tell the player to reattach his
  ///     controller or something, but this is entirely optional.
  ///   </para>
  /// </remarks>
  class InputManager {

    /// <summary>Initializes a new input manager</summary>
    protected: InputManager() : snapshotCount(0) {}

    /// <summary>Destroys the input manager</summary>
    public: virtual ~InputManager() {}

    /// <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: virtual std::size_t CountKeyboards() const = 0;

    /// <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: virtual const Devices::Keyboard &GetKeyboard(std::size_t index) const = 0;

    /// <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: virtual Devices::Keyboard &GetKeyboard(std::size_t index) = 0;

    /// <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: virtual std::size_t CountMice() const = 0;

    /// <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: virtual const Devices::Mouse &GetMouse(std::size_t index) const = 0;

    /// <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: virtual Devices::Mouse &GetMouse(std::size_t index) = 0;

    /// <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: virtual std::size_t CountGamePads() const = 0;

    /// <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: virtual const Devices::GamePad &GetGamePad(std::size_t index) const = 0;

    /// <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: virtual Devices::GamePad &GetGamePad(std::size_t index) = 0;

    /// <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: virtual std::size_t CountTouchPanels() const = 0;

    /// <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: virtual const Devices::TouchPanel &GetTouchPanel(std::size_t index) const = 0;

    /// <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: virtual Devices::TouchPanel &GetTouchPanel(std::size_t index) = 0;

    /// <summary>Updates the state of all input devices</summary>
    public: NUCLEX_INPUT_API virtual void Update();

    /// <summary>Takes a snapshot of the current state of all input devices</summary>
    /// <remarks>
    ///   <para>
    ///     The snapshot will be queued until the user calls the Update() method, at which
    ///     point the next stored snapshot will be taken from the queue and provided as
    ///     the current state.
    ///   </para>
    ///   <para>
    ///     This can be used to make input independent of the game's frame rate - instead
    ///     of polling input once per frame, a thread can take snapshots of all input devices
    ///     at regular intervals and these snapshots can then be processed one after another
    ///     during the next update phase (note that this requires time-stepped instead of
    ///     a time-scaled updates)
    ///   </para>
    ///   <para>
    ///     If the snapshot queue is empty, a call to update will poll the input devices
    ///     right then and there at no additional overhead, so feel free to ignore this method
    ///     if your game doesn't need that kind of complexity!
    ///   </para>
    /// </remarks>
    public: NUCLEX_INPUT_API virtual void TakeSnapshot();

    /// <summary>Clears the snapshot queue</summary>
    public: NUCLEX_INPUT_API virtual void ClearSnapshots();

    /// <summary>Returns the number of snapshots currently queued</summary>
    /// <returns>The number of input device snapshots currently in the queue</returns>
    public: virtual std::size_t CountSnapshots() const { return this->snapshotCount; }

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

    /// <summary>Number of snapshots the input devices should have</summary>
    private: std::size_t snapshotCount;

  };

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

}} // namespace Nuclex::Input

#endif // NUCLEX_INPUT_INPUTMANAGER_H