#include <QPushButton>
#include <QGridLayout>
#include <QVBoxLayout>
#include <QStandardItemModel>
#include <QStandardItem>
#include <QTreeView>
#include <QCompleter>
#include <QDirModel>
#include <QDir>
#include <QFileDialog>
#include <QLabel>
#include <QMimeDatabase>
#include <QMimeType>
#include <QFont>
#include <QSqlDatabase>
#include <QSqlQuery>
#include <QSettings>
#include <QHeaderView>
#include <QApplication>
#include <QCursor>
#include <QJsonObject>
#include <QJsonDocument>
#include <QItemSelectionModel>
#include <QGroupBox>
#include <QKeyEvent>
#include <QMessageBox>
#include <QProgressBar>
#include <QUrl>
#include <QMimeData>
#include <QClipboard>
#include <QApplication>
#include <QContextMenuEvent>
#include <QDirIterator>
#include <QStandardPaths>

#include "filewidget.h"
#include "filesorter.h"
#include "filedisplay.h"
#include "filecopier.h"
#include "cachedfiledata.h"
#include "origindialog.h"
#include "helper.h"
#include "globals.h"
#include "viewer.h"
#include "progressdialog.h"

FileWidget::FileWidget(QWidget *parent) : QWidget(parent), mCopyToMenu(0) {
    mFileCopier = new FileCopier(this);
    mCopyProgress = new ProgressDialog;
    mFileCache.setMaxCost(500);
    QString cacheDir = QStandardPaths::locate(QStandardPaths::HomeLocation, ".shemovcleaner", QStandardPaths::LocateDirectory);
    if(!cacheDir.isEmpty()){
        QString cacheFile = QString("%1/%2").arg(cacheDir).arg("cfd.dat");
        QFile f(cacheFile);
        if(f.open(QIODevice::ReadOnly)){
            QDataStream in(&f);
            while(!in.atEnd()){
                CachedFileData *fd = new CachedFileData;
                in >> *fd;
                mFileCache.insert(fd->fullPath, fd);
            }
        }
    }
    connect(mFileCopier, SIGNAL(newFile(QString,QString,qint64)), this, SLOT(setupProgress(QString,QString,qint64)));
    connect(mFileCopier, SIGNAL(bytesRead(qint64)), this, SLOT(setCopyProgress(qint64)));
    connect(mFileCopier, SIGNAL(bytesReadIntval(qint64,qint64)), this, SLOT(setCopySummary(qint64,qint64)));
    connect(mFileCopier, SIGNAL(finished()), this, SLOT(hideCopyProgress()));
    connect(mFileCopier, SIGNAL(success(bool,QString)), this, SLOT(copySuccess(bool,QString)));
    connect(mCopyProgress, SIGNAL(cancelled()), this, SLOT(hideCopyProgress()));
    setupGui();
}

FileWidget::~FileWidget(){
    writeHeaderData();
    writeSettings();
    QString cacheDir = QStandardPaths::locate(QStandardPaths::HomeLocation, ".shemovcleaner", QStandardPaths::LocateDirectory);
    if(!cacheDir.isEmpty()){
        QString cacheFile = QString("%1/%2").arg(cacheDir).arg("cfd.dat");
        QFile f(cacheFile);
        if(f.open(QIODevice::WriteOnly)){
            QDataStream out(&f);
            QList<QString> entries = mFileCache.keys();
            for(const QString &e : entries){
                CachedFileData *entry = mFileCache[e];
                out << *entry;
            }
        }
    }
}

