/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the FOO module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL-EXCEPT$
** 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 General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** 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-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <QtCore/private/qabstractfileengine_p.h>
#include <QtCore/private/qfsfileengine_p.h>

#include <QtCore/QMutex>
#include <QtCore/QMutexLocker>
#include <QtCore/QSharedPointer>
#include <QtCore/QScopedPointer>
#include <QtCore/QHash>
#include <QtCore/QDir>
#include <QtCore/QDirIterator>

#include <QtTest/QTest>

#include <QtCore/QDebug>
#include "../../../../shared/filesystem.h"

class tst_QAbstractFileEngine
    : public QObject
{
    Q_OBJECT
public slots:
    void initTestCase();
    void cleanupTestCase();

private slots:
    void customHandler();

    void fileIO_data();
    void fileIO();

    void mounting_data();
    void mounting();
private:
    QStringList filesForRemoval;
    QSharedPointer<QTemporaryDir> m_currentDir;
    QString m_previousCurrent;
};

class ReferenceFileEngine
    : public QAbstractFileEngine
{
public:
    ReferenceFileEngine(const QString &fileName)
        : fileName_(QDir::cleanPath(fileName))
        , position_(-1)
        , openForRead_(false)
        , openForWrite_(false)
    {
    }

    bool open(QIODevice::OpenMode openMode)
    {
        if (openForRead_ || openForWrite_) {
            qWarning("%s: file is already open for %s",
                     Q_FUNC_INFO,
                     (openForRead_ ? "reading" : "writing"));
            return false;
        }

        openFile_ = resolveFile(openMode & QIODevice::WriteOnly);
        if (!openFile_)
            return false;

        position_ = 0;
        if (openMode & QIODevice::ReadOnly)
            openForRead_ = true;

        if (openMode & QIODevice::WriteOnly) {
            openForWrite_ = true;

            QMutexLocker lock(&openFile_->mutex);
            if (openMode & QIODevice::Truncate
                    || !(openForRead_ || openMode & QIODevice::Append))
                openFile_->content.clear();

            if (openMode & QIODevice::Append)
                position_ = openFile_->content.size();
        }

        return true;
    }

    bool close()
    {
        openFile_.clear();

        openForRead_ = false;
        openForWrite_ = false;
        position_ = -1;

        return true;
    }

    qint64 size() const
    {
        QSharedPointer<File> file = resolveFile(false);
        if (!file)
            return 0;

        QMutexLocker lock(&file->mutex);
        return file->content.size();
    }

    qint64 pos() const
    {
        if (!openForRead_ && !openForWrite_) {
            qWarning("%s: file is not open", Q_FUNC_INFO);
            return -1;
        }
        return position_;
    }

    bool seek(qint64 pos)
    {
        if (!openForRead_ && !openForWrite_) {
            qWarning("%s: file is not open", Q_FUNC_INFO);
            return false;
        }

        if (pos >= 0) {
            position_ = pos;
            return true;
        }

        return false;
    }

    bool flush()
    {
        if (!openForRead_ && !openForWrite_) {
            qWarning("%s: file is not open", Q_FUNC_INFO);
            return false;
        }

        return true;
    }

    bool remove()
    {
        QMutexLocker lock(&fileSystemMutex);
        int count = fileSystem.remove(fileName_);

        return (count == 1);
    }

    bool copy(const QString &newName)
    {
        QMutexLocker lock(&fileSystemMutex);
        if (!fileSystem.contains(fileName_)
                || fileSystem.contains(newName))
            return false;

        fileSystem.insert(newName, fileSystem.value(fileName_));
        return true;
    }

    bool rename(const QString &newName)
    {
        QMutexLocker lock(&fileSystemMutex);
        if (!fileSystem.contains(fileName_)
                || fileSystem.contains(newName))
            return false;

        fileSystem.insert(newName, fileSystem.take(fileName_));
        return true;
    }

    //  bool link(const QString &newName)
    //  {
    //      Q_UNUSED(newName)
    //      return false;
    //  }

    //  bool mkdir(const QString &dirName, bool createParentDirectories) const
    //  {
    //      Q_UNUSED(dirName)
    //      Q_UNUSED(createParentDirectories)

    //      return false;
    //  }

    //  bool rmdir(const QString &dirName, bool recurseParentDirectories) const
    //  {
    //      Q_UNUSED(dirName)
    //      Q_UNUSED(recurseParentDirectories)

    //      return false;
    //  }

    bool setSize(qint64 size)
    {
        if (size < 0)
            return false;

        QSharedPointer<File> file = resolveFile(false);
        if (!file)
            return false;

        QMutexLocker lock(&file->mutex);
        file->content.resize(size);

        if (openForRead_ || openForWrite_)
            if (position_ > size)
                position_ = size;

        return (file->content.size() == size);
    }

    FileFlags fileFlags(FileFlags type) const
    {
        QSharedPointer<File> file = resolveFile(false);
        if (file) {
            QMutexLocker lock(&file->mutex);
            return (file->fileFlags & type);
        }

        return FileFlags();
    }

    //  bool setPermissions(uint perms)
    //  {
    //      Q_UNUSED(perms)

    //      return false;
    //  }

    QString fileName(FileName file) const
    {
        switch (file) {
            case DefaultName:
                return QLatin1String("DefaultName");
            case BaseName:
                return QLatin1String("BaseName");
            case PathName:
                return QLatin1String("PathName");
            case AbsoluteName:
                return QLatin1String("AbsoluteName");
            case AbsolutePathName:
                return QLatin1String("AbsolutePathName");
            case LinkName:
                return QLatin1String("LinkName");
            case CanonicalName:
                return QLatin1String("CanonicalName");
            case CanonicalPathName:
                return QLatin1String("CanonicalPathName");
            case BundleName:
                return QLatin1String("BundleName");

            default:
                break;
        }

        return QString();
    }

    uint ownerId(FileOwner owner) const
    {
        QSharedPointer<File> file = resolveFile(false);
        if (file) {
            switch (owner) {
                case OwnerUser:
                {
                    QMutexLocker lock(&file->mutex);
                    return file->userId;
                }
                case OwnerGroup:
                {
                    QMutexLocker lock(&file->mutex);
                    return file->groupId;
                }
            }
        }

        return -2;
    }

    QString owner(FileOwner owner) const
    {
        QSharedPointer<File> file = resolveFile(false);
        if (file) {
            uint ownerId;
            switch (owner) {
                case OwnerUser:
                {
                    QMutexLocker lock(&file->mutex);
                    ownerId = file->userId;
                }

                {
                    QMutexLocker lock(&fileSystemMutex);
                    return fileSystemUsers.value(ownerId);
                }

                case OwnerGroup:
                {
                    QMutexLocker lock(&file->mutex);
                    ownerId = file->groupId;
                }

                {
                    QMutexLocker lock(&fileSystemMutex);
                    return fileSystemGroups.value(ownerId);
                }
            }
        }

        return QString();
    }

    QDateTime fileTime(FileTime time) const
    {
        QSharedPointer<File> file = resolveFile(false);
        if (file) {
            QMutexLocker lock(&file->mutex);
            switch (time) {
                case BirthTime:
                    return file->birth;
                case MetadataChangeTime:
                    return file->change;
                case ModificationTime:
                    return file->modification;
                case AccessTime:
                    return file->access;
            }
        }

        return QDateTime();
    }

    bool setFileTime(const QDateTime &newDate, FileTime time)
    {
        Q_UNUSED(newDate);
        Q_UNUSED(time);
        return false;
    }

    void setFileName(const QString &file)
    {
        if (openForRead_ || openForWrite_)
            qWarning("%s: Can't set file name while file is open", Q_FUNC_INFO);
        else
            fileName_ = file;
    }

    //  typedef QAbstractFileEngineIterator Iterator;
    //  Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames)
    //  {
    //      Q_UNUSED(filters)
    //      Q_UNUSED(filterNames)

    //      return 0;
    //  }

    //  Iterator *endEntryList()
    //  {
    //      return 0;
    //  }

    qint64 read(char *data, qint64 maxLen)
    {
        if (!openForRead_) {
            qWarning("%s: file must be open for reading", Q_FUNC_INFO);
            return -1;
        }

        if (openFile_.isNull()) {
            qWarning("%s: file must not be null", Q_FUNC_INFO);
            return -1;
        }

        QMutexLocker lock(&openFile_->mutex);
        qint64 readSize = qMin(openFile_->content.size() - position_, maxLen);
        if (readSize < 0)
            return -1;

        memcpy(data, openFile_->content.constData() + position_, readSize);
        position_ += readSize;

        return readSize;
    }

    qint64 write(const char *data, qint64 length)
    {
        if (!openForWrite_) {
            qWarning("%s: file must be open for writing", Q_FUNC_INFO);
            return -1;
        }

        if (openFile_.isNull()) {
            qWarning("%s: file must not be null", Q_FUNC_INFO);
            return -1;
        }

        if (length < 0)
            return -1;

        QMutexLocker lock(&openFile_->mutex);
        if (openFile_->content.size() == position_)
            openFile_->content.append(data, length);
        else {
            if (position_ + length > openFile_->content.size())
                openFile_->content.resize(position_ + length);
            openFile_->content.replace(position_, length, data, length);
        }

        qint64 writeSize = qMin(length, openFile_->content.size() - position_);
        position_ += writeSize;

        return writeSize;
    }

protected:
    // void setError(QFile::FileError error, const QString &str);

    struct File
    {
        File()
            : userId(0)
            , groupId(0)
            , fileFlags(
                    ReadOwnerPerm | WriteOwnerPerm | ExeOwnerPerm
                    | ReadUserPerm | WriteUserPerm | ExeUserPerm
                    | ReadGroupPerm | WriteGroupPerm | ExeGroupPerm
                    | ReadOtherPerm | WriteOtherPerm | ExeOtherPerm
                    | FileType | ExistsFlag)
        {
        }

        QMutex mutex;

        uint userId, groupId;
        QAbstractFileEngine::FileFlags fileFlags;
        QDateTime birth, change, modification, access;

        QByteArray content;
    };

    QSharedPointer<File> resolveFile(bool create) const
    {
        if (openForRead_ || openForWrite_) {
            if (!openFile_)
                qWarning("%s: file should not be null", Q_FUNC_INFO);
            return openFile_;
        }

        QMutexLocker lock(&fileSystemMutex);
        if (create) {
            QSharedPointer<File> &p = fileSystem[fileName_];
            if (p.isNull())
                p = QSharedPointer<File>::create();
            return p;
        }

        return fileSystem.value(fileName_);
    }

    static QMutex fileSystemMutex;
    static QHash<uint, QString> fileSystemUsers, fileSystemGroups;
    static QHash<QString, QSharedPointer<File> > fileSystem;

private:
    QString fileName_;
    qint64 position_;
    bool openForRead_;
    bool openForWrite_;

    mutable QSharedPointer<File> openFile_;
};

