/****************************************************************************
**
** Copyright (C) 2015 The Qt Company Ltd.
** Contact: http://www.qt.io/licensing/
**
** This file is part of the Qt Gamepad module
**
** $QT_BEGIN_LICENSE:LGPL3$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see http://www.qt.io/terms-conditions. For further
** information use the contact form at http://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPLv3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or later as published by the Free
** Software Foundation and appearing in the file LICENSE.GPL included in
** the packaging of this file. Please review the following information to
** ensure the GNU General Public License version 2.0 requirements will be
** met: http://www.gnu.org/licenses/gpl-2.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qgamepadkeynavigation.h"
#include <QtGui/QKeyEvent>
#include <QtGui/QGuiApplication>
#include <QtGui/QWindow>
#include <QtGamepad/QGamepad>

#include <private/qobject_p.h>

QT_BEGIN_NAMESPACE

class QGamepadKeyNavigationPrivate : public QObjectPrivate
{
    Q_DECLARE_PUBLIC(QGamepadKeyNavigation)
public:
    QGamepadKeyNavigationPrivate()
        : active(true)
        , gamepad(nullptr)
        , buttonL2Pressed(false)
        , buttonR2Pressed(false)
    {
    }

    void sendGeneratedKeyEvent(QKeyEvent *event);

    bool active;
    QGamepad *gamepad;
    QGamepadManager *gamepadManger;
    bool buttonL2Pressed;
    bool buttonR2Pressed;
    QMap<QGamepadManager::GamepadButton, Qt::Key> keyMapping;

    void _q_processGamepadButtonPressEvent(int index, QGamepadManager::GamepadButton button, double value);
    void _q_processGamepadButtonReleaseEvent(int index, QGamepadManager::GamepadButton button);
};

void QGamepadKeyNavigationPrivate::sendGeneratedKeyEvent(QKeyEvent *event)
{
    if (!active) {
        delete event;
        return;
    }
    const QGuiApplication *app = qApp;
    QWindow *focusWindow = app ? app->focusWindow() : nullptr;
    if (focusWindow)
        QGuiApplication::sendEvent(focusWindow, event);
}

void QGamepadKeyNavigationPrivate::_q_processGamepadButtonPressEvent(int index, QGamepadManager::GamepadButton button, double value)
{
    Q_UNUSED(value)
    //If a gamepad has been set then, only use the events of that gamepad
    if (gamepad && gamepad->deviceId() != index)
        return;

    //Trigger buttons are a special case as they get multiple press events as the value changes
    if (button == QGamepadManager::ButtonL2 && buttonL2Pressed)
        return;
    else
        buttonL2Pressed = true;
    if (button == QGamepadManager::ButtonR2 && buttonR2Pressed)
        return;
    else
        buttonR2Pressed = true;

    QKeyEvent *event = new QKeyEvent(QEvent::KeyPress, keyMapping[button], Qt::NoModifier);
    sendGeneratedKeyEvent(event);
}

void QGamepadKeyNavigationPrivate::_q_processGamepadButtonReleaseEvent(int index, QGamepadManager::GamepadButton button)
{
    //If a gamepad has been set then, only use the events of that gamepad
    if (gamepad && gamepad->deviceId() != index)
        return;

    //Free the trigger buttons if necessary
    if (button == QGamepadManager::ButtonL2)
        buttonL2Pressed = false;
    if (button == QGamepadManager::ButtonR2)
        buttonR2Pressed = false;

    QKeyEvent *event = new QKeyEvent(QEvent::KeyRelease, keyMapping[button], Qt::NoModifier);
    sendGeneratedKeyEvent(event);
}

/*!
   \class QGamepadKeyNavigation
   \inmodule QtGamepad
   \brief Provides support for keyboard events triggered by gamepads.

   QGamepadKeyNavigation provides support for keyboard events triggered by
   gamepads.
 */

/*!
 * Constructs a QGamepadNavigation object with the given \a parent.
 */