void FileWidget::setupGui(){
    mDir = new QLineEdit;
    QCompleter *fsCompleter = new QCompleter(this);
    QDirModel *dirModel = new QDirModel(this);
    fsCompleter->setModel(dirModel);
    fsCompleter->setCompletionMode(QCompleter::PopupCompletion);
    mDir->setCompleter(fsCompleter);
    connect(mDir, SIGNAL(returnPressed()), this, SLOT(gatherData()));
    QPushButton *selDirBtn = new QPushButton(tr("&Browse..."));
    connect(selDirBtn, SIGNAL(clicked()), this, SLOT(selectDir()));

    mFilter = new QLineEdit;
    connect(mFilter, SIGNAL(returnPressed()), this, SLOT(filter()));
    QPushButton *searchBtn = new QPushButton(tr("F&ilter"));
    connect(searchBtn, SIGNAL(clicked()), this, SLOT(filter()));

    QGridLayout *topL = new QGridLayout;
    topL->addWidget(new QLabel(tr("Directory")), 0, 0);
    topL->addWidget(mDir, 0, 1);
    topL->addWidget(selDirBtn, 0, 2);
    topL->addWidget(new QLabel(tr("Filter")), 1, 0);
    topL->addWidget(mFilter, 1, 1);
    topL->addWidget(searchBtn, 1, 2);

    mFileView = new QTreeView;
    mFileView->setSortingEnabled(true);
    mFileView->setUniformRowHeights(true);
    mFileView->setSelectionBehavior(QAbstractItemView::SelectRows);
    mFileView->setSelectionMode(QAbstractItemView::ExtendedSelection);
    connect(mFileView, SIGNAL(doubleClicked(QModelIndex)), this, SLOT(properties(QModelIndex)));

    mModel = new QStandardItemModel;
    mProxy = new VideoSorter;
    mProxy->setSourceModel(mModel);
    mFileView->setModel(mProxy);
    readSettings();

    QSqlDatabase mDb = QSqlDatabase::database("shemovdb");
    if(!mDb.isOpen()){
        mDb.open();
    }
    mQOrigin = QSqlQuery(mDb);
    mQOrigin.prepare("SELECT COUNT(*) FROM files_origin WHERE cmd5sum = :md5");
    mQFiles = QSqlQuery(mDb);
    mQFiles.prepare("SELECT COUNT(*) FROM files WHERE cmd5sum = :md5");

    mFileDisplay = new FileDisplay(this);
    mOrignDlg = new OriginDialog(this);
    connect(mOrignDlg, SIGNAL(statusMessage(QString)), this, SIGNAL(statusMessage(QString)));
    connect(mOrignDlg, SIGNAL(refreshNeeded()), this, SLOT(gatherData()));
    mMenuBar = new QMenuBar;
    mToolBar = new QToolBar;
    mToolBar->setIconSize(QSize(16, 16));

    QVBoxLayout *mainLayout = new QVBoxLayout;
    mainLayout->addWidget(mMenuBar);
    mainLayout->addWidget(mToolBar);
    mainLayout->addLayout(topL);
    mainLayout->addWidget(new QLabel(tr("Files")));
    mainLayout->addWidget(mFileView);
    setLayout(mainLayout);

    connect(mFileView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)), this, SLOT(fileSelectionChanged(QItemSelection,QItemSelection)));
    createActions();
    mMimeData = new QMimeData;
    mFileView->setFocus();
    mCopyProgress->setVisible(false);
}

