// Copyright (C) 2016 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 "qaccessiblecache_p.h"

#include <QtCore/qdebug.h>

#include <QtCore/qloggingcategory.h>

#include <private/qguiapplication_p.h>

#if QT_CONFIG(accessibility)

QT_BEGIN_NAMESPACE

Q_STATIC_LOGGING_CATEGORY(lcAccessibilityCache, "qt.accessibility.cache");

/*!

    \class QAccessibleCache

    \internal

    \brief Maintains a cache of accessible interfaces.

*/

static QAccessibleCache *accessibleCache = nullptr;

static bool inCacheDestructor = false;

static void cleanupAccessibleCache()

{

    delete accessibleCache;

    accessibleCache = nullptr;

}

QAccessibleObjectDestroyedEvent::~QAccessibleObjectDestroyedEvent()

{

}

QAccessibleCache::~QAccessibleCache()

{

    inCacheDestructor = true;

    for (QAccessible::Id id: idToInterface.keys())

        deleteInterface(id);

}

QAccessibleCache *QAccessibleCache::instance()

{

    if (!accessibleCache) {

        accessibleCache = new QAccessibleCache;

        qAddPostRoutine(cleanupAccessibleCache);

    }

    return accessibleCache;

}

/*

  The ID is always in the range [INT_MAX+1, UINT_MAX].

  This makes it easy on windows to reserve the positive integer range

  for the index of a child and not clash with the unique ids.

*/

QAccessible::Id QAccessibleCache::acquireId() const

{

    static const QAccessible::Id FirstId = QAccessible::Id(INT_MAX) + 1;

    static QAccessible::Id nextId = FirstId;

    while (idToInterface.contains(nextId)) {

        // (wrap back when when we reach UINT_MAX - 1)

        // -1 because on Android -1 is taken for the "View" so just avoid it completely for consistency

        if (nextId == UINT_MAX - 1)

            nextId = FirstId;

        else

            ++nextId;

    }

    return nextId++;

}

QAccessibleInterface *QAccessibleCache::interfaceForId(QAccessible::Id id) const

{

    return idToInterface.value(id);

}

QAccessible::Id QAccessibleCache::idForInterface(QAccessibleInterface *iface) const

{

    return interfaceToId.value(iface);

}

QAccessible::Id QAccessibleCache::idForObject(QObject *obj) const

{

    if (obj) {

        const QMetaObject *mo = obj->metaObject();

        for (auto pair : objectToId.values(obj)) {

            if (pair.second == mo) {

                return pair.first;

            }

        }

    }

    return 0;

}

/*!

 * \internal

 *

 * returns true if the cache has an interface for the object and its corresponding QMetaObject

 */

bool QAccessibleCache::containsObject(QObject *obj) const

{

    if (obj) {

        const QMetaObject *mo = obj->metaObject();

        for (auto pair : objectToId.values(obj)) {

            if (pair.second == mo) {

                return true;

            }

        }

    }

    return false;

}

QAccessible::Id QAccessibleCache::insert(QObject *object, QAccessibleInterface *iface) const

{

    Q_ASSERT(iface);

    Q_UNUSED(object);

    // object might be 0

    Q_ASSERT(!containsObject(object));

    Q_ASSERT_X(!interfaceToId.contains(iface), "", "Accessible interface inserted into cache twice!");

    QAccessible::Id id = acquireId();

    QObject *obj = iface->object();

    Q_ASSERT(object == obj);

    if (obj) {

        objectToId.insert(obj, std::pair(id, obj->metaObject()));

        connect(obj, &QObject::destroyed, this, &QAccessibleCache::objectDestroyed);

    }

    idToInterface.insert(id, iface);

    interfaceToId.insert(iface, id);

    qCDebug(lcAccessibilityCache) << "insert - id:" << id << " iface:" << iface;

    return id;

}

void QAccessibleCache::objectDestroyed(QObject* obj)

{

    /*

    In some cases we might add a not fully-constructed object to the cache. This might happen with

    for instance QWidget subclasses that are in the construction phase. If updateAccessibility() is

    called in the constructor of QWidget (directly or indirectly), it will end up asking for the

    classname of that widget in order to know which accessibility interface subclass the

    accessibility factory should instantiate and return. However, since that requires a virtual

    call to metaObject(), it will return the metaObject() of QWidget (not for the subclass), and so

    the factory will ultimately return a rather generic QAccessibleWidget instead of a more

    specialized interface. Even though it is a "incomplete" interface it will be put in the cache

    and it will be usable as if the object is a widget. In order for the cache to not just return

    the same generic QAccessibleWidget for that object, we have to check if the cache matches

    the objects QMetaObject. We therefore use a QMultiHash and also store the QMetaObject * in

    the value. We therefore might potentially store several values for the corresponding object

    (in theory one for each level in the class inheritance chain)

    This means that after the object have been fully constructed, we will at some point again query

    for the interface for the same object, but now its metaObject() returns the correct

    QMetaObject, so it won't return the QAccessibleWidget that is associated with the object in the

    cache. Instead it will go to the factory and create the _correct_ specialized interface for the

    object. If that succeeded, it will also put that entry in the cache. We will therefore in those

    cases insert *two* cache entries for the same object (using QMultiHash). They both must live

    until the object is destroyed.

    So when the object is destroyed we might have to delete two entries from the cache.

    */

    for (auto pair : objectToId.values(obj)) {

        QAccessible::Id id = pair.first;

        Q_ASSERT_X(idToInterface.contains(id), "", "QObject with accessible interface deleted, where interface not in cache!");

        deleteInterface(id, obj);

    }

}

void QAccessibleCache::sendObjectDestroyedEvent(QObject *obj)

{

    for (auto pair : objectToId.values(obj)) {

        QAccessible::Id id = pair.first;

        Q_ASSERT_X(idToInterface.contains(id), "", "QObject with accessible interface deleted, where interface not in cache!");

        QAccessibleObjectDestroyedEvent event(id);

        QAccessible::updateAccessibility(&event);

    }

}

void QAccessibleCache::deleteInterface(QAccessible::Id id, QObject *obj)

{

    const auto it = idToInterface.find(id);

    if (it == idToInterface.end()) // the interface may be deleted already

        return;

    QAccessibleInterface *iface = *it;

    qCDebug(lcAccessibilityCache) << "delete - id:" << id << " iface:" << iface;

    if (!iface) {

        idToInterface.erase(it);

        return;

    }

    // QObjects send this from their destructors, but the interfaces

    // with no associated object call deleteInterface directly.

    if (!inCacheDestructor && !obj && !iface->object()) {

        if (QGuiApplicationPrivate::is_app_running && !QGuiApplicationPrivate::is_app_closing && QAccessible::isActive()) {

            QAccessibleObjectDestroyedEvent event(id);

            QAccessible::updateAccessibility(&event);

        }

    }

    idToInterface.erase(it);

    interfaceToId.take(iface);

    if (!obj)

        obj = iface->object();

    if (obj)

        objectToId.remove(obj);

    delete iface;

#ifdef Q_OS_APPLE

    removeAccessibleElement(id);

#endif

}

QT_END_NAMESPACE

#include "moc_qaccessiblecache_p.cpp"

#endif