QGamepadKeyNavigation::QGamepadKeyNavigation(QObject *parent)
    : QObject(*new QGamepadKeyNavigationPrivate(), parent)
{
    Q_D(QGamepadKeyNavigation);
    d->gamepadManger = QGamepadManager::instance();

    //Default keymap
    d->keyMapping.insert(QGamepadManager::ButtonUp, Qt::Key_Up);
    d->keyMapping.insert(QGamepadManager::ButtonDown, Qt::Key_Down);
    d->keyMapping.insert(QGamepadManager::ButtonLeft, Qt::Key_Left);
    d->keyMapping.insert(QGamepadManager::ButtonRight, Qt::Key_Right);
    d->keyMapping.insert(QGamepadManager::ButtonA, Qt::Key_Return);
    d->keyMapping.insert(QGamepadManager::ButtonB, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonX, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonY, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonSelect, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonStart, Qt::Key_Return);
    d->keyMapping.insert(QGamepadManager::ButtonGuide, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonL1, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonR1, Qt::Key_Forward);
    d->keyMapping.insert(QGamepadManager::ButtonL2, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonR2, Qt::Key_Forward);
    d->keyMapping.insert(QGamepadManager::ButtonL3, Qt::Key_Back);
    d->keyMapping.insert(QGamepadManager::ButtonR3, Qt::Key_Forward);

    connect(d->gamepadManger, SIGNAL(gamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double)),
            this, SLOT(_q_processGamepadButtonPressEvent(int,QGamepadManager::GamepadButton,double)));
    connect(d->gamepadManger, SIGNAL(gamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton)),
            this, SLOT(_q_processGamepadButtonReleaseEvent(int,QGamepadManager::GamepadButton)));
}

/*!
 * Returns whether key navigation on the gamepad is active or not.
*/
bool QGamepadKeyNavigation::active() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->active;
}

/*!
 * Returns a pointer the current QGamepad
 */
QGamepad *QGamepadKeyNavigation::gamepad() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->gamepad;
}

/*!
 * Returns the key mapping of the Up button.
 */
Qt::Key QGamepadKeyNavigation::upKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonUp];
}

/*!
 * Returns the key mapping of the Down button.
 */
Qt::Key QGamepadKeyNavigation::downKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonDown];
}

/*!
 * Returns the key mapping of the Left button.
 */
Qt::Key QGamepadKeyNavigation::leftKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonLeft];
}

/*!
 * Returns the key mapping of the Right button.
 */
Qt::Key QGamepadKeyNavigation::rightKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonRight];
}

/*!
 * Returns the key mapping of A button.
 */
Qt::Key QGamepadKeyNavigation::buttonAKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonA];
}

/*!
 * Returns the key mapping of the B button.
 */
Qt::Key QGamepadKeyNavigation::buttonBKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonB];
}

/*!
 * Returns the key mapping of the X button.
 */
Qt::Key QGamepadKeyNavigation::buttonXKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonX];
}

/*!
 * Returns the key mapping of the Y button.
 */
Qt::Key QGamepadKeyNavigation::buttonYKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonY];
}

/*!
 * Returns the key mapping of the Select button.
 */
Qt::Key QGamepadKeyNavigation::buttonSelectKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonSelect];
}

/*!
 * Returns the key mapping of the Start button.
 */
Qt::Key QGamepadKeyNavigation::buttonStartKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonStart];
}

/*!
 * Returns the key mapping of the Guide button.
 */
Qt::Key QGamepadKeyNavigation::buttonGuideKey() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonGuide];
}

/*!
 * Returns the key mapping of the left shoulder button.
 */
Qt::Key QGamepadKeyNavigation::buttonL1Key() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonL1];
}

/*!
 * Returns the key mapping of the Right shoulder button.
 */
Qt::Key QGamepadKeyNavigation::buttonR1Key() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonL2];
}

/*!
 * Returns the key mapping of the left trigger button.
 */
Qt::Key QGamepadKeyNavigation::buttonL2Key() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonL2];
}

/*!
 * Returns the key mapping of the Right trigger button.
 */
Qt::Key QGamepadKeyNavigation::buttonR2Key() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonL2];
}

/*!
 * Returns the key mapping of the left stick button.
 */
Qt::Key QGamepadKeyNavigation::buttonL3Key() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonL3];
}

/*!
 * Returns the key mapping of the right stick button.
 */
Qt::Key QGamepadKeyNavigation::buttonR3Key() const
{
    Q_D(const QGamepadKeyNavigation);
    return d->keyMapping[QGamepadManager::ButtonL3];
}

