/*
    SPDX-FileCopyrightText: 2012 Lukáš Tinkl <ltinkl@redhat.com>

    SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
*/

#include "udisksmanager.h"
#include "udisks_debug.h"
#include "udisksdevicebackend.h"

#include <QDBusConnection>
#include <QDBusConnectionInterface>
#include <QDBusMetaType>
#include <QDBusObjectPath>
#include <QDomDocument>

#include "../shared/rootdevice.h"

using namespace Solid::Backends::UDisks2;
using namespace Solid::Backends::Shared;

Manager::Manager(QObject *parent)
    : Solid::Ifaces::DeviceManager(parent)
    , m_manager(QStringLiteral(UD2_DBUS_SERVICE), QStringLiteral(UD2_DBUS_PATH), QDBusConnection::systemBus())
{
    m_supportedInterfaces = {
        Solid::DeviceInterface::GenericInterface,
        Solid::DeviceInterface::Block,
        Solid::DeviceInterface::StorageAccess,
        Solid::DeviceInterface::StorageDrive,
        Solid::DeviceInterface::OpticalDrive,
        Solid::DeviceInterface::OpticalDisc,
        Solid::DeviceInterface::StorageVolume,
    };

    qDBusRegisterMetaType<QList<QDBusObjectPath>>();
    qDBusRegisterMetaType<QVariantMap>();
    qDBusRegisterMetaType<VariantMapMap>();
    qDBusRegisterMetaType<DBUSManagerStruct>();

    bool serviceFound = m_manager.isValid();
    if (!serviceFound) {
        // find out whether it will be activated automatically
        QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.freedesktop.DBus"), //
                                                              QStringLiteral("/org/freedesktop/DBus"),
                                                              QStringLiteral("org.freedesktop.DBus"),
                                                              QStringLiteral("ListActivatableNames"));

        QDBusReply<QStringList> reply = QDBusConnection::systemBus().call(message);
        if (reply.isValid() && reply.value().contains(QStringLiteral(UD2_DBUS_SERVICE))) {
            QDBusConnection::systemBus().interface()->startService(QStringLiteral(UD2_DBUS_SERVICE));
            serviceFound = true;
        }
    }

    if (serviceFound) {
        connect(&m_manager, SIGNAL(InterfacesAdded(QDBusObjectPath, VariantMapMap)), this, SLOT(slotInterfacesAdded(QDBusObjectPath, VariantMapMap)));
        connect(&m_manager, SIGNAL(InterfacesRemoved(QDBusObjectPath, QStringList)), this, SLOT(slotInterfacesRemoved(QDBusObjectPath, QStringList)));
    }
}

Manager::~Manager()
{
    while (!m_deviceCache.isEmpty()) {
        QString udi = m_deviceCache.takeFirst();
        DeviceBackend::destroyBackend(udi);
    }
}

QObject *Manager::createDevice(const QString &udi)
{
    if (udi == udiPrefix()) {
        RootDevice *root = new RootDevice(udi);

        root->setProduct(tr("Storage"));
        root->setDescription(tr("Storage devices"));
        root->setIcon(QStringLiteral("server-database")); // Obviously wasn't meant for that, but maps nicely in oxygen icon set :-p

        return root;
    } else if (deviceCache().contains(udi)) {
        return new Device(udi);
    } else {
        return nullptr;
    }
}

QStringList Manager::devicesFromQuery(const QString &parentUdi, Solid::DeviceInterface::Type type)
{
    QStringList result;
    const QStringList deviceList = deviceCache();

    if (!parentUdi.isEmpty()) {
        for (const QString &udi : deviceList) {
            Device device(udi);
            if (device.queryDeviceInterface(type) && device.parentUdi() == parentUdi) {
                result << udi;
            }
        }

        return result;
    } else if (type != Solid::DeviceInterface::Unknown) {
        for (const QString &udi : deviceList) {
            Device device(udi);
            if (device.queryDeviceInterface(type)) {
                result << udi;
            }
        }

        return result;
    }

    return deviceCache();
}

QStringList Manager::allDevices()
{
    m_deviceCache.clear();

    introspect(QStringLiteral(UD2_DBUS_PATH_BLOCKDEVICES), true /*checkOptical*/);
    introspect(QStringLiteral(UD2_DBUS_PATH_DRIVES));

    return m_deviceCache;
}

void Manager::introspect(const QString &path, bool checkOptical)
{
    QDBusMessage call =
        QDBusMessage::createMethodCall(QStringLiteral(UD2_DBUS_SERVICE), path, QStringLiteral(DBUS_INTERFACE_INTROSPECT), QStringLiteral("Introspect"));
    QDBusPendingReply<QString> reply = QDBusConnection::systemBus().call(call);

    if (reply.isValid()) {
        QDomDocument dom;
        dom.setContent(reply.value());
        QDomNodeList nodeList = dom.documentElement().elementsByTagName(QStringLiteral("node"));
        for (int i = 0; i < nodeList.count(); i++) {
            QDomElement nodeElem = nodeList.item(i).toElement();
            if (!nodeElem.isNull() && nodeElem.hasAttribute(QStringLiteral("name"))) {
                const QString name = nodeElem.attribute(QStringLiteral("name"));
                const QString udi = path + QStringLiteral("/") + name;

                // Optimization, a loop device cannot really have a physical drive associated with it
                if (checkOptical && !name.startsWith(QLatin1String("loop"))) {
                    Device device(udi);
                    if (device.mightBeOpticalDisc()) {
                        QDBusConnection::systemBus().connect(QStringLiteral(UD2_DBUS_SERVICE), //
                                                             udi,
                                                             QStringLiteral(DBUS_INTERFACE_PROPS),
                                                             QStringLiteral("PropertiesChanged"),
                                                             this,
                                                             SLOT(slotMediaChanged(QDBusMessage)));
                        if (!device.isOpticalDisc()) { // skip empty CD disc
                            continue;
                        }
                    }
                }

                m_deviceCache.append(udi);
            }
        }
    } else {
        qCWarning(UDISKS2) << "Failed enumerating UDisks2 objects:" << reply.error().name() << "\n" << reply.error().message();
    }
}