class MountingFileEngine : public QFSFileEngine
{
public:
    class Iterator : public QAbstractFileEngineIterator
    {
    public:
        Iterator(QDir::Filters filters, const QStringList &filterNames)
            : QAbstractFileEngineIterator(filters, filterNames)
        {
            names.append("foo");
            names.append("bar");
            index = -1;
        }
        QString currentFileName() const
        {
            return names.at(index);
        }
        bool hasNext() const
        {
            return index < names.size() - 1;
        }
        QString next()
        {
            if (!hasNext())
                return QString();
            ++index;
            return currentFilePath();
        }
        QStringList names;
        int index;
    };
    MountingFileEngine(QString fileName)
        : QFSFileEngine(fileName)
    {
    }
    Iterator *beginEntryList(QDir::Filters filters, const QStringList &filterNames)
    {
        return new Iterator(filters, filterNames);
    }
    FileFlags fileFlags(FileFlags type) const
    {
        if (fileName(DefaultName).endsWith(".tar")) {
            FileFlags ret = QFSFileEngine::fileFlags(type);
            //make this file in file system appear to be a directory
            ret &= ~FileType;
            ret |= DirectoryType;
            return ret;
        } else {
            //file inside the archive
            return ExistsFlag | FileType;
        }
    }
};

QMutex ReferenceFileEngine::fileSystemMutex;
QHash<uint, QString> ReferenceFileEngine::fileSystemUsers, ReferenceFileEngine::fileSystemGroups;
QHash<QString, QSharedPointer<ReferenceFileEngine::File> > ReferenceFileEngine::fileSystem;

