/*
 *  Main implementation for KIO-MTP
 *  SPDX-FileCopyrightText: 2012 Philipp Schmidt <philschmidt@gmx.net>
 *  SPDX-FileCopyrightText: 2018 Andreas Krutzler <andreas.krutzler@gmx.net>
 *  SPDX-FileCopyrightText: 2022 Harald Sitter <sitter@kde.org>
 *
 *  SPDX-License-Identifier: GPL-2.0-or-later
 */

#include "kio_mtp.h"
#include "kio_mtp_debug.h"
#include "udsentry_compat.h"

// #include <KComponentData>
#include <QCoreApplication>
#include <QDateTime>
#include <QFileInfo>
#include <QTemporaryFile>
#include <QTimer>

#include <sys/types.h>
#include <utime.h>

#include "config-mtp.h"
#include "kmtpdeviceinterface.h"
#include "kmtpstorageinterface.h"
#include "listerinterface.h"

// Pseudo plugin class to embed meta data
class KIOPluginForMetaData : public QObject
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "org.kde.kio.worker.mtp" FILE "mtp.json")
};

static UDSEntry getEntry(const KMTPDeviceInterface *device)
{
    UDSEntry entry;
    KIOExtras::insertStrings(entry,
                             {
                                 {UDSEntry::UDS_NAME, device->friendlyName()},
                                 {UDSEntry::UDS_ICON_NAME, QStringLiteral("multimedia-player")},
                                 {UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory")},
                             });
    KIOExtras::insertNumbers(entry,
                             {
                                 {UDSEntry::UDS_FILE_TYPE, S_IFDIR},
                                 {UDSEntry::UDS_ACCESS, S_IRUSR | S_IRGRP | S_IROTH | S_IXUSR | S_IXGRP | S_IXOTH},
                             });
    return entry;
}

static UDSEntry getEntry(const KMTPStorageInterface *storage)
{
    UDSEntry entry;
    KIOExtras::insertStrings(entry,
                             {
                                 {UDSEntry::UDS_NAME, storage->description()},
                                 {UDSEntry::UDS_ICON_NAME, QStringLiteral("drive-removable-media")},
                                 {UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory")},
                             });
    KIOExtras::insertNumbers(entry,
                             {
                                 {UDSEntry::UDS_FILE_TYPE, S_IFDIR},
                                 {UDSEntry::UDS_ACCESS, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH},
                             });
    return entry;
}

static UDSEntry getEntry(const KMTPFile &file)
{
    UDSEntry entry;
    const bool isFolder = file.isFolder();

    KIOExtras::insertStrings(entry,
                             {
                                 {UDSEntry::UDS_NAME, file.filename()},
                                 {UDSEntry::UDS_MIME_TYPE, file.filetype()},
                             });

    const auto modificationDate = file.modificationdate();
    KIOExtras::insertNumbers(entry,
                             {
                                 {UDSEntry::UDS_FILE_TYPE, isFolder ? S_IFDIR : S_IFREG},
                                 {UDSEntry::UDS_ACCESS, isFolder ? S_IRWXU | S_IRWXG | S_IRWXO : S_IRUSR | S_IRGRP | S_IROTH | S_IXUSR | S_IXGRP | S_IXOTH},
                                 {UDSEntry::UDS_INODE, file.itemId()},
                                 {UDSEntry::UDS_ACCESS_TIME, modificationDate},
                                 {UDSEntry::UDS_MODIFICATION_TIME, modificationDate},
                                 {UDSEntry::UDS_CREATION_TIME, modificationDate},
                             });
    if (!isFolder) {
        entry.fastInsert(UDSEntry::UDS_SIZE, file.filesize());
    }
    return entry;
}

static QString urlDirectory(const QUrl &url, bool appendTrailingSlash = false)
{
    if (!appendTrailingSlash) {
        return url.adjusted(QUrl::StripTrailingSlash | QUrl::RemoveFilename).path();
    }
    return url.adjusted(QUrl::RemoveFilename).path();
}

static QString urlFileName(const QUrl &url)
{
    return url.fileName();
}

static QString convertPath(const QString &workerPath)
{
    return workerPath.section(QLatin1Char('/'), 3, -1, QString::SectionIncludeLeadingSep);
}

//////////////////////////////////////////////////////////////////////////////
///////////////////////////// Worker Implementation ///////////////////////////
//////////////////////////////////////////////////////////////////////////////

extern "C" int Q_DECL_EXPORT kdemain(int argc, char **argv)
{
    QCoreApplication app(argc, argv);
    app.setApplicationName(QLatin1String("kio_mtp"));

    if (argc != 4) {
        fprintf(stderr, "Usage: kio_mtp protocol domain-socket1 domain-socket2\n");
        exit(-1);
    }

    MTPWorker worker(argv[2], argv[3]);

    worker.dispatchLoop();

    qCDebug(LOG_KIO_MTP) << "Worker EventLoop ended";

    return 0;
}

MTPWorker::MTPWorker(const QByteArray &pool, const QByteArray &app)
    : WorkerBase("mtp", pool, app)
{
    qCDebug(LOG_KIO_MTP) << "Worker started";
    qCDebug(LOG_KIO_MTP) << "Connected to kiod module:" << m_kmtpDaemon.isValid();
}

MTPWorker::~MTPWorker()
{
    qCDebug(LOG_KIO_MTP) << "Worker destroyed";
}

enum MTPWorker::Url MTPWorker::checkUrl(const QUrl &url)
{
    if (url.path().startsWith(QLatin1String("udi="))) {
        const QString udi = url.adjusted(QUrl::StripTrailingSlash).path().remove(0, 4);

        qCDebug(LOG_KIO_MTP) << "udi = " << udi;

        const KMTPDeviceInterface *device = m_kmtpDaemon.deviceFromUdi(udi);
        if (!device) {
            return Url::NotFound;
        }

        QUrl newUrl;
        newUrl.setScheme(QStringLiteral("mtp"));
        newUrl.setPath(QLatin1Char('/') + device->friendlyName());
        redirection(newUrl);

        return Url::Redirected;
    }
    if (url.path().startsWith(QLatin1Char('/'))) {
        return Url::Valid;
    }
    if (url.scheme() == QLatin1String("mtp") && url.path().isEmpty()) {
        QUrl newUrl = url;
        newUrl.setPath(QLatin1String("/"));
        redirection(newUrl);

        return Url::Redirected;
    }
    return Url::Invalid;
}

WorkerResult MTPWorker::listDir(const QUrl &url)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
        return WorkerResult::pass();
    case Url::NotFound:
        return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    // list '.' entry, otherwise files cannot be pasted to empty folders
    KIO::UDSEntry entry;
    entry.fastInsert(KIO::UDSEntry::UDS_NAME, QStringLiteral("."));
    KIOExtras::insertNumbers(entry,
                             {
                                 {KIO::UDSEntry::UDS_FILE_TYPE, S_IFDIR},
                                 {KIO::UDSEntry::UDS_SIZE, 0},
                                 {KIO::UDSEntry::UDS_ACCESS, S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IWGRP | S_IXGRP | S_IROTH | S_IXOTH},
                             });
    listEntry(entry);

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);
    // list devices
    if (pathItems.isEmpty()) {
        qCDebug(LOG_KIO_MTP) << "Root directory, listing devices";

        const auto devices = m_kmtpDaemon.devices();
        totalSize(filesize_t(devices.size()));

        for (const KMTPDeviceInterface *device : devices) {
            listEntry(getEntry(device));
        }

        qCDebug(LOG_KIO_MTP) << "[SUCCESS] :: Devices:" << devices.size();
        return WorkerResult::pass();
    }

    // traverse into device
    KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
    if (!mtpDevice) {
        // device not found
        qCDebug(LOG_KIO_MTP) << "[ERROR] :: Device";
        return WorkerResult::fail(ERR_CANNOT_ENTER_DIRECTORY, url.path());
    }

    // list storage media
    if (pathItems.size() == 1) {
        qCDebug(LOG_KIO_MTP) << "Listing storage media for device " << pathItems.first();

        const auto storages = mtpDevice->storages();
        totalSize(filesize_t(storages.size()));

        if (storages.count() <= 0) {
            return WorkerResult::fail(ERR_WORKER_DEFINED,
                                      i18nc("Message shown when attempting to access an MTP device that is not fully accessible yet",
                                            "Could not access device. Make sure it is unlocked, and tap \"Allow\" on the popup on its screen. If that does not "
                                            "work, make sure MTP is enabled in its USB connection settings."));
        }

        for (KMTPStorageInterface *storage : storages) {
            listEntry(getEntry(storage));
        }
        qCDebug(LOG_KIO_MTP) << "[SUCCESS] :: Storage media:" << storages.count();
        return WorkerResult::pass();
    }

    // list files and folders
    const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
    if (!storage) {
        // storage not found
        qCDebug(LOG_KIO_MTP) << "[ERROR] :: Storage";
        return WorkerResult::fail(ERR_CANNOT_ENTER_DIRECTORY, url.path());
    }

    const QString path = convertPath(url.path());

#ifdef HAVE_LIBMTP_Get_Children
    const auto pathVariant = storage->getFilesAndFolders2(path);
    if (std::holds_alternative<QDBusError>(pathVariant)) {
        qCWarning(LOG_KIO_MTP) << "[ERROR] :: Failed to get lister dbus path" << std::get<QDBusError>(pathVariant);
        return WorkerResult::fail();
    }
    Q_ASSERT(std::holds_alternative<QDBusObjectPath>(pathVariant));

    OrgKdeKmtpListerInterface lister(QStringLiteral("org.kde.kmtpd5"), std::get<QDBusObjectPath>(pathVariant).path(), QDBusConnection::sessionBus(), this);

    QEventLoop loop;
    connect(&lister, &OrgKdeKmtpListerInterface::entry, this, [this, &lister](const KMTPFile &file) {
        listEntries({getEntry(file)});
        if (wasKilled()) {
            lister.abort(); // issues finished which causes the loop to quit
        }
    });
    connect(&lister, &OrgKdeKmtpListerInterface::finished, &loop, &QEventLoop::quit);

    lister.run();
    loop.exec();

    qCDebug(LOG_KIO_MTP) << "[SUCCESS]";
    return WorkerResult::pass();
#else
    int result = 0;
    const KMTPFileList files = storage->getFilesAndFolders(path, result);

    switch (result) {
    case 0:
        for (const KMTPFile &file : files) {
            listEntry(getEntry(file));
        }

        qCDebug(LOG_KIO_MTP) << "[SUCCESS] :: Files:" << files.count();
        return WorkerResult::pass();
    case 2:
        return WorkerResult::fail(ERR_IS_FILE, url.path());
    }
    // path not found
    return WorkerResult::fail(ERR_CANNOT_ENTER_DIRECTORY, url.path());
#endif
}