QSet<Solid::DeviceInterface::Type> Manager::supportedInterfaces() const
{
    return m_supportedInterfaces;
}

QString Manager::udiPrefix() const
{
    return QStringLiteral(UD2_UDI_DISKS_PREFIX);
}

void Manager::slotInterfacesAdded(const QDBusObjectPath &object_path, const VariantMapMap &interfaces_and_properties)
{
    const QString udi = object_path.path();

    /* Ignore jobs */
    if (udi.startsWith(QStringLiteral(UD2_DBUS_PATH_JOBS))) {
        return;
    }

    qCDebug(UDISKS2) << udi << "has new interfaces:" << interfaces_and_properties.keys();

    // If device gained an org.freedesktop.UDisks2.Block interface, we
    // should check if it is an optical drive, in order to properly
    // register mediaChanged event handler with newly-plugged external
    // drives
    if (interfaces_and_properties.contains(QStringLiteral("org.freedesktop.UDisks2.Block"))) {
        Device device(udi);
        if (device.mightBeOpticalDisc()) {
            QDBusConnection::systemBus().connect(QStringLiteral(UD2_DBUS_SERVICE), //
                                                 udi,
                                                 QStringLiteral(DBUS_INTERFACE_PROPS),
                                                 QStringLiteral("PropertiesChanged"),
                                                 this,
                                                 SLOT(slotMediaChanged(QDBusMessage)));
        }
    }

    updateBackend(udi);

    // new device, we don't know it yet
    if (!m_deviceCache.contains(udi)) {
        m_deviceCache.append(udi);
        Q_EMIT deviceAdded(udi);
    }
    // re-emit in case of 2-stage devices like N9 or some Android phones
    else if (m_deviceCache.contains(udi) && interfaces_and_properties.keys().contains(QStringLiteral(UD2_DBUS_INTERFACE_FILESYSTEM))) {
        Q_EMIT deviceAdded(udi);
    }
}

void Manager::slotInterfacesRemoved(const QDBusObjectPath &object_path, const QStringList &interfaces)
{
    const QString udi = object_path.path();
    if (udi.isEmpty()) {
        return;
    }

    /* Ignore jobs */
    if (udi.startsWith(QStringLiteral(UD2_DBUS_PATH_JOBS))) {
        return;
    }

    qCDebug(UDISKS2) << udi << "lost interfaces:" << interfaces;

    /*
     * Determine left interfaces. The device backend may have processed the
     * InterfacesRemoved signal already, but the result set is the same
     * independent if the backend or the manager processes the signal first.
     */
    Device device(udi);
    const QStringList ifaceList = device.interfaces();
    QSet<QString> leftInterfaces(ifaceList.begin(), ifaceList.end());
    leftInterfaces.subtract(QSet<QString>(interfaces.begin(), interfaces.end()));

    if (leftInterfaces.isEmpty()) {
        // remove the device if the last interface is removed
        Q_EMIT deviceRemoved(udi);
        m_deviceCache.removeAll(udi);
        DeviceBackend::destroyBackend(udi);
    } else {
        /*
         * Changes in the interface composition may change if a device
         * matches a Predicate. We have to do a remove-and-readd cycle
         * as there is no dedicated signal for Predicate reevaluation.
         */
        Q_EMIT deviceRemoved(udi);
        Q_EMIT deviceAdded(udi);
    }
}

void Manager::slotMediaChanged(const QDBusMessage &msg)
{
    const QVariantMap properties = qdbus_cast<QVariantMap>(msg.arguments().at(1));

    if (!properties.contains(QStringLiteral("Size"))) { // react only on Size changes
        return;
    }

    const QString udi = msg.path();
    updateBackend(udi);
}

const QStringList &Manager::deviceCache()
{
    if (m_deviceCache.isEmpty()) {
        allDevices();
    }

    return m_deviceCache;
}

void Manager::updateBackend(const QString &udi)
{
    DeviceBackend *backend = DeviceBackend::backendForUDI(udi);
    if (!backend) {
        return;
    }

    // This doesn't emit "changed" signals. Signals are emitted later by DeviceBackend's slots
    backend->allProperties();

    QVariant driveProp = backend->prop(QStringLiteral("Drive"));
    if (!driveProp.isValid()) {
        return;
    }

    QDBusObjectPath drivePath = qdbus_cast<QDBusObjectPath>(driveProp);
    DeviceBackend *driveBackend = DeviceBackend::backendForUDI(drivePath.path(), false);
    if (!driveBackend) {
        return;
    }

    driveBackend->invalidateProperties();
}

#include "moc_udisksmanager.cpp"