void FileWidget::createActions(){
    mCopyToMenu = new QMenu;
    mSelDirA = new QAction(QIcon(":/folder.png"), tr("Select Folder..."), this);
    mSelDirA->setShortcut(tr("CTRL+O"));
    connect(mSelDirA, SIGNAL(triggered()), this, SLOT(selectDir()));
    mRefreshA = new QAction(QIcon(":/refresh.png"), tr("Refresh"), this);
    mRefreshA->setShortcut(tr("CTRL+R"));
    connect(mRefreshA, SIGNAL(triggered()), this, SLOT(gatherData()));
    mDirUpA = new QAction(QIcon(":/up_dick.png"), tr("Dir up"), this);
    mDirUpA->setShortcut(Qt::Key_Backspace);
    connect(mDirUpA, SIGNAL(triggered()), this, SLOT(cdUp()));
    mDirBackA = new QAction(QIcon(":/back_dick.png"), tr("Back"), this);
    mDirBackA->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Left));
    connect(mDirBackA, SIGNAL(triggered()), this, SLOT(cdLast()));
    mCopyA = new QAction(QIcon(":/edit-copy.png"), tr("Copy"), this);
    mCopyA->setShortcut(tr("CTRL+C"));
    connect(mCopyA, SIGNAL(triggered()), this, SLOT(copy()));
    mCutA = new QAction(QIcon(":/edit-cut.png"), tr("Cut"), this);
    mCutA->setShortcut(tr("CTRL+X"));
    connect(mCutA, SIGNAL(triggered()), this, SLOT(cut()));
    mPasteA = new QAction(QIcon(":/edit-paste.png"), tr("Paste"), this);
    mPasteA->setShortcut(tr("CTRL+V"));
    connect(mPasteA, SIGNAL(triggered()), this, SLOT(paste()));
    mDeleteA = new QAction(QIcon(":/delete.png"), tr("Delete..."), this);
    mDeleteA->setShortcut(Qt::Key_Delete);
    connect(mDeleteA, SIGNAL(triggered()), this, SLOT(deleteFiles()));
    mPropertiesA = new QAction(QIcon(":/diaper.png"), tr("Properties..."), this);
    mPropertiesA->setShortcut(Qt::CTRL + Qt::Key_Return);
    connect(mPropertiesA, SIGNAL(triggered()), this, SLOT(properties()));
    mPreviewA = new QAction(QIcon(":/snapshot.png"), tr("Preview..."), this);
    connect(mPreviewA, SIGNAL(triggered()), this, SLOT(preview()));
    mAddAsOriginA = new QAction(QIcon(":/butt_plug.png"), tr("Add as Origin..."), this);
    connect(mAddAsOriginA, SIGNAL(triggered()), this, SLOT(addAsOrigin()));

    QMenu *fileMenu = new QMenu(tr("&File"));
    fileMenu->addAction(mSelDirA);
    fileMenu->addAction(mRefreshA);
    fileMenu->addSeparator();
    fileMenu->addAction(Globals::instance()->action(Globals::QuitAction));

    QMenu *editMenu = new QMenu(tr("&Edit"));
    editMenu->addAction(mDirUpA);
    editMenu->addAction(mDirBackA);
    editMenu->addSeparator();
    editMenu->addAction(mCopyA);
    editMenu->addAction(mCutA);
    editMenu->addAction(mPasteA);
    editMenu->addAction(mDeleteA);
    editMenu->addSeparator();
    editMenu->addAction(mPropertiesA);
    editMenu->addAction(mPreviewA);
    editMenu->addAction(mAddAsOriginA);
    editMenu->addSeparator();
    editMenu->addAction(Globals::instance()->action(Globals::ConfigAction));

    mMenuBar->addMenu(fileMenu);
    mMenuBar->addMenu(editMenu);

    mToolBar->addAction(mRefreshA);
    mToolBar->addAction(mSelDirA);
    mToolBar->addAction(createSeparator());
    mToolBar->addAction(mDirUpA);
    mToolBar->addAction(mDirBackA);
    mToolBar->addAction(createSeparator());
    mToolBar->addAction(mCopyA);
    mToolBar->addAction(mCutA);
    mToolBar->addAction(mPasteA);
    mToolBar->addAction(mDeleteA);
    mToolBar->addAction(createSeparator());
    mToolBar->addAction(mPropertiesA);
    mToolBar->addAction(mPreviewA);
    mToolBar->addAction(createSeparator());
    mToolBar->addAction(mAddAsOriginA);
    mToolBar->addAction(createSeparator());
    mToolBar->addAction(Globals::instance()->action(Globals::ConfigAction));

    addActions(QList<QAction*>() << mDirBackA << mDirUpA << createSeparator() << mRefreshA << mSelDirA << createSeparator() << mCopyA << mCutA << mPasteA << mDeleteA << createSeparator() << mAddAsOriginA << createSeparator() << mPreviewA << createSeparator() << mPropertiesA);
}

void FileWidget::fileData(const QString &fullPath, const QString &md5){
    mFileDisplay->setFileData(fullPath, md5);
    mFileDisplay->show();
}