WorkerResult MTPWorker::stat(const QUrl &url)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
        return WorkerResult::pass();
    case Url::NotFound:
        return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);
    UDSEntry entry;
    // root
    if (pathItems.size() < 1) {
        KIOExtras::insertStrings(entry,
                                 {
                                     {UDSEntry::UDS_NAME, QStringLiteral("mtp:///")},
                                     {UDSEntry::UDS_MIME_TYPE, QStringLiteral("inode/directory")},
                                 });
        KIOExtras::insertNumbers(entry,
                                 {
                                     {UDSEntry::UDS_FILE_TYPE, S_IFDIR},
                                     {UDSEntry::UDS_ACCESS, S_IRUSR | S_IRGRP | S_IROTH | S_IXUSR | S_IXGRP | S_IXOTH},
                                 });
    } else {
        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
        if (mtpDevice) {
            // device
            if (pathItems.size() < 2) {
                entry = getEntry(mtpDevice);
            } else {
                const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
                if (storage) {
                    // storage
                    if (pathItems.size() < 3) {
                        entry = getEntry(storage);
                    }
                    // folder/file
                    else {
                        const KMTPFile file = storage->getFileMetadata(convertPath(url.path()));
                        if (file.isValid()) {
                            entry = getEntry(file);
                        } else {
                            return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
                        }
                    }
                } else {
                    return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
                }
            }
        } else {
            return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
        }
    }

    statEntry(entry);
    return WorkerResult::pass();
}