class FileEngineHandler
    : QAbstractFileEngineHandler
{
    QAbstractFileEngine *create(const QString &fileName) const
    {
        if (fileName.endsWith(".tar") || fileName.contains(".tar/"))
            return new MountingFileEngine(fileName);
        if (fileName.startsWith("QFSFileEngine:"))
            return new QFSFileEngine(fileName.mid(14));
        if (fileName.startsWith("reference-file-engine:"))
            return new ReferenceFileEngine(fileName.mid(22));
        if (fileName.startsWith("resource:"))
            return QAbstractFileEngine::create(QLatin1String(":/tst_qabstractfileengine/resources/") + fileName.mid(9));
        return 0;
    }
};

void tst_QAbstractFileEngine::initTestCase()
{
    m_previousCurrent = QDir::currentPath();
    m_currentDir = QSharedPointer<QTemporaryDir>::create();
    QVERIFY2(!m_currentDir.isNull(), qPrintable("Could not create current directory."));
    QDir::setCurrent(m_currentDir->path());
}

void tst_QAbstractFileEngine::cleanupTestCase()
{
    bool failed = false;

    FileEngineHandler handler;
    Q_FOREACH(QString file, filesForRemoval)
        if (!QFile::remove(file)
                || QFile::exists(file)) {
            failed = true;
            qDebug() << "Couldn't remove file:" << file;
        }

    QVERIFY(!failed);

    QDir::setCurrent(m_previousCurrent);
}

