#pragma once

#ifndef INPUTSTATE_INCLUDED
#define INPUTSTATE_INCLUDED

// TnzTools includes
#include <tools/tooltimer.h>
#include <tools/keyhistory.h>

// TnzCore includes
#include <tcommon.h>
#include <tsmartpointer.h>
#include <tgeometry.h>

// Qt includes
#include <Qt>

// std includes
#include <map>
#include <vector>
#include <iostream>


#undef DVAPI
#undef DVVAR
#ifdef TNZTOOLS_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif


//====================================================

//  Forward declarations

typedef std::vector<TPointD> THoverList;

//===================================================================


//*****************************************************************************************
//    TKey definition
//*****************************************************************************************

class DVAPI TKey {
public:
  Qt::Key key;
  bool generic;
  bool numPad;

  static const TKey shift;
  static const TKey control;
  static const TKey alt;
  static const TKey meta;

  inline explicit TKey(Qt::Key key = Qt::Key(), bool generic = true, bool numPad = false):
    key(key),
    generic(generic),
    numPad(numPad)
    { }

  inline bool operator== (const TKey &other) const {
    if (generic || other.generic)
      return is(other.key);
    return key == other.key && numPad == other.numPad;
  }

  inline bool is(Qt::Key key) const
    { return mapKey(this->key) == mapKey(key); }

  inline bool isModifier() const
    { return isModifier(key); }
  inline bool isNumber() const
    { return isNumber(key); }

  static Qt::Key mapKey(Qt::Key key);
  static bool isNumber(Qt::Key key);
  static bool isModifier(Qt::Key key);
};


//*****************************************************************************************
//    export template implementations for win32
//*****************************************************************************************

#ifdef _WIN32
template class DVAPI TKeyStateT<TKey>;
template class DVAPI TSmartPointerT< TKeyStateT<TKey> >;
template class DVAPI TKeyHistoryT<TKey>;
template class DVAPI TKeyHistoryT<TKey>::Holder;

template class DVAPI TKeyStateT<Qt::MouseButton>;
template class DVAPI TSmartPointerT< TKeyStateT<Qt::MouseButton> >;
template class DVAPI TKeyHistoryT<Qt::MouseButton>;
template class DVAPI TKeyHistoryT<Qt::MouseButton>::Holder;
#endif


//*****************************************************************************************
//    TInputState definition
//*****************************************************************************************

class DVAPI TInputState {
public:
  typedef qint64 DeviceId;
  typedef long long TouchId;

  typedef TKey Key;
  typedef TKeyHistoryT<Key> KeyHistory;
  typedef KeyHistory::State KeyState;

  typedef Qt::MouseButton Button;
  typedef TKeyHistoryT<Button> ButtonHistory;
  typedef ButtonHistory::State ButtonState;
  typedef std::map<DeviceId, ButtonHistory::Pointer> ButtonHistoryMap;

private:
  TTimerTicks m_ticks;
  KeyHistory::Pointer m_keyHistory;
  mutable ButtonHistoryMap m_buttonHistories;

public:
  TInputState();
  ~TInputState();

  TTimerTicks ticks() const
    { return m_ticks; }
  void touch(TTimerTicks ticks);

  inline const KeyHistory::Pointer& keyHistory() const
    { return m_keyHistory; }
  inline KeyState::Pointer keyState() const
    { return keyHistory()->current(); }

  inline void keyEvent(bool press, Key key, TTimerTicks ticks)
    { touch(ticks); keyHistory()->change(press, key, m_ticks); }
  inline void keyPress(Key key, TTimerTicks ticks)
    { keyEvent(true, key, ticks); }
  inline void keyRelease(Key key, TTimerTicks ticks)
    { keyEvent(false, key, ticks); }

  inline KeyState::Pointer keyFind(Key key) const
    { return keyState()->find(key); }
  inline bool isKeyPressed(Key key) const
    { return keyFind(key); }
  inline double howLongKeyPressed(Key key, TTimerTicks ticks, double timeOffset = 0.0)
    { return KeyState::Holder::howLongPressed(keyFind(key), ticks, timeOffset); }
  inline double howLongKeyPressed(Key key)
    { return howLongKeyPressed(key, m_ticks); }

