// Copyright (C) 2022 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

#include "qpcscmanager_p.h"
#include "qpcscslot_p.h"
#include "qpcsccard_p.h"
#include <QtCore/QLoggingCategory>
#include <QtCore/QThread>
#include <QtCore/QTimer>

QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(QT_NFC_PCSC)

static constexpr auto PollIntervalEnvVar = "QT_NFC_POLL_INTERVAL_MS";
static constexpr int DefaultPollIntervalMs = 100;

QPcscManager::QPcscManager(QObject *parent) : QObject(parent)
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;

    int pollInterval = DefaultPollIntervalMs;
    QByteArray intervalEnv = qgetenv(PollIntervalEnvVar);
    if (!intervalEnv.isEmpty()) {
        if (int intervalFromEnv = intervalEnv.toInt(); intervalFromEnv > 0)
            pollInterval = intervalFromEnv;
        else
            qCWarning(QT_NFC_PCSC) << PollIntervalEnvVar << "set to an invalid value";
    }

    m_stateUpdateTimer = new QTimer(this);
    m_stateUpdateTimer->setInterval(pollInterval);
    connect(m_stateUpdateTimer, &QTimer::timeout, this, &QPcscManager::onStateUpdate);
}

QPcscManager::~QPcscManager()
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
    if (m_hasContext) {
        // Destroy all card handles before destroying the PCSC context.
        for (auto slot : std::as_const(m_slots))
            slot->invalidateInsertedCard();
        SCardReleaseContext(m_context);
    }

    // Stop the worker thread.
    thread()->quit();
}

void QPcscManager::processSlotUpdates()
{
    for (auto &state : m_slotStates) {
        auto slot = static_cast<QPcscSlot *>(state.pvUserData);
        Q_ASSERT(slot != nullptr);

        if ((state.dwEventState & SCARD_STATE_UNKNOWN) != 0)
            continue;

        if (state.dwEventState == state.dwCurrentState)
            continue;

        qCDebug(QT_NFC_PCSC) << Qt::hex << state.dwCurrentState << "=>" << state.dwEventState << ":"
                             << slot->name();

        state.dwCurrentState = state.dwEventState;
        slot->processStateChange(state.dwEventState, m_targetDetectionRunning);
    }
}

/*
    Remove slots that no longer need to be tracked.
*/
void QPcscManager::removeSlots()
{
    for (auto &state : m_slotStates) {
        auto slot = static_cast<QPcscSlot *>(state.pvUserData);
        Q_ASSERT(slot != nullptr);

        // Remove slots that no longer exist, or all slots without cards if
        // target detection is stopped.
        if ((state.dwEventState & SCARD_STATE_UNKNOWN) != 0
            || !(m_targetDetectionRunning || slot->hasCard())) {
            qCDebug(QT_NFC_PCSC) << "Removing slot:" << slot;
            state.dwEventState = SCARD_STATE_UNKNOWN;
            slot->invalidateInsertedCard();
            m_slots.remove(slot->name());
            slot->deleteLater();
            state.pvUserData = nullptr;
        }
    }

    // Remove state tracking entries for slots that no longer exist.
    m_slotStates.removeIf(
            [](const auto &state) { return (state.dwEventState & SCARD_STATE_UNKNOWN) != 0; });
}