void FileWidget::selectDir(){
    QString dir = QFileDialog::getExistingDirectory(this, tr("Select directory"), QDir::homePath());
    if(!dir.isEmpty()){
        mDir->setText(QDir::toNativeSeparators(dir));
        gatherData();
    }
}

void FileWidget::gatherData(){
    if(isVisible()){
        writeHeaderData();
    }
    QSettings s;
    QStringList copyDirs = s.value("copydirs").toStringList();
    QStringList copyDirFiles;
    for(const QString &d : copyDirs){
        QDirIterator it(d, QDir::Files | QDir::NoDotAndDotDot);
        while(it.hasNext()){
            it.next();
            copyDirFiles << it.fileName();
        }
    }

    mFileView->setSortingEnabled(false);
    mModel->clear();
    QStandardItem *root = mModel->invisibleRootItem();
    mModel->setHorizontalHeaderLabels(QStringList() << QChar(0x26A7) << tr("Name") << QChar(0x26A5) << tr("MIME") << tr("Duration") << tr("Size") << tr("MD5"));

    QMimeDatabase db;
    qApp->setOverrideCursor(Qt::BusyCursor);
    QString gatherMsg(tr("Gathering data: %1 (%2)"));
    int count = 1;
    qint64 totalSize = 0;
    qApp->processEvents();

    QDirIterator it(mDir->text(), QDir::Files | QDir::Dirs | QDir::NoDot);
    while(it.hasNext()){
        QFileInfo fi = it.next();
        emit statusMessage(gatherMsg.arg(fi.fileName()).arg(QString::number(count)));
        CachedFileData *fd = mFileCache[fi.absoluteFilePath()];
        if(!fd){
            bool insert = true;
            fd = new CachedFileData;
            QMimeType mime = db.mimeTypeForFile(fi);
            fd->attr = NotPresent;
            Helper::Duration dur;
            QString md5(tr("n/a"));
            QString duration(tr("n/a"));
            qint64 seconds = 0;
            if(mime.name().startsWith("video")){
                md5 = Helper::md5Sum(fi.absoluteFilePath());
                fd->md5Sum = md5;
                int haveFile = md5Count(md5);
                if(haveFile){
                    fd->attr = Present;
                }
                QJsonDocument jDoc = Helper::ffpmegData(fi.absoluteFilePath());
                QJsonObject jObj = jDoc.object();
                QJsonValue durationV = jObj["format"].toObject()["duration"];
                seconds = durationV.toVariant().toDouble();
                dur = Helper::Duration(seconds);
                duration = dur.toString();
            }else if(fi.isDir()){
                if(fi.fileName() == ".."){
                    fd->attr = ParentDir;
                    insert = false;
                }else{
                    fd->attr = Directory;
                    insert = false;
                }
            }else{
                fd->attr = NoVideo;
                insert = false;
            }
            if(fi.isFile()){
                qint64 sizemb = fi.size();
                fd->size = sizemb;
                if(copyDirFiles.contains(fi.fileName())){
                    fd->copied = true;
                }else{
                    fd->copied = false;
                }
                ++count;
                totalSize += sizemb;
            }
            fd->duration = duration;
            fd->md5Sum = md5;
            fd->mimeType = mime.name();
            fd->name = fi.fileName();
            fd->fullPath = fi.absoluteFilePath();
            if(insert){
                mFileCache.insert(fi.absoluteFilePath(), fd);
            }
        }else{
            int haveFile = md5Count(fd->md5Sum);
            if(haveFile){
                fd->attr = Present;
            }
        }
        root->appendRow(constructRow(fd));
    }
    mFileView->setSortingEnabled(true);
    readHeaderData();
    qApp->restoreOverrideCursor();
    selectFirst();
    double totalSizeGB = totalSize / 1024 / 1024 / 1024.0;
    emit statusMessage(QString(tr("Analyzed %1 file(s) / (%2 GB)").arg(QString::number(count)).arg(QString::number(totalSizeGB, 'f', 2))));
    emit freeSpaceChanged(mDir->text());
}

