#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_BUFFEREDKEYBOARD_H
#define NUCLEX_INPUT_DEVICES_BUFFEREDKEYBOARD_H

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

namespace Nuclex { namespace Input { namespace Devices {

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

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

    /// <summary>A snapshot has been recorded</summary>
    private: static const int SnapshotNotification = 0;
    /// <summary>Key has been pressed</summary>
    private: static const int KeyPressNotification = 1;
    /// <summary>Key has been pressed</summary>
    private: static const int KeyReleaseNotification = 2;
    /// <summary>Character has been entered</summary>
    private: static const int CharacterEntryNotification = 3;

    #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>Key that has been pressed or released</summary>
        public: Key::Enum PressedOrReleasedKey;
        /// <summary>Character that has been entered</summary>
        public: wchar_t EnteredCharacter;
      };
    };

    #pragma endregion // struct Event

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

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

    /// <summary>Buffers a key press notification</summary>
    /// <param name="pressedKey">Key that has been pressed</param>
    protected: void BufferKeyPress(Key::Enum pressedKey);
    /// <summary>Buffers a key release notification</summary>
    /// <param name="releasedKey">Key that has been released</param>
    protected: void BufferKeyRelease(Key::Enum releasedKey);
    /// <summary>Buffers a character entry notification</summary>
    /// <param name="enteredCharacter">Character that has been entered</param>
    protected: void BufferCharacterEntry(wchar_t enteredCharacter);

    /// <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 keyboard's state</summary>
    /// <param name="recordedEvent">Event that will be played back</param>
    private: void playbackEvent(const Event &recordedEvent);

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

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

  };

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

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

#endif // NUCLEX_INPUT_DEVICES_BUFFEREDKEYBOARD_H