/*
    Reads the system slot lists and marks slots that no longer exists, also
    creates new slot entries if target detection is currently running.
*/
void QPcscManager::updateSlotList()
{
    Q_ASSERT(m_hasContext);

#ifndef SCARD_AUTOALLOCATE
    // macOS does not support automatic allocation. Try using a fixed-size
    // buffer first, extending it if it is not sufficient.
#define LIST_READER_BUFFER_EXTRA 1024
    QPcscSlotName buf(nullptr);
    DWORD listSize = LIST_READER_BUFFER_EXTRA;
    buf.resize(listSize);
    QPcscSlotName::Ptr list = buf.ptr();

    auto ret = SCardListReaders(m_context, nullptr, list, &listSize);
#else
    QPcscSlotName::Ptr list;
    DWORD listSize = SCARD_AUTOALLOCATE;
    auto ret = SCardListReaders(m_context, nullptr, reinterpret_cast<QPcscSlotName::Ptr>(&list),
                                &listSize);
#endif

    if (ret == LONG(SCARD_E_NO_READERS_AVAILABLE)) {
        list = nullptr;
        ret = SCARD_S_SUCCESS;
    }
#ifndef SCARD_AUTOALLOCATE
    else if (ret == LONG(SCARD_E_INSUFFICIENT_BUFFER)) {
        // SCardListReaders() has set listSize to the required size. We add
        // extra space to reduce possibility of failure if the reader list has
        // changed since the last call.
        listSize += LIST_READER_BUFFER_EXTRA;
        buf.resize(listSize);
        list = buf.ptr();

        ret = SCardListReaders(m_context, nullptr, list, &listSize);
        if (ret == LONG(SCARD_E_NO_READERS_AVAILABLE)) {
            list = nullptr;
            ret = SCARD_S_SUCCESS;
        }
    }
#undef LIST_READER_BUFFER_EXTRA
#endif

    if (ret != SCARD_S_SUCCESS) {
        qCDebug(QT_NFC_PCSC) << "Failed to list readers:" << QPcsc::errorMessage(ret);
        return;
    }

#ifdef SCARD_AUTOALLOCATE
    auto freeList = qScopeGuard([this, list] {
        if (list) {
            Q_ASSERT(m_hasContext);
            SCardFreeMemory(m_context, list);
        }
    });
#endif

    QSet<QPcscSlotName> presentSlots;

    if (list != nullptr) {
        for (const auto *p = list; *p; p += QPcscSlotName::nameSize(p) + 1)
            presentSlots.insert(QPcscSlotName(p));
    }

    // Check current state list and mark slots that are not present anymore to
    // be removed later.
    for (auto &state : m_slotStates) {
        auto slot = static_cast<QPcscSlot *>(state.pvUserData);
        Q_ASSERT(slot != nullptr);

        if (presentSlots.contains(slot->name()))
            presentSlots.remove(slot->name());
        else
            state.dwEventState = SCARD_STATE_UNKNOWN;
    }

    if (!m_targetDetectionRunning)
        return;

    // Add new slots
    for (auto &&slotName : std::as_const(presentSlots)) {
        QPcscSlot *slot = new QPcscSlot(slotName, this);
        qCDebug(QT_NFC_PCSC) << "New slot:" << slot;

        m_slots[slotName] = slot;

        SCARD_READERSTATE state {};
        state.pvUserData = slot;
        state.szReader = slot->name().ptr();
        state.dwCurrentState = SCARD_STATE_UNAWARE;

        m_slotStates.append(state);
    }
}

bool QPcscManager::establishContext()
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;

    Q_ASSERT(!m_hasContext);

    LONG ret = SCardEstablishContext(SCARD_SCOPE_USER, nullptr, nullptr, &m_context);
    if (ret != SCARD_S_SUCCESS) {
        qCWarning(QT_NFC_PCSC) << "Failed to establish context:" << QPcsc::errorMessage(ret);
        return false;
    }
    m_hasContext = true;

    return true;
}