WorkerResult MTPWorker::mimetype(const QUrl &url)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
        return WorkerResult::pass();
    case Url::NotFound:
        return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);
    if (pathItems.size() > 2) {
        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
            if (storage) {
                const KMTPFile file = storage->getFileMetadata(convertPath(url.path()));
                if (file.isValid()) {
                    // NOTE the difference between calling mimetype and mimeType
                    mimeType(file.filetype());
                    return WorkerResult::pass();
                }
            }
        }
    } else {
        mimeType(QStringLiteral("inode/directory"));
        return WorkerResult::pass();
    }

    return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
}

WorkerResult MTPWorker::get(const QUrl &url)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
    case Url::NotFound:
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);

    // file
    if (pathItems.size() > 2) {
        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
            if (storage) {
                const QString path = convertPath(url.path());
                const KMTPFile source = storage->getFileMetadata(path);
                if (!source.isValid()) {
                    return WorkerResult::fail(KIO::ERR_DOES_NOT_EXIST, url.path());
                }

                mimeType(source.filetype());
                totalSize(source.filesize());

                int result = storage->getFileToHandler(path);
                if (result) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_READ, url.path());
                }

                QEventLoop loop;
                connect(storage, &KMTPStorageInterface::dataReady, &loop, [this](const QByteArray &data) {
                    MTPWorker::data(data);
                });
                connect(storage, &KMTPStorageInterface::copyFinished, &loop, &QEventLoop::exit);
                result = loop.exec();

                qCDebug(LOG_KIO_MTP) << "data received";

                if (result) {
                    return WorkerResult::fail(ERR_CANNOT_READ, url.path());
                }

                data(QByteArray());
                return WorkerResult::pass();
            }
        }
    } else {
        return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, url.path());
    }
    return WorkerResult::fail(ERR_CANNOT_READ, url.path());
}

