/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qfilesystemmodel_p.h"

#include "qfilesystemmodel.h"

#include <qlocale.h>

#include <qmime.h>

#include <qurl.h>

#include <qdebug.h>

#include <qmessagebox.h>

#include <qapplication.h>

#ifdef Q_OS_WIN

#include <qt_windows.h>

#endif

QT_BEGIN_NAMESPACE

#ifndef QT_NO_FILESYSTEMMODEL

/*!

    \enum QFileSystemModel::Roles

    \value FileIconRole

    \value FilePathRole

    \value FileNameRole

    \value FilePermissions

*/

/*!

    \class QFileSystemModel

    \since 4.4

    \brief The QFileSystemModel class provides a data model for the local filesystem.

    \ingroup model-view

    This class provides access to the local filesystem, providing functions

    for renaming and removing files and directories, and for creating new

    directories. In the simplest case, it can be used with a suitable display

    widget as part of a browser or filter.

    QFileSystemModel will not fetch any files or directories until setRootPath

    is called.  This will prevent any unnecessary querying on the file system

    until that point such as listing the drives on Windows.

    Unlike the QDirModel, QFileSystemModel uses a separate thread to populate

    itself so it will not cause the main thread to hang as the file system

    is being queried.  Calls to rowCount() will return 0 until the model

    populates a directory.

    QFileSystemModel keeps a cache with file information. The cache is

    automatically kept up to date using the QFileSystemWatcher.

    QFileSystemModel can be accessed using the standard interface provided by

    QAbstractItemModel, but it also provides some convenience functions that are

    specific to a directory model.

    The fileInfo(), isDir(), name(), and path() functions provide information

    about the underlying files and directories related to items in the model.

    Directories can be created and removed using mkdir(), rmdir().

    \note QFileSystemModel requires an instance of a GUI application.

    \sa {Model Classes}

*/

/*!

    \fn bool QFileSystemModel::rmdir(const QModelIndex &index) const

    Removes the directory corresponding to the model item \a index in the

    file system model and \bold{deletes the corresponding directory from the

    file system}, returning true if successful. If the directory cannot be

    removed, false is returned.

    \warning This function deletes directories from the file system; it does

    \bold{not} move them to a location where they can be recovered.

    \sa remove()

*/

/*!

    \fn QIcon QFileSystemModel::fileName(const QModelIndex &index) const

    Returns the file name for the item stored in the model under the given

    \a index.

*/

/*!

    \fn QIcon QFileSystemModel::fileIcon(const QModelIndex &index) const

    Returns the icon for the item stored in the model under the given

    \a index.

*/

/*!

    \fn QFileInfo QFileSystemModel::fileInfo(const QModelIndex &index) const

    Returns the QFileInfo for the item stored in the model under the given

    \a index.

*/

/*!

    \fn void QFileSystemModel::rootPathChanged(const QString &newPath);

    This signal is emitted whenever the root path has been changed to a \a newPath.

*/

/*!

    \fn void QFileSystemModel::fileRenamed(const QString &path, const QString &oldName, const QString &newName)

    This signal is emitted whenever a file with the \a oldName is successfully

    renamed to \a newName.  The file is located in in the directory \a path.

*/

/*!

    \fn bool QFileSystemModel::remove(const QModelIndex &index) const

    Removes the model item \a index from the file system model and \bold{deletes the

    corresponding file from the file system}, returning true if successful. If the

    item cannot be removed, false is returned.

    \warning This function deletes files from the file system; it does \bold{not}

    move them to a location where they can be recovered.

    \sa rmdir()

*/

bool QFileSystemModel::remove(const QModelIndex &aindex) const

{

    //### TODO optim

    QString path = filePath(aindex);

    QFileSystemModelPrivate * d = const_cast<QFileSystemModelPrivate*>(d_func());

    d->fileInfoGatherer.removePath(path);

    QDirIterator it(path,

            QDir::AllDirs | QDir:: Files | QDir::NoDotAndDotDot,

            QDirIterator::Subdirectories);

    QStringList children;

    while (it.hasNext())

        children.prepend(it.next());

    children.append(path);

    bool error = false;

    for (int i = 0; i < children.count(); ++i) {

        QFileInfo info(children.at(i));

        QModelIndex modelIndex = index(children.at(i));

        if (info.isDir()) {

            QDir dir;

            if (children.at(i) != path)

                error |= remove(modelIndex);

            error |= rmdir(modelIndex);

        } else {

            error |= QFile::remove(filePath(modelIndex));

        }

    }

    return error;

}

/*!

  Constructs a file system model with the given \a parent.

*/

QFileSystemModel::QFileSystemModel(QObject *parent)

    : QAbstractItemModel(*new QFileSystemModelPrivate, parent)

{

    Q_D(QFileSystemModel);

    d->init();

}

/*!

    \internal

*/