  inline KeyState::Holder keyStateHolder(TTimerTicks ticks, double timeOffset = 0.0) const
    { return KeyState::Holder(keyState(), ticks, timeOffset); }
  inline KeyState::Holder keyStateHolder() const
    { return keyStateHolder(m_ticks); }
  inline KeyHistory::Holder keyHistoryHolder(TTimerTicks ticks, double timeOffset = 0.0) const
    { return KeyHistory::Holder(keyHistory(), ticks, timeOffset); }
  inline KeyHistory::Holder keyHistoryHolder() const
    { return keyHistoryHolder(m_ticks); }

  ButtonHistory::Pointer buttonHistory(DeviceId deviceId) const;

  inline const ButtonHistoryMap buttonHistories() const
    { return m_buttonHistories; }
  inline ButtonState::Pointer buttonState(DeviceId deviceId) const
    { return buttonHistory(deviceId)->current(); }

  inline void buttonEvent(bool press, DeviceId deviceId, Button button, TTimerTicks ticks)
    { touch(ticks); buttonHistory(deviceId)->change(press, button, m_ticks); }
  inline void buttonPress(DeviceId deviceId, Button button, TTimerTicks ticks)
    { buttonEvent(true, deviceId, button, ticks); }
  inline void buttonRelease(DeviceId deviceId, Button button, TTimerTicks ticks)
    { buttonEvent(false, deviceId, button, ticks); }
  inline void buttonEvent(bool press, Button button, TTimerTicks ticks)
    { buttonEvent(press, 0, button, ticks); }
  inline void buttonPress(Button button, TTimerTicks ticks)
    { buttonEvent(true, button, ticks); }
  inline void buttonRelease(Button button, TTimerTicks ticks)
    { buttonEvent(false, button, ticks); }

  inline ButtonState::Pointer buttonFind(DeviceId deviceId, Button button)
    { return buttonState(deviceId)->find(button); }
  inline bool isButtonPressed(DeviceId deviceId, Button button)
    { return buttonFind(deviceId, button); }
  inline double howLongButtonPressed(DeviceId deviceId, Button button, TTimerTicks ticks, double timeOffset = 0.0)
    { return ButtonState::Holder::howLongPressed(buttonFind(deviceId, button), ticks, timeOffset); }
  inline double howLongButtonPressed(DeviceId deviceId, Button button)
    { return howLongButtonPressed(deviceId, button, m_ticks); }

  inline ButtonState::Pointer buttonFindDefault(Button button)
    { return buttonFind(DeviceId(), button); }
  inline bool isButtonPressedDefault(Button button)
    { return isButtonPressed(DeviceId(), button); }
  inline double howLongButtonPressedDefault(Button button, TTimerTicks ticks, double timeOffset = 0.0)
    { return howLongButtonPressed(DeviceId(), button, ticks, timeOffset); }
  inline double howLongButtonPressedDefault(Button button)
    { return howLongButtonPressedDefault(button, m_ticks); }

  ButtonState::Pointer buttonFindAny(Button button, DeviceId &outDevice);

  inline ButtonState::Pointer buttonFindAny(Button button)
    { DeviceId deviceId; return buttonFindAny(button, deviceId); }
  inline bool isButtonPressedAny(Button button)
    { return buttonFindAny(button); }
  inline double howLongButtonPressedAny(Button button, TTimerTicks ticks, double timeOffset = 0.0)
    { return ButtonState::Holder::howLongPressed(buttonFindAny(button), ticks, timeOffset); }
  inline double howLongButtonPressedAny(Button button)
    { return howLongButtonPressedAny(button, m_ticks); }

  inline ButtonState::Holder buttonStateHolder(DeviceId deviceId, TTimerTicks ticks, double timeOffset = 0.0)
    { return ButtonState::Holder(buttonState(deviceId), ticks, timeOffset); }
  inline ButtonState::Holder buttonStateHolder(DeviceId deviceId)
    { return buttonStateHolder(deviceId, m_ticks); }
  inline ButtonHistory::Holder buttonHistoryHolder(DeviceId deviceId, long ticks, double timeOffset = 0.0)
    { return ButtonHistory::Holder(buttonHistory(deviceId), ticks, timeOffset); }
  inline ButtonHistory::Holder buttonHistoryHolder(DeviceId deviceId)
    { return buttonHistoryHolder(deviceId, m_ticks); }
    
  void print(std::ostream &stream, const std::string &tab = std::string()) const;
  inline void print(const std::string &tab = std::string()) const
    { print(std::cout, tab); }
};


#endif