WorkerResult MTPWorker::put(const QUrl &url, int, JobFlags flags)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
    case Url::NotFound:
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList destItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);

    // can't copy to root or device, needs storage
    if (destItems.size() < 2) {
        return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, url.path());
    }

    // we need to get the entire file first, then we can upload
    qCDebug(LOG_KIO_MTP) << "use temp file";

    QTemporaryFile temp;
    if (temp.open()) {
        QByteArray buffer;
        int len = 0;

        do {
            dataReq();
            len = readData(buffer);
            temp.write(buffer);
        } while (len > 0);

        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(destItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(destItems.at(1));
            if (storage) {
                const QString destinationPath = convertPath(url.path());

                // check if the file already exists on the device
                const KMTPFile destinationFile = storage->getFileMetadata(destinationPath);
                if (destinationFile.isValid()) {
                    if (flags & KIO::Overwrite) {
                        // delete existing file on the device
                        const int result = storage->deleteObject(destinationPath);
                        if (result) {
                            return WorkerResult::fail(ERR_CANNOT_DELETE, url.path());
                        }
                    } else {
                        return WorkerResult::fail(ERR_FILE_ALREADY_EXIST, url.path());
                    }
                }

                totalSize(quint64(temp.size()));

                QDBusUnixFileDescriptor descriptor(temp.handle());
                int result = storage->sendFileFromFileDescriptor(descriptor, destinationPath);
                if (result) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_WRITE, urlFileName(url));
                }

                result = waitForCopyOperation(storage);
                processedSize(quint64(temp.size()));
                temp.close();

                switch (result) {
                case 0:
                    qCDebug(LOG_KIO_MTP) << "data sent";
                    return WorkerResult::pass();
                case 2:
                    return WorkerResult::fail(ERR_IS_FILE, urlDirectory(url));
                }

                return WorkerResult::fail(KIO::ERR_CANNOT_WRITE, urlFileName(url));
            }
        }
    }

    return WorkerResult::fail(KIO::ERR_CANNOT_WRITE, urlFileName(url));
}