void tst_QAbstractFileEngine::customHandler()
{
    QScopedPointer<QAbstractFileEngine> file;
    {
        file.reset(QAbstractFileEngine::create("resource:file.txt"));

        QVERIFY(file);
    }

    {
        FileEngineHandler handler;

        QFile file("resource:file.txt");
        QVERIFY(file.exists());
    }

    {
        QFile file("resource:file.txt");
        QVERIFY(!file.exists());
    }
}

void tst_QAbstractFileEngine::fileIO_data()
{
    QTest::addColumn<QString>("fileName");
    QTest::addColumn<QByteArray>("readContent");
    QTest::addColumn<QByteArray>("writeContent");
    QTest::addColumn<bool>("fileExists");

    QString resourceTxtFile(":/tst_qabstractfileengine/resources/file.txt");
    QByteArray readContent("This is a simple text file.\n");
    QByteArray writeContent("This contains two lines of text.\n");

    QTest::newRow("resource") << resourceTxtFile << readContent << QByteArray() << true;
    QTest::newRow("native") << "native-file.txt" << readContent << writeContent << false;
    QTest::newRow("Forced QFSFileEngine") << "QFSFileEngine:QFSFileEngine-file.txt" << readContent << writeContent << false;
    QTest::newRow("Custom FE") << "reference-file-engine:file.txt" << readContent << writeContent << false;

    QTest::newRow("Forced QFSFileEngine (native)") << "QFSFileEngine:native-file.txt" << readContent << writeContent << true;
    QTest::newRow("native (Forced QFSFileEngine)") << "QFSFileEngine-file.txt" << readContent << writeContent << true;
    QTest::newRow("Custom FE (2)") << "reference-file-engine:file.txt" << readContent << writeContent << true;
}