/*!
 * Activates key navigation if \a isActive is true,
 * disables it otherwise.
 */
void QGamepadKeyNavigation::setActive(bool isActive)
{
    Q_D(QGamepadKeyNavigation);
    if (d->active != isActive) {
        d->active = isActive;
        emit activeChanged(isActive);
    }
}

/*!
 * Selects the specified \a gamepad.
*/
void QGamepadKeyNavigation::setGamepad(QGamepad *gamepad)
{
    Q_D(QGamepadKeyNavigation);
    if (d->gamepad != gamepad) {
        d->gamepad = gamepad;
        emit gamepadChanged(gamepad);
    }
}

/*!
 * Sets the mapping of the Up button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setUpKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonUp] != key) {
        d->keyMapping[QGamepadManager::ButtonUp] = key;
        emit upKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Down button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setDownKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonDown] != key) {
        d->keyMapping[QGamepadManager::ButtonDown] = key;
        emit downKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Left button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setLeftKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonLeft] != key) {
        d->keyMapping[QGamepadManager::ButtonLeft] = key;
        emit leftKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Right button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setRightKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonRight] != key) {
        d->keyMapping[QGamepadManager::ButtonRight] = key;
        emit rightKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the A button with the keycode
 * specified in \a key.
*/
void QGamepadKeyNavigation::setButtonAKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonA] != key) {
        d->keyMapping[QGamepadManager::ButtonA] = key;
        emit buttonAKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the B button with the keycode
 * specified in \a key.
*/
void QGamepadKeyNavigation::setButtonBKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonB] != key) {
        d->keyMapping[QGamepadManager::ButtonB] = key;
        emit buttonBKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the X button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonXKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonX] != key) {
        d->keyMapping[QGamepadManager::ButtonX] = key;
        emit buttonXKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Y button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonYKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonY] != key) {
        d->keyMapping[QGamepadManager::ButtonY] = key;
        emit buttonYKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Select button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonSelectKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonSelect] != key) {
        d->keyMapping[QGamepadManager::ButtonSelect] = key;
        emit buttonSelectKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Start button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonStartKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonStart] != key) {
        d->keyMapping[QGamepadManager::ButtonStart] = key;
        emit buttonStartKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the Guide button with the keycode
 * specified in \a key.
*/
void QGamepadKeyNavigation::setButtonGuideKey(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonGuide] != key) {
        d->keyMapping[QGamepadManager::ButtonGuide] = key;
        emit buttonGuideKeyChanged(key);
    }
}

/*!
 * Sets the mapping of the left shoulder button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonL1Key(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonL1] != key) {
        d->keyMapping[QGamepadManager::ButtonL1] = key;
        emit buttonL1KeyChanged(key);
    }
}

/*!
 * Sets the mapping of the right shoulder button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonR1Key(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonR1] != key) {
        d->keyMapping[QGamepadManager::ButtonR1] = key;
        emit buttonR1KeyChanged(key);
    }
}

/*!
 * Sets the mapping of the left trigger button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonL2Key(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonL2] != key) {
        d->keyMapping[QGamepadManager::ButtonL2] = key;
        emit buttonL1KeyChanged(key);
    }
}

/*!
 * Sets the mapping of the right trigger button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonR2Key(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonR2] != key) {
        d->keyMapping[QGamepadManager::ButtonR2] = key;
        emit buttonR1KeyChanged(key);
    }
}

/*!
 * Sets the mapping of the left stick button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonL3Key(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonL3] != key) {
        d->keyMapping[QGamepadManager::ButtonL3] = key;
        emit buttonL1KeyChanged(key);
    }
}

/*!
 * Sets the mapping of the right stick button with the
 * keycode specified in \a key.
*/
void QGamepadKeyNavigation::setButtonR3Key(Qt::Key key)
{
    Q_D(QGamepadKeyNavigation);
    if (d->keyMapping[QGamepadManager::ButtonR3] != key) {
        d->keyMapping[QGamepadManager::ButtonR3] = key;
        emit buttonR1KeyChanged(key);
    }
}

QT_END_NAMESPACE

#include "moc_qgamepadkeynavigation.cpp"