/***************************************************************************
**
** Copyright (C) 2016 BlackBerry Limited. All rights reserved.
** Copyright (C) 2016 BasysKom GmbH.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtNfc module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** 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 https://www.qt.io/terms-conditions. For further
** information use the contact form at https://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.LGPL3 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-3.0.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 (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qnearfieldmanager_neard_p.h"
#include "qnearfieldtarget_neard_p.h"

#include "neard/adapter_p.h"
#include "neard/dbusproperties_p.h"
#include "neard/dbusobjectmanager_p.h"

QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(QT_NFC_NEARD)

// TODO We need a constructor that lets us select an adapter
QNearFieldManagerPrivateImpl::QNearFieldManagerPrivateImpl()
    : QNearFieldManagerPrivate(),
      m_neardHelper(NeardHelper::instance())
{
    QDBusPendingReply<ManagedObjectList> reply = m_neardHelper->dbusObjectManager()->GetManagedObjects();
    reply.waitForFinished();
    if (reply.isError()) {
        qCWarning(QT_NFC_NEARD) << "Error getting managed objects";
        return;
    }

    bool found = false;
    const QList<QDBusObjectPath> paths = reply.value().keys();
    for (const QDBusObjectPath &path : paths) {
        const InterfaceList ifaceList = reply.value().value(path);
        const QStringList ifaces = ifaceList.keys();
        for (const QString &iface : ifaces) {
            if (iface == QStringLiteral("org.neard.Adapter")) {
                found = true;
                m_adapterPath = path.path();
                qCDebug(QT_NFC_NEARD) << "org.neard.Adapter found for path" << m_adapterPath;
                break;
            }
        }

        if (found)
            break;
    }

    if (!found) {
        qCWarning(QT_NFC_NEARD) << "no adapter found, neard daemon running?";
    } else {
        connect(m_neardHelper, &NeardHelper::tagFound,
                this,          &QNearFieldManagerPrivateImpl::handleTagFound);
        connect(m_neardHelper, &NeardHelper::tagRemoved,
                this,          &QNearFieldManagerPrivateImpl::handleTagRemoved);
    }
}

QNearFieldManagerPrivateImpl::~QNearFieldManagerPrivateImpl()
{
    stopTargetDetection();
}

bool QNearFieldManagerPrivateImpl::isAvailable() const
{
    if (!m_neardHelper->dbusObjectManager()->isValid() || m_adapterPath.isNull()) {
        qCWarning(QT_NFC_NEARD) << "dbus object manager invalid or adapter path invalid";
        return false;
    }

    QDBusPendingReply<ManagedObjectList> reply = m_neardHelper->dbusObjectManager()->GetManagedObjects();
    reply.waitForFinished();
    if (reply.isError()) {
        qCWarning(QT_NFC_NEARD) << "error getting managed objects";
        return false;
    }

    const QList<QDBusObjectPath> paths = reply.value().keys();
    for (const QDBusObjectPath &path : paths) {
        if (m_adapterPath == path.path())
            return true;
    }

    return false;
}

bool QNearFieldManagerPrivateImpl::isSupported() const
{
    if (m_adapterPath.isEmpty()) {
        qCWarning(QT_NFC_NEARD) << "no adapter found, neard daemon running?";
        return false;
    }

    if (!m_neardHelper->dbusObjectManager()->isValid() || m_adapterPath.isNull()) {
        qCWarning(QT_NFC_NEARD) << "dbus object manager invalid or adapter path invalid";
        return false;
    }

    return true;
}

bool QNearFieldManagerPrivateImpl::startTargetDetection()
{
    qCDebug(QT_NFC_NEARD) << "starting target detection";
    if (!isAvailable())
        return false;

    OrgFreedesktopDBusPropertiesInterface dbusProperties(QStringLiteral("org.neard"),
                                                         m_adapterPath,
                                                         QDBusConnection::systemBus());

    if (!dbusProperties.isValid()) {
        qCWarning(QT_NFC_NEARD) << "dbus property interface invalid";
        return false;
    }

    // check if the adapter is currently polling
    QDBusPendingReply<QDBusVariant> replyPolling = dbusProperties.Get(QStringLiteral("org.neard.Adapter"),
                                                                      QStringLiteral("Polling"));
    replyPolling.waitForFinished();
    if (!replyPolling.isError()) {
        if (replyPolling.value().variant().toBool()) {
            qCDebug(QT_NFC_NEARD) << "adapter is already polling";
            return true;
        }
    } else {
        qCWarning(QT_NFC_NEARD) << "error getting 'Polling' state from property interface";
        return false;
    }

    // check if the adapter it powered
    QDBusPendingReply<QDBusVariant> replyPowered = dbusProperties.Get(QStringLiteral("org.neard.Adapter"),
                                                                      QStringLiteral("Powered"));
    replyPowered.waitForFinished();
    if (!replyPowered.isError()) {
        if (replyPowered.value().variant().toBool()) {
            qCDebug(QT_NFC_NEARD) << "adapter is already powered";
        } else {
            QDBusPendingReply<QDBusVariant> replyTryPowering = dbusProperties.Set(QStringLiteral("org.neard.Adapter"),
                                                                                  QStringLiteral("Powered"),
                                                                                  QDBusVariant(true));
            replyTryPowering.waitForFinished();
            if (!replyTryPowering.isError()) {
                qCDebug(QT_NFC_NEARD) << "powering adapter";
            }
        }
    } else {
        qCWarning(QT_NFC_NEARD) << "error getting 'Powered' state from property interface";
        return false;
    }

    // create adapter and start poll loop
    OrgNeardAdapterInterface neardAdapter(QStringLiteral("org.neard"),
                                          m_adapterPath,
                                          QDBusConnection::systemBus());

    // possible modes: "Target", "Initiator", "Dual"
    QDBusPendingReply<> replyPollLoop = neardAdapter.StartPollLoop(QStringLiteral("Dual"));
    replyPollLoop.waitForFinished();
    if (replyPollLoop.isError()) {
        qCWarning(QT_NFC_NEARD) << "error when starting polling";
        return false;
    } else {
        qCDebug(QT_NFC_NEARD) << "successfully started polling";
    }

    return true;
}

void QNearFieldManagerPrivateImpl::stopTargetDetection()
{
    qCDebug(QT_NFC_NEARD) << "stopping target detection";
    if (!isAvailable())
        return;

    OrgFreedesktopDBusPropertiesInterface dbusProperties(QStringLiteral("org.neard"),
                                                         m_adapterPath,
                                                         QDBusConnection::systemBus());

    if (!dbusProperties.isValid()) {
        qCWarning(QT_NFC_NEARD) << "dbus property interface invalid";
        return;
    }

    // check if the adapter is currently polling
    QDBusPendingReply<QDBusVariant> replyPolling = dbusProperties.Get(QStringLiteral("org.neard.Adapter"),
                                                                      QStringLiteral("Polling"));
    replyPolling.waitForFinished();
    if (!replyPolling.isError()) {
        if (replyPolling.value().variant().toBool()) {
            // create adapter and stop poll loop
            OrgNeardAdapterInterface neardAdapter(QStringLiteral("org.neard"),
                                                  m_adapterPath,
                                                  QDBusConnection::systemBus());

            QDBusPendingReply<> replyStopPolling = neardAdapter.StopPollLoop();
            replyStopPolling.waitForFinished();
            if (replyStopPolling.isError())
                qCWarning(QT_NFC_NEARD) << "error when stopping polling";
            else
                qCDebug(QT_NFC_NEARD) << "successfully stopped polling";
        } else {
            qCDebug(QT_NFC_NEARD) << "already stopped polling";
        }
    } else {
        qCWarning(QT_NFC_NEARD) << "error getting 'Polling' state from property interface";
    }
}

int QNearFieldManagerPrivateImpl::registerNdefMessageHandler(QObject *object, const QMetaMethod &method)
{
    Q_UNUSED(object);
    Q_UNUSED(method);
    return -1;
}

int QNearFieldManagerPrivateImpl::registerNdefMessageHandler(const QNdefFilter &filter, QObject *object, const QMetaMethod &method)
{
    Q_UNUSED(filter);
    Q_UNUSED(object);
    Q_UNUSED(method);
    return -1;
}

bool QNearFieldManagerPrivateImpl::unregisterNdefMessageHandler(int handlerId)
{
    Q_UNUSED(handlerId);
    return false;
}

void QNearFieldManagerPrivateImpl::requestAccess(QNearFieldManager::TargetAccessModes accessModes)
{
    Q_UNUSED(accessModes);
}

void QNearFieldManagerPrivateImpl::releaseAccess(QNearFieldManager::TargetAccessModes accessModes)
{
    Q_UNUSED(accessModes);
}

void QNearFieldManagerPrivateImpl::handleTagFound(const QDBusObjectPath &path)
{
    NearFieldTarget<QNearFieldTarget> *nfTag = new NearFieldTarget<QNearFieldTarget>(this, path);
    m_activeTags.insert(path.path(), nfTag);
    emit targetDetected(nfTag);
}

void QNearFieldManagerPrivateImpl::handleTagRemoved(const QDBusObjectPath &path)
{
    const QString adapterPath = path.path();
    if (m_activeTags.contains(adapterPath)) {
        QNearFieldTarget *nfTag = m_activeTags.value(adapterPath);
        m_activeTags.remove(adapterPath);
        emit targetLost(nfTag);
    }
}

QT_END_NAMESPACE