QFileSystemModel::QFileSystemModel(QFileSystemModelPrivate &dd, QObject *parent)

    : QAbstractItemModel(dd, parent)

{

    Q_D(QFileSystemModel);

    d->init();

}

/*!

  Destroys this file system model.

*/

QFileSystemModel::~QFileSystemModel()

{

}

/*!

    \reimp

*/

QModelIndex QFileSystemModel::index(int row, int column, const QModelIndex &parent) const

{

    Q_D(const QFileSystemModel);

    if (row < 0 || column < 0 || row >= rowCount(parent) || column >= columnCount(parent))

        return QModelIndex();

    // get the parent node

    QFileSystemModelPrivate::QFileSystemNode *parentNode = (d->indexValid(parent) ? d->node(parent) :

                                                   const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&d->root));

    Q_ASSERT(parentNode);

    // now get the internal pointer for the index

    QString childName = parentNode->visibleChildren[d->translateVisibleLocation(parentNode, row)];

    const QFileSystemModelPrivate::QFileSystemNode *indexNode = parentNode->children.value(childName);

    Q_ASSERT(indexNode);

    return createIndex(row, column, const_cast<QFileSystemModelPrivate::QFileSystemNode*>(indexNode));

}

/*!

    \overload

    Returns the model item index for the given \a path and \a column.

*/

QModelIndex QFileSystemModel::index(const QString &path, int column) const

{

    Q_D(const QFileSystemModel);

    QFileSystemModelPrivate::QFileSystemNode *node = d->node(path, false);

    QModelIndex idx = d->index(node);

    if (idx.column() != column)

        idx = idx.sibling(idx.row(), column);

    return idx;

}

/*!

    \internal

    Return the QFileSystemNode that goes to index.

  */

QFileSystemModelPrivate::QFileSystemNode *QFileSystemModelPrivate::node(const QModelIndex &index) const

{

    if (!index.isValid())

        return const_cast<QFileSystemNode*>(&root);

    QFileSystemModelPrivate::QFileSystemNode *indexNode = static_cast<QFileSystemModelPrivate::QFileSystemNode*>(index.internalPointer());

    Q_ASSERT(indexNode);

    return indexNode;

}

static QString qt_GetLongPathName(const QString &strShortPath)

{

        return strShortPath;

}

#endif

/*!

    \internal

    Given a path return the matching QFileSystemNode or &root if invalid

*/

QFileSystemModelPrivate::QFileSystemNode *QFileSystemModelPrivate::node(const QString &path, bool fetch) const

{

    Q_Q(const QFileSystemModel);

    Q_UNUSED(q);

    if (path.isEmpty() || path == myComputer() || path.startsWith(QLatin1Char(':')))

        return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

    // Construct the nodes up to the new root path if they need to be built

    QString absolutePath;

    QString longPath = qt_GetLongPathName(path);

#else

    QString longPath = path;

#endif

    if (longPath == rootDir.path())

        absolutePath = rootDir.absolutePath();

    else

        absolutePath = QDir(longPath).absolutePath();

    // ### TODO can we use bool QAbstractFileEngine::caseSensitive() const?

    QStringList pathElements = absolutePath.split(QLatin1Char('/'), QString::SkipEmptyParts);

    if ((pathElements.isEmpty())

#if (!defined(Q_OS_WIN) || defined(Q_OS_WINCE)) && !defined(Q_OS_SYMBIAN)

        && QDir::fromNativeSeparators(longPath) != QLatin1String("/")

#endif

        )

        return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

    QModelIndex index = QModelIndex(); // start with "My Computer"

#if defined(Q_OS_WIN) && !defined(Q_OS_WINCE)

    if (absolutePath.startsWith(QLatin1String("//"))) { // UNC path

        QString host = QLatin1String("\\\\") + pathElements.first();

        if (absolutePath == QDir::fromNativeSeparators(host))

            absolutePath.append(QLatin1Char('/'));

        if (longPath.endsWith(QLatin1Char('/')) && !absolutePath.endsWith(QLatin1Char('/')))

            absolutePath.append(QLatin1Char('/'));

        int r = 0;

        QFileSystemModelPrivate::QFileSystemNode *rootNode = const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

        if (!root.children.contains(host.toLower())) {

            if (pathElements.count() == 1 && !absolutePath.endsWith(QLatin1Char('/')))

                return rootNode;

            QFileInfo info(host);

            if (!info.exists())

                return rootNode;

            QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);

            p->addNode(rootNode, host,info);

            p->addVisibleFiles(rootNode, QStringList(host));

        }

        r = rootNode->visibleLocation(host);

        r = translateVisibleLocation(rootNode, r);

        index = q->index(r, 0, QModelIndex());

        pathElements.pop_front();

    } else

#endif