void QPcscManager::onStateUpdate()
{
    if (!m_hasContext) {
        if (!m_targetDetectionRunning) {
            m_stateUpdateTimer->stop();
            return;
        }

        if (!establishContext())
            return;
    }

    updateSlotList();
    removeSlots();

    if (m_slotStates.isEmpty()) {
        if (!m_targetDetectionRunning) {
            // Free the context if it is no longer needed to card tracking.
            SCardReleaseContext(m_context);
            m_hasContext = false;

            m_stateUpdateTimer->stop();
        }
        return;
    }

    // Both Windows and PCSCLite support interruptable continuos state detection
    // where SCardCancel() can be used to abort it from another thread.
    // But that introduces a problem of reliable cancelling of the status change
    // call and no other. Reliable use of SCardCancel() would probably require
    // some form of synchronization and polling, and would make the code much
    // more complicated.
    // Alternatively, the state detection code could run in a yet another thread
    // that will not need to be cancelled too often.
    // For simplicity, the current code just checks for status changes every
    // second.
    LONG ret = SCardGetStatusChange(m_context, 0, m_slotStates.data(), m_slotStates.size());

    if (ret == SCARD_S_SUCCESS || ret == LONG(SCARD_E_UNKNOWN_READER)) {
        processSlotUpdates();
        removeSlots();
    } else if (ret == LONG(SCARD_E_CANCELLED) || ret == LONG(SCARD_E_UNKNOWN_READER)
               || ret == LONG(SCARD_E_TIMEOUT)) {
        /* ignore */
    } else {
        qCWarning(QT_NFC_PCSC) << "SCardGetStatusChange failed:" << QPcsc::errorMessage(ret);

        // Unknown failure. It is likely that the current context will not
        // recover from it, so destroy it and try to create a new context at the
        // next iteration.
        Q_ASSERT(m_hasContext);
        m_hasContext = false;
        for (auto slot : std::as_const(m_slots)) {
            slot->invalidateInsertedCard();
            slot->deleteLater();
        }
        SCardReleaseContext(m_context);
        m_slots.clear();
        m_slotStates.clear();
    }
}

void QPcscManager::onStartTargetDetectionRequest(QNearFieldTarget::AccessMethod accessMethod)
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;

    m_requestedMethod = accessMethod;

    if (m_targetDetectionRunning)
        return;

    m_targetDetectionRunning = true;
    m_stateUpdateTimer->start();
}

void QPcscManager::onStopTargetDetectionRequest()
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
    m_targetDetectionRunning = false;
}

QPcscCard *QPcscManager::connectToCard(QPcscSlot *slot)
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;
    Q_ASSERT(slot != nullptr);
    Q_ASSERT(m_hasContext);

    SCARDHANDLE cardHandle;
    DWORD activeProtocol;

    LONG ret = SCardConnect(m_context, slot->name().ptr(), SCARD_SHARE_SHARED,
                            SCARD_PROTOCOL_T0 | SCARD_PROTOCOL_T1, &cardHandle, &activeProtocol);
    if (ret != SCARD_S_SUCCESS) {
        qCDebug(QT_NFC_PCSC) << "Failed to connect to card:" << QPcsc::errorMessage(ret);
        retryCardDetection(slot);
        return nullptr;
    }

    auto card = new QPcscCard(cardHandle, activeProtocol, this);
    auto uid = card->readUid();
    auto maxInputLength = card->readMaxInputLength();

    QNearFieldTarget::AccessMethods accessMethods = QNearFieldTarget::TagTypeSpecificAccess;
    if (card->supportsNdef())
        accessMethods |= QNearFieldTarget::NdefAccess;

    if (m_requestedMethod != QNearFieldTarget::UnknownAccess
        && (accessMethods & m_requestedMethod) == 0) {
        qCDebug(QT_NFC_PCSC) << "Dropping card without required access support";
        card->deleteLater();
        return nullptr;
    }

    if (!card->isValid()) {
        qCDebug(QT_NFC_PCSC) << "Card became invalid";
        card->deleteLater();

        retryCardDetection(slot);

        return nullptr;
    }

    Q_EMIT cardInserted(card, uid, accessMethods, maxInputLength);

    return card;
}

/*
    Setup states list so that the card detection for the given slot will
    be retried on the next iteration.

    This is useful to try to get cards working after reset.
*/
void QPcscManager::retryCardDetection(const QPcscSlot *slot)
{
    qCDebug(QT_NFC_PCSC) << Q_FUNC_INFO;

    for (auto &state : m_slotStates) {
        if (state.pvUserData == slot) {
            state.dwCurrentState = SCARD_STATE_UNAWARE;
            break;
        }
    }
}

QT_END_NAMESPACE