WorkerResult MTPWorker::copy(const QUrl &src, const QUrl &dest, int, JobFlags flags)
{
    if (src.scheme() == QLatin1String("mtp") && dest.scheme() == QLatin1String("mtp")) {
        qCDebug(LOG_KIO_MTP) << "Copy on device: Not supported";
        // MTP doesn't support moving files directly on the device, so we have to download and then upload...

        return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, i18n("Cannot copy/move files on the device itself"));
    }
    if (src.scheme() == QLatin1String("file") && dest.scheme() == QLatin1String("mtp")) {
        // copy from filesystem to the device

        switch (checkUrl(dest)) {
        case Url::Valid:
            break;
        case Url::NotFound:
            return WorkerResult::fail(ERR_DOES_NOT_EXIST, src.path());
        case Url::Redirected:
        case Url::Invalid:
            return WorkerResult::fail(ERR_MALFORMED_URL, dest.path());
        }

        QStringList destItems = dest.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);

        // can't copy to root or device, needs storage
        if (destItems.size() < 2) {
            return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, dest.path());
        }

        qCDebug(LOG_KIO_MTP) << "Copy file " << urlFileName(src) << "from filesystem to device" << urlDirectory(src, true) << urlDirectory(dest, true);

        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(destItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(destItems.at(1));
            if (storage) {
                const QString destinationPath = convertPath(dest.path());

                // check if the file already exists on the device
                const KMTPFile destinationFile = storage->getFileMetadata(destinationPath);
                if (destinationFile.isValid()) {
                    if (flags & KIO::Overwrite) {
                        // delete existing file on the device
                        const int result = storage->deleteObject(destinationPath);
                        if (result) {
                            return WorkerResult::fail(ERR_CANNOT_DELETE, dest.path());
                        }
                    } else {
                        return WorkerResult::fail(ERR_FILE_ALREADY_EXIST, dest.path());
                    }
                }

                QFile srcFile(src.path());
                if (!srcFile.open(QIODevice::ReadOnly)) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_OPEN_FOR_READING, src.path());
                }

                qCDebug(LOG_KIO_MTP) << "Sending file" << srcFile.fileName() << "with size" << srcFile.size();

                totalSize(quint64(srcFile.size()));

                QDBusUnixFileDescriptor descriptor(srcFile.handle());
                int result = storage->sendFileFromFileDescriptor(descriptor, destinationPath);
                if (result) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_WRITE, urlFileName(dest));
                }

                result = waitForCopyOperation(storage);
                processedSize(quint64(srcFile.size()));
                srcFile.close();

                if (result) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_WRITE, urlFileName(dest));
                }

                qCDebug(LOG_KIO_MTP) << "Sent file";
                return WorkerResult::pass();
            }
        }
        return WorkerResult::fail(KIO::ERR_CANNOT_WRITE, urlFileName(src));
    }
    if (src.scheme() == QLatin1String("mtp") && dest.scheme() == QLatin1String("file")) {
        // copy from the device to filesystem

        switch (checkUrl(src)) {
        case Url::Valid:
            break;
        case Url::NotFound:
            return WorkerResult::fail(ERR_DOES_NOT_EXIST, src.toDisplayString());
        case Url::Redirected:
        case Url::Invalid:
            return WorkerResult::fail(ERR_MALFORMED_URL, src.toDisplayString());
        }

        qCDebug(LOG_KIO_MTP) << "Copy file" << urlFileName(src) << "from device to filesystem" << urlDirectory(src, true) << urlDirectory(dest, true);

        QFileInfo destination(dest.path());

        if (!(flags & KIO::Overwrite) && destination.exists()) {
            return WorkerResult::fail(ERR_FILE_ALREADY_EXIST, dest.path());
        }

        const QStringList srcItems = src.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);

        // can't copy to root or device, needs storage
        if (srcItems.size() < 2) {
            return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, src.path());
        }

        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(srcItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(srcItems.at(1));
            if (storage) {
                QFile destFile(dest.path());
                if (!destFile.open(QIODevice::Truncate | QIODevice::WriteOnly)) {
                    return WorkerResult::fail(KIO::ERR_WRITE_ACCESS_DENIED, dest.path());
                }

                const KMTPFile source = storage->getFileMetadata(convertPath(src.path()));
                if (!source.isValid()) {
                    return WorkerResult::fail(KIO::ERR_DOES_NOT_EXIST, src.path());
                }

                totalSize(source.filesize());

                QDBusUnixFileDescriptor descriptor(destFile.handle());
                int result = storage->getFileToFileDescriptor(descriptor, convertPath(src.path()));
                if (result) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_READ, urlFileName(src));
                }

                result = waitForCopyOperation(storage);
                processedSize(quint64(source.filesize()));
                destFile.close();

                if (result) {
                    return WorkerResult::fail(KIO::ERR_CANNOT_READ, urlFileName(src));
                }

                // set correct modification time
                struct ::utimbuf times;
                times.actime = QDateTime::currentDateTime().toSecsSinceEpoch();
                times.modtime = source.modificationdate();

                ::utime(dest.path().toUtf8().data(), &times);

                qCDebug(LOG_KIO_MTP) << "Received file";
                return WorkerResult::pass();
            }
        }
        return WorkerResult::fail(KIO::ERR_CANNOT_READ, urlFileName(src));
    }
    return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, {});
}