int FileWidget::md5Count(const QString &md5) {
    mQOrigin.bindValue(":md5", md5);
    mQOrigin.exec();
    int retval = 0;
    while(mQOrigin.next()){
        retval = mQOrigin.value(0).toInt();
    }
    if(!retval){
        mQFiles.bindValue(":md5", md5);
        mQFiles.exec();
        while(mQFiles.next()){
            retval = mQFiles.value(0).toInt();
        }
    }
    return retval;
}

void FileWidget::readHeaderData(){
    QSettings s;
    QByteArray headers = s.value("video/fileheaders").toByteArray();
    if(!headers.isEmpty()){
        mFileView->header()->restoreState(headers);
    }
}

void FileWidget::writeHeaderData(){
    QSettings s;
    s.setValue("video/fileheaders", mFileView->header()->saveState());
}

void FileWidget::readSettings(){
    QSettings s;
    QString dir = s.value("video/searchdir", QDir::toNativeSeparators(QDir::homePath())).toString();
    mDir->setText(dir);
}

void FileWidget::writeSettings(){
    QSettings s;
    s.setValue("video/searchdir", mDir->text());
}

QAction *FileWidget::createSeparator(){
    QAction *retval = new QAction(this);
    retval->setSeparator(true);
    return retval;
}

void FileWidget::filter(){
    mProxy->setFilterRegExp(mFilter->text());
    mProxy->setFilterKeyColumn(NameColumn);
    mProxy->setFilterCaseSensitivity(Qt::CaseInsensitive);
}

void FileWidget::clearFilter(){
    mFilter->clear();
    filter();
}

void FileWidget::copy(){
    mFileAction = Copy;
    cutOrCopy();
}

void FileWidget::cut(){
    mFileAction = Cut;
    cutOrCopy();
}

void FileWidget::cutOrCopy(){
    mMimeData->clear();
    QModelIndexList idxL = mFileView->selectionModel()->selectedRows(NameColumn);
    QList<QUrl> files;
    foreach(QModelIndex i, idxL){
        QUrl url = QUrl::fromLocalFile(i.data(FullPathRole).toString());
        files << url;
    }
    mMimeData->setUrls(files);
    QClipboard *clip = qApp->clipboard();
    clip->setMimeData(mMimeData);
}

QList<QStandardItem*> FileWidget::constructRow(CachedFileData *fd) const{
    QList<QStandardItem*> fData;
    QBrush redBrush(Qt::red);
    QBrush greenBrush(Qt::darkGreen);
    QBrush blueBrush(Qt::darkBlue);
    for(int i = 0; i < ColumnCount; ++i){
        QStandardItem *item = new QStandardItem;
        item->setEditable(false);
        if(i == Md5Column){
            item->setFont(QFont("courier new"));
            item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
        }
        if(i == SizeColumn){
            item->setFont(QFont("courier new"));
            item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
        }
        fData << item;
    }
    fData[NameColumn]->setText(fd->name);
    fData[Md5Column]->setText(fd->md5Sum);
    int attr = fd->attr;
    if(attr == Present){
        fData[IconColumn]->setIcon(QIcon(":/huge_bra.png"));
        fData[NameColumn]->setForeground(greenBrush);
    }else if(attr == NotPresent){
        fData[IconColumn]->setIcon(QIcon(":/chastity_belt.png"));
        fData[NameColumn]->setForeground(redBrush);
    }else if(attr == ParentDir){
        fData[IconColumn]->setIcon(QIcon(":/up_dick.png"));
    }else if(attr == Directory){
        fData[IconColumn]->setIcon(QIcon(":/folder.png"));
    }else if(attr == NoVideo){
        fData[IconColumn]->setIcon(QIcon(":/gaping_ass.png"));
    }
    qint64 size = fd->size;
    QString sizeStr;
    if(size){
        QLocale l;
        sizeStr = QString("%1").arg(l.toString(size));
    }
    fData[SizeColumn]->setText(sizeStr);
    fData[SizeColumn]->setData(size, SizeRole);
    bool copied = fd->copied;
    if(copied){
        fData[CopiedColumn]->setText(QChar(0x2642));
        fData[CopiedColumn]->setForeground(blueBrush);
    }else{
        fData[CopiedColumn]->setText(QChar(0x2640));
        fData[CopiedColumn]->setForeground(redBrush);
    }
    fData[DurationColumn]->setText(fd->duration);
    fData[DurationColumn]->setData(fd->seconds, SecondsRole);
    QString mimeType = fd->mimeType;
    if(mimeType == "inode/directory"){
        fData[MimeColumn]->setText("directory");
    }else{
        fData[MimeColumn]->setText(mimeType);
    }
    for(int i = 0; i < ColumnCount; ++i){
        fData[i]->setData(fd->attr, AttrsRole);
        fData[i]->setData(fd->fullPath, FullPathRole);
        fData[i]->setData(fd->md5Sum, MD5SumRole);
    }
    return fData;
}