#if (defined(Q_OS_WIN) && !defined(Q_OS_WINCE)) || defined(Q_OS_SYMBIAN)

    {

        if (!pathElements.at(0).contains(QLatin1String(":"))) {

            // The reason we express it like this instead of with anonymous, temporary

            // variables, is to workaround a compiler crash with Q_CC_NOKIAX86.

            QString rootPath = QDir(longPath).rootPath();

            pathElements.prepend(rootPath);

        }

        if (pathElements.at(0).endsWith(QLatin1Char('/')))

            pathElements[0].chop(1);

    }

#else

    // add the "/" item, since it is a valid path element on Unix

    if (absolutePath[0] == QLatin1Char('/'))

        pathElements.prepend(QLatin1String("/"));

#endif

    QFileSystemModelPrivate::QFileSystemNode *parent = node(index);

    for (int i = 0; i < pathElements.count(); ++i) {

        QString element = pathElements.at(i);

#ifdef Q_OS_WIN

        // On Windows, "filename......." and "filename" are equivalent Task #133928

        while (element.endsWith(QLatin1Char('.')))

            element.chop(1);

#endif

        bool alreadyExisted = parent->children.contains(element);

        // we couldn't find the path element, we create a new node since we

        // _know_ that the path is valid

        if (alreadyExisted) {

            if ((parent->children.count() == 0)

                || (parent->caseSensitive()

                    && parent->children.value(element)->fileName != element)

                || (!parent->caseSensitive()

                    && parent->children.value(element)->fileName.toLower() != element.toLower()))

                alreadyExisted = false;

        }

        QFileSystemModelPrivate::QFileSystemNode *node;

        if (!alreadyExisted) {

            // Someone might call ::index("file://cookie/monster/doesn't/like/veggies"),

            // a path that doesn't exists, I.E. don't blindly create directories.

            QFileInfo info(absolutePath);

            if (!info.exists())

                return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

            QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);

            node = p->addNode(parent, element,info);

#ifndef QT_NO_FILESYSTEMWATCHER

            node->populate(fileInfoGatherer.getInfo(info));

#endif

        } else {

            node = parent->children.value(element);

        }

        Q_ASSERT(node);

        if (!node->isVisible) {

            // It has been filtered out

            if (alreadyExisted && node->hasInformation() && !fetch)

                return const_cast<QFileSystemModelPrivate::QFileSystemNode*>(&root);

            QFileSystemModelPrivate *p = const_cast<QFileSystemModelPrivate*>(this);

            p->addVisibleFiles(parent, QStringList(element));

            if (!p->bypassFilters.contains(node))

                p->bypassFilters[node] = 1;

            QString dir = q->filePath(this->index(parent));

            if (!node->hasInformation() && fetch) {

                Fetching f;

                f.dir = dir;

                f.file = element;

                f.node = node;

                p->toFetch.append(f);

                p->fetchingTimer.start(0, const_cast<QFileSystemModel*>(q));

            }

        }

        parent = node;

    }

    return parent;

}

/*!

    \reimp

*/

void QFileSystemModel::timerEvent(QTimerEvent *event)

{

    Q_D(QFileSystemModel);

    if (event->timerId() == d->fetchingTimer.timerId()) {

        d->fetchingTimer.stop();

#ifndef QT_NO_FILESYSTEMWATCHER

        for (int i = 0; i < d->toFetch.count(); ++i) {

            const QFileSystemModelPrivate::QFileSystemNode *node = d->toFetch.at(i).node;

            if (!node->hasInformation()) {

                d->fileInfoGatherer.fetchExtendedInformation(d->toFetch.at(i).dir,

                                                 QStringList(d->toFetch.at(i).file));

            } else {

                // qDebug() << "yah!, you saved a little gerbil soul";

            }

        }

#endif

        d->toFetch.clear();

    }

}

/*!

    Returns true if the model item \a index represents a directory;

    otherwise returns false.

*/

bool QFileSystemModel::isDir(const QModelIndex &index) const

{

    // This function is for public usage only because it could create a file info

    Q_D(const QFileSystemModel);

    if (!index.isValid())

        return true;

    QFileSystemModelPrivate::QFileSystemNode *n = d->node(index);

    if (n->hasInformation())

        return n->isDir();

    return fileInfo(index).isDir();

}

/*!

    Returns the size in bytes of \a index. If the file does not exist, 0 is returned.

  */

qint64 QFileSystemModel::size(const QModelIndex &index) const

{

    Q_D(const QFileSystemModel);

    if (!index.isValid())

        return 0;

    return d->node(index)->size();

}

/*!

    Returns the type of file \a index such as "Directory" or "JPEG file".

  */

QString QFileSystemModel::type(const QModelIndex &index) const

{

    Q_D(const QFileSystemModel);

    if (!index.isValid())

        return QString();

    return d->node(index)->type();

}

/*!

    Returns the date and time when \a index was last modified.

 */

QDateTime QFileSystemModel::lastModified(const QModelIndex &index) const

{

    Q_D(const QFileSystemModel);