WorkerResult MTPWorker::mkdir(const QUrl &url, int)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
    case Url::NotFound:
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);
    if (pathItems.size() > 2) {
        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
            if (storage) {
                // TODO: folder already exists
                const quint32 itemId = storage->createFolder(convertPath(url.path()));
                if (itemId) {
                    return WorkerResult::pass();
                }
            }
        }
    }
    return WorkerResult::fail(ERR_CANNOT_MKDIR, url.path());
}

WorkerResult MTPWorker::del(const QUrl &url, bool)
{
    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
    case Url::NotFound:
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);
    if (pathItems.size() >= 2) {
        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
            if (storage) {
                const int result = storage->deleteObject(convertPath(url.path()));
                if (!result) {
                    return WorkerResult::pass();
                }
            }
        }
    }
    return WorkerResult::fail(ERR_CANNOT_DELETE, url.path());
}

WorkerResult MTPWorker::rename(const QUrl &src, const QUrl &dest, JobFlags flags)
{
    for (const auto &url : {src, dest}) {
        switch (checkUrl(src)) {
        case Url::Valid:
            break;
        case Url::Redirected:
        case Url::NotFound:
        case Url::Invalid:
            return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
        }
    }

    if (src.scheme() != QLatin1String("mtp")) {
        // Kate: when editing files directly on the device and the user wants to save the changes,
        // Kate tries to move the file from /tmp/xxx to the MTP device which is not supported.
        // The ERR_UNSUPPORTED_ACTION error tells Kate to copy the file instead of moving.
        return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, src.path());
    }

    const QStringList srcItems = src.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);
    KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(srcItems.first());
    if (!mtpDevice) {
        return WorkerResult::fail(ERR_CANNOT_RENAME, src.path());
    }

    // rename Device
    if (srcItems.size() == 1) {
        if (mtpDevice->setFriendlyName(urlFileName(dest)) != 0) {
            return WorkerResult::fail(ERR_CANNOT_RENAME, src.path());
        }
        return WorkerResult::pass();
    }

    // rename Storage
    if (srcItems.size() == 2) {
        return WorkerResult::fail(ERR_CANNOT_RENAME, src.path());
    }

    // rename across folder boundary -> let KIO fall back to get-put instead.
    // There is LIBMTP_Move_Object but it's supposedly not supported on all devices. Plus get-put requires no extra code.
    const auto srcDir = QFileInfo(src.path()).dir().path();
    const auto dstDir = QFileInfo(dest.path()).dir().path();
    if (srcDir != dstDir) {
        return WorkerResult::fail(ERR_UNSUPPORTED_ACTION, src.path());
    }

    // rename file or folder
    const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(srcItems.at(1));
    if (!storage) {
        return WorkerResult::fail(ERR_CANNOT_RENAME, src.path());
    }

    // check if the file already exists on the device
    const QString destinationPath = convertPath(dest.path());
    const KMTPFile destinationFile = storage->getFileMetadata(destinationPath);
    if (destinationFile.isValid()) {
        if (flags & KIO::Overwrite) {
            // delete existing file on the device
            if (storage->deleteObject(destinationPath) != 0) {
                return WorkerResult::fail(ERR_CANNOT_DELETE, dest.path());
            }
        } else {
            return WorkerResult::fail(ERR_FILE_ALREADY_EXIST, dest.path());
        }
    }

    if (storage->setFileName(convertPath(src.path()), dest.fileName()) != 0) {
        return WorkerResult::fail(ERR_CANNOT_RENAME, src.path());
    }
    return WorkerResult::pass();
}