void FileWidget::paste(){
    QClipboard *clip = qApp->clipboard();
    const QMimeData *md = clip->mimeData();
    if(md->hasUrls()){
        qApp->setOverrideCursor(Qt::WaitCursor);
        QList<QUrl> urls = md->urls();
        int count = 0;
        mProgressBar->reset();
        mProgressBar->setMaximum(urls.count() - 1);
        for(QUrl u : urls){
            QString path = u.toLocalFile();
            QString newDir = mDir->text();
            QFileInfo fi(path);
            QString newFile = QString("%1/%2").arg(newDir).arg(fi.fileName());
            mProgressBar->setValue(++count);
            CachedFileData *fd = mFileCache[path];
            if(mFileAction == Copy){
                QString msg = QString(tr("Copying %1").arg(path));
                emit statusMessage(msg);
                qApp->processEvents();
                if(QFile::copy(path, newFile)){
                    CachedFileData *fdNew = new CachedFileData(*fd);
                    fdNew->fullPath = newFile;
                    mFileCache.insert(newFile, fdNew);
                }
            }else if(mFileAction == Cut){
                QString msg = QString(tr("Moving %1").arg(path));
                emit statusMessage(msg);
                qApp->processEvents();
                if(QFile::rename(path, newFile)){
                    CachedFileData *fd = mFileCache.take(path);
                    if(fd){
                        mFileCache.remove(path);
                        mFileCache.insert(newFile, fd);
                    }
                }
            }
            emit statusMessage("Finished Paste!");
        }
        gatherData();
        qApp->restoreOverrideCursor();
    }
}