void tst_QAbstractFileEngine::fileIO()
{
    QFETCH(QString, fileName);
    QFETCH(QByteArray, readContent);
    QFETCH(QByteArray, writeContent);
    QFETCH(bool, fileExists);

    FileEngineHandler handler;


    {
        QFile file(fileName);
        QCOMPARE(file.exists(), fileExists);

        if (!fileExists) {
            QVERIFY(file.open(QIODevice::WriteOnly | QIODevice::Unbuffered));
            filesForRemoval.append(fileName);

            QCOMPARE(file.write(readContent), qint64(readContent.size()));
        }
    }

    //
    // File content is: readContent
    //

    qint64 fileSize = readContent.size();
    {
        // Reading
        QFile file(fileName);
        QVERIFY(!file.isOpen());

        /* For an exact match, this test requires the repository to
         * be checked out with UNIX-style line endings on Windows.
         * Try to succeed also for the common case of checking out with autocrlf
         * by reading the file as text and checking if the size matches
         * the original size + the '\r' characters added by autocrlf. */

        QFile::OpenMode openMode = QIODevice::ReadOnly | QIODevice::Unbuffered;
#ifdef Q_OS_WIN
        openMode |= QIODevice::Text;
#endif
        QVERIFY(file.open(openMode));
        QVERIFY(file.isOpen());
#ifdef Q_OS_WIN
        const qint64 convertedSize = fileSize + readContent.count('\n');
        if (file.size() == convertedSize)
            fileSize = convertedSize;
#endif
        QCOMPARE(file.size(), fileSize);
        QCOMPARE(file.pos(), qint64(0));

        QCOMPARE(file.size(), fileSize);
        QCOMPARE(file.readAll(), readContent);
        QCOMPARE(file.pos(), fileSize);

        file.close();
        QVERIFY(!file.isOpen());
        QCOMPARE(file.size(), fileSize);
    }

    if (writeContent.isEmpty())
        return;

    {
        // Writing / appending
        QFile file(fileName);

        QVERIFY(!file.isOpen());
        QVERIFY(file.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Unbuffered));

        QVERIFY(file.isOpen());
        QCOMPARE(file.size(), fileSize);
        QCOMPARE(file.pos(), fileSize);

        QCOMPARE(file.write(writeContent), qint64(writeContent.size()));

        fileSize += writeContent.size();
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        file.close();
        QVERIFY(!file.isOpen());
        QCOMPARE(file.size(), fileSize);
    }

    //
    // File content is: readContent + writeContent
    //

    {
        // Reading and Writing
        QFile file(fileName);

        QVERIFY(!file.isOpen());
        QVERIFY(file.open(QIODevice::ReadWrite | QIODevice::Unbuffered));

        QVERIFY(file.isOpen());
        QCOMPARE(file.size(), fileSize);
        QCOMPARE(file.pos(), qint64(0));

        QCOMPARE(file.readAll(), readContent + writeContent);
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        QVERIFY(file.seek(writeContent.size()));
        QCOMPARE(file.pos(), qint64(writeContent.size()));
        QCOMPARE(file.size(), fileSize);

        QCOMPARE(file.write(readContent), qint64(readContent.size()));
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        QVERIFY(file.seek(0));
        QCOMPARE(file.pos(), qint64(0));
        QCOMPARE(file.size(), fileSize);

        QCOMPARE(file.write(writeContent), qint64(writeContent.size()));
        QCOMPARE(file.pos(), qint64(writeContent.size()));
        QCOMPARE(file.size(), fileSize);

        QVERIFY(file.seek(0));
        QCOMPARE(file.read(writeContent.size()), writeContent);
        QCOMPARE(file.pos(), qint64(writeContent.size()));
        QCOMPARE(file.size(), fileSize);

        QCOMPARE(file.readAll(), readContent);
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        file.close();
        QVERIFY(!file.isOpen());
        QCOMPARE(file.size(), fileSize);
    }

    //
    // File content is: writeContent + readContent
    //

    {
        // Writing
        QFile file(fileName);

        QVERIFY(!file.isOpen());
        QVERIFY(file.open(QIODevice::ReadWrite | QIODevice::Unbuffered));

        QVERIFY(file.isOpen());
        QCOMPARE(file.size(), fileSize);
        QCOMPARE(file.pos(), qint64(0));

        QCOMPARE(file.write(writeContent), qint64(writeContent.size()));
        QCOMPARE(file.pos(), qint64(writeContent.size()));
        QCOMPARE(file.size(), fileSize);

        QVERIFY(file.resize(writeContent.size()));
        QCOMPARE(file.size(), qint64(writeContent.size()));

        file.close();
        QVERIFY(!file.isOpen());
        QCOMPARE(file.size(), qint64(writeContent.size()));

        QVERIFY(file.resize(fileSize));
        QCOMPARE(file.size(), fileSize);
    }

    //
    // File content is: writeContent + <undefined>
    // File size is   : (readContent + writeContent).size()
    //

    {
        // Writing / extending
        QFile file(fileName);

        QVERIFY(!file.isOpen());
        QVERIFY(file.open(QIODevice::ReadWrite | QIODevice::Unbuffered));

        QVERIFY(file.isOpen());
        QCOMPARE(file.size(), fileSize);
        QCOMPARE(file.pos(), qint64(0));

        QVERIFY(file.seek(1024));
        QCOMPARE(file.pos(), qint64(1024));
        QCOMPARE(file.size(), fileSize);

        fileSize = 1024 + writeContent.size();
        QCOMPARE(file.write(writeContent), qint64(writeContent.size()));
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        QVERIFY(file.seek(1028));
        QCOMPARE(file.pos(), qint64(1028));
        QCOMPARE(file.size(), fileSize);

        fileSize = 1028 + writeContent.size();
        QCOMPARE(file.write(writeContent), qint64(writeContent.size()));
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        file.close();
        QVERIFY(!file.isOpen());
        QCOMPARE(file.size(), fileSize);
    }

    //
    // File content is: writeContent + <undefined> + writeContent
    // File size is   : 1024 + writeContent.size()
    //

    {
        // Writing / truncating
        QFile file(fileName);

        QVERIFY(!file.isOpen());
        QVERIFY(file.open(QIODevice::WriteOnly | QIODevice::Truncate | QIODevice::Unbuffered));

        QVERIFY(file.isOpen());
        QCOMPARE(file.size(), qint64(0));
        QCOMPARE(file.pos(), qint64(0));

        fileSize = readContent.size();
        QCOMPARE(file.write(readContent), fileSize);
        QCOMPARE(file.pos(), fileSize);
        QCOMPARE(file.size(), fileSize);

        file.close();
        QVERIFY(!file.isOpen());
        QCOMPARE(file.size(), fileSize);
    }

    //
    // File content is: readContent
    //
}

void tst_QAbstractFileEngine::mounting_data()
{
    QTest::addColumn<QString>("fileName");
    QTest::newRow("native") << "test.tar";
    QTest::newRow("Forced QFSFileEngine") << "QFSFileEngine:test.tar";
}

void tst_QAbstractFileEngine::mounting()
{
    FileSystem fs;
    QVERIFY(fs.createFile("test.tar"));
    FileEngineHandler handler;

    QFETCH(QString, fileName);
    const QString absName = fs.absoluteFilePath(fileName);

    QVERIFY(QFileInfo(absName).isDir());
    QDir dir(absName);
    QCOMPARE(dir.entryList(), (QStringList() << "bar" << "foo"));
    QDir dir2(fs.path());
    bool found = false;
    foreach (QFileInfo info, dir2.entryInfoList()) {
        if (info.fileName() == QLatin1String("test.tar")) {
            QVERIFY(!found);
            found = true;
            QVERIFY(info.isDir());
        }
    }
    QVERIFY(found);
}

QTEST_APPLESS_MAIN(tst_QAbstractFileEngine)
#include "tst_qabstractfileengine.moc"