WorkerResult MTPWorker::fileSystemFreeSpace(const QUrl &url)
{
    qCDebug(LOG_KIO_MTP) << "fileSystemFreeSpace:" << url;

    switch (checkUrl(url)) {
    case Url::Valid:
        break;
    case Url::Redirected:
        return WorkerResult::pass();
    case Url::NotFound:
        return WorkerResult::fail(ERR_DOES_NOT_EXIST, url.path());
    case Url::Invalid:
        return WorkerResult::fail(ERR_MALFORMED_URL, url.path());
    }

    const QStringList pathItems = url.path().split(QLatin1Char('/'), Qt::SkipEmptyParts);

    // Storage
    if (pathItems.size() > 1) {
        const KMTPDeviceInterface *mtpDevice = m_kmtpDaemon.deviceFromName(pathItems.first());
        if (mtpDevice) {
            const KMTPStorageInterface *storage = mtpDevice->storageFromDescription(pathItems.at(1));
            if (storage) {
                setMetaData(QStringLiteral("total"), QString::number(storage->maxCapacity()));
                setMetaData(QStringLiteral("available"), QString::number(storage->freeSpaceInBytes()));
                return WorkerResult::pass();
            }
        }
    }
    return WorkerResult::fail(KIO::ERR_CANNOT_STAT, url.toDisplayString());
}

int MTPWorker::waitForCopyOperation(const KMTPStorageInterface *storage)
{
    QEventLoop loop;
    connect(storage, &KMTPStorageInterface::copyProgress, &loop, [this](qulonglong sent, qulonglong total) {
        Q_UNUSED(total)
        processedSize(sent);
    });

    // any chance to 'miss' the copyFinished signal and dead lock the worker?
    connect(storage, &KMTPStorageInterface::copyFinished, &loop, &QEventLoop::exit);
    return loop.exec();
}

KIO::WorkerResult MTPWorker::chmod(const QUrl &url, int permissions)
{
    return WorkerResult::pass();
}

KIO::WorkerResult MTPWorker::chown(const QUrl &url, const QString &owner, const QString &group)
{
    return WorkerResult::pass();
}

#include "kio_mtp.moc"
#include "moc_kio_mtp.cpp"