void FileWidget::selectFirst(){
    if(mModel->rowCount() > 0){
        QModelIndex idx = mModel->index(0, 0);
        mFileView->setCurrentIndex(idx);
        mFileView->selectionModel()->select(idx, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
    }
}

void FileWidget::addAsOrigin(){
    mOrignDlg->clear();
    QModelIndex idx = mFileView->selectionModel()->selectedRows().first();
    QString fp = idx.data(FullPathRole).toString();
    mOrignDlg->setSrctData(fp);
    mOrignDlg->setDstData(fp);
    mOrignDlg->show();
}

void FileWidget::setupProgress(QString file, QString dest, qint64 size){
    mCopyProgress->setMaximum(size / 1024 / 1024);
    mCopyProgress->setValue(0);
    QFileInfo fi(file);
    QString srcLabel = QString(tr("Copying %1")).arg(fi.fileName());
    QFileInfo fi2(dest);
    QString dstLabel = QString(tr("to %2")).arg(QDir::toNativeSeparators(fi2.absolutePath()));
    mCopyProgress->setLabelText(srcLabel, dstLabel);
}

void FileWidget::setCopyProgress(qint64 bytes){
    int val = bytes / 1024 / 1024;
    mCopyProgress->setValue(val);
}

void FileWidget::setCopySummary(qint64 bytes, qint64 elapsed){
    QHash<QString,QString> jobs = mFileCopier->jobs();
    float rate = bytes / (elapsed / 1000) / 1024 / 1024.0;
    QString sum = QString("%1 file(s), @ %2 MB/s").arg(QString::number(jobs.count() + 1)).arg(QString::number(rate, 'f', 2));
    mCopyProgress->setSummary(sum);
}

void FileWidget::copyFiles(QString destDir){
    QModelIndexList files = mFileView->selectionModel()->selectedRows();
    if(!files.isEmpty()){
        foreach(auto idx, files){
            QString fp = idx.data(FullPathRole).toString();
            QFileInfo fi(fp);
            if(!fi.exists() || fi.isDir()){
                continue;
            }
            QString destFile = QString("%1%2%3").arg(destDir).arg(QDir::separator()).arg(fi.fileName());
            mFileCopier->addJob(fp, destFile);
        }
        mCopyProgress->show();
        if(!mFileCopier->isRunning()){
            mFileCopier->start();
        }
    }
}

void FileWidget::hideCopyProgress(){
    if(mFileCopier->isRunning()){
        mFileCopier->cancel();
    }
    mCopyProgress->hide();
}

void FileWidget::copySuccess(bool success, QString source){
    if(success){
        QFileInfo fi(source);
        auto sourceFiles = mModel->findItems(fi.fileName(), Qt::MatchExactly, NameColumn);
        if(!sourceFiles.isEmpty()){
            QModelIndex idx = mModel->indexFromItem(sourceFiles.first());
            if(idx.isValid()){
                QModelIndex copyIdx = idx.sibling(idx.row(), CopiedColumn);
                mModel->setData(copyIdx, QColor(Qt::blue), Qt::ForegroundRole);
                mModel->setData(copyIdx, QChar(0x2642));
            }
        }
        CachedFileData *fd = mFileCache[source];
        if(fd){
            fd->copied = true;
        }
    }
}

void FileWidget::fileSelectionChanged(const QItemSelection &selected, const QItemSelection &deselected){
    Q_UNUSED(selected);
    Q_UNUSED(deselected);
    int count = mFileView->selectionModel()->selectedRows().count();
    int total = mModel->rowCount();
    QString msg = QString("%1/%2").arg(QString::number(count)).arg(QString::number(total));
    emit selectionCountChanged(msg);
    QModelIndexList idxl = mFileView->selectionModel()->selectedRows(DurationColumn);
    qint64 seconds = 0;
    foreach(QModelIndex idx, idxl){
        seconds += idx.data(SecondsRole).toLongLong();
    }
    Helper::Duration dur(seconds);
    emit durationChanged(dur.toString());
}

void FileWidget::properties(){
    QModelIndexList idxs = mFileView->selectionModel()->selectedRows();
    if(!idxs.isEmpty()){
        QModelIndex cur = idxs.first();
        int attr = cur.data(AttrsRole).toInt();
        if(attr != ParentDir && attr != Directory){
            mFileView->selectionModel()->select(cur, QItemSelectionModel::Rows);
            properties(cur);
        }
    }
}

void FileWidget::properties(const QModelIndex &idx){
    QModelIndex name = idx;
    QString mime = idx.sibling(idx.row(), MimeColumn).data().toString();
    if(name.column() != NameColumn){
        name = idx.sibling(idx.row(), NameColumn);
    }
    int attr = name.data(AttrsRole).toInt();
    if(attr == ParentDir || attr == Directory){
        cd(name.data().toString());
        return;
    }
    if(mime.startsWith("video")){
        fileData(name.data(FullPathRole).toString(), name.data(MD5SumRole).toString());
    }
    if(mime.startsWith("image")){
        Viewer *v = Globals::instance()->viewer();
        v->setFile(idx.data(FullPathRole).toString());
        v->show();
    }
}

void FileWidget::preview(){
    QModelIndex idx = mFileView->selectionModel()->currentIndex();
    if(!idx.isValid()){
        return;
    }
    QString mime = idx.sibling(idx.row(), MimeColumn).data().toString();
    QString file = idx.data(FullPathRole).toString();
    qApp->setOverrideCursor(Qt::WaitCursor);
    Viewer *v = Globals::instance()->viewer();
    if(mime.startsWith("video")){
        v->preview(file);
    }else if(mime.startsWith("image")){
        v->setFile(file, false);
    }
    qApp->restoreOverrideCursor();
    v->show();
}

void FileWidget::cd(const QString &to){
    QString ld = mDir->text();
    QDir cur(mDir->text());
    if(cur.cd(to)){
        QString newDir = cur.absolutePath();
        mDir->setText(QDir::toNativeSeparators(newDir));
        mLastDir = ld;
        gatherData();
    }else{
        QString msg = QString(tr("Could not cd to %1")).arg(to);
        emit statusMessage(msg);
    }
}

void FileWidget::cdUp(){
    cd("..");
}

void FileWidget::cdLast(){
    cd(mLastDir);
}

void FileWidget::deleteFiles(){
    QModelIndexList selFiles = mFileView->selectionModel()->selectedRows(NameColumn);
    if(selFiles.isEmpty()){
        return;
    }
    const QString msg = QString(tr("Really delete %1 file(s)?")).arg(QString::number(selFiles.count()));
    int retval = QMessageBox::question(this, tr("Delete files..."), msg);
    if(retval == QMessageBox::Yes){
        QStringList removed;
        for(const QModelIndex& idx : selFiles){
            QString path = idx.data(FullPathRole).toString();
            QFileInfo fi(path);
            bool success = false;
            if(fi.isDir()){
                QDir d(fi.absoluteFilePath());
                success = d.removeRecursively();
            }else{
                success = QFile::remove(path);
                if(!success){
                    QFile f(path);
                    f.setPermissions(QFile::ReadOther | QFile::WriteOther);
                    success = f.remove();
                }
            }
            if(success){
                mFileCache.remove(fi.absoluteFilePath());
                removed << idx.data().toString();
            }
        }
        for(const QString& f : removed){
            QList<QStandardItem*> res = mModel->findItems(f, Qt::MatchExactly, NameColumn);
            if(!res.isEmpty()){
                mModel->removeRow(res.at(0)->row());
            }
        }
    }
}

void FileWidget::keyPressEvent(QKeyEvent *e){
    if(e->key() == Qt::Key_S && (e->modifiers() & Qt::ControlModifier)){
        mFilter->setFocus();
        mFilter->selectAll();
        goto exit;
    }
    if(e->key() == Qt::Key_D && (e->modifiers() & Qt::ControlModifier)){
        mDir->setFocus();
        mDir->selectAll();
        goto exit;
    }
    if(e->key() == Qt::Key_F && (e->modifiers() & Qt::ControlModifier)){
        mFileView->setFocus();
        goto exit;
    }
    if(mFileView->hasFocus()){
        if(e->key() == Qt::Key_Return){
            QModelIndex cur = mFileView->selectionModel()->currentIndex();
            QString mimeType = cur.sibling(cur.row(), MimeColumn).data().toString();
            if(mimeType == "directory"){
                cd(cur.sibling(cur.row(), NameColumn).data().toString());
            }else{
                properties();
            }
        }
    }

    return QWidget::keyPressEvent(e);

    exit:
    e->accept();
}

void FileWidget::contextMenuEvent(QContextMenuEvent *e){
    QMenu contextMenu(this);
    QSettings s;
    mCopyToMenu->clear();
    mCopyToMenu->setTitle(tr("Copy Files to..."));
    mCopyToMenu->setIcon(QIcon(":/hourglass_figure.png"));
    QStringList copyToDirs = s.value("copydirs").toStringList();
    for(QString &d : copyToDirs){
        QFileInfo di(d);
        if(di.exists()){
            QAction *copyA = new QAction(di.fileName(), mCopyToMenu);
            connect(copyA, &QAction::triggered, [=] { copyFiles(di.absoluteFilePath()); });
            mCopyToMenu->addAction(copyA);
        }
    }
    contextMenu.addMenu(mCopyToMenu);
    contextMenu.addAction(createSeparator());
    contextMenu.addActions(actions());
    contextMenu.exec(e->globalPos());
}