/*
  This program is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License
  as published by the Free Software Foundation; either version
  2 of the License, or (at your option) any later version.
*/

#include <QContextMenuEvent>
#include <QMenu>
#include <QAction>
#include <QKeyEvent>
#include <QModelIndex>
#include <QRegExp>
#include <QFileSystemModel>
#include <QSortFilterProxyModel>
#include <QAction>
#include <QApplication>
#include <QEvent>
#include <QSettings>
#include <QModelIndex>
#include <QFileInfo>
#include <QVariant>
#include <QList>
#include <QDir>
#include <QSortFilterProxyModel>
#include <QInputDialog>
#include <QPalette>
#include <QTimer>
#include <QHeaderView>

#include "fileview.h"
#include "hoverwindow.h"
#include "smglobals.h"
#include "filesystemfileproxy.h"
#include "filepropertiesdialog.h"
#include "smdirmodel.h"

FileView::FileView(QWidget *parent) : SmTreeView("ui/fsheaderpos", parent), mDeleteA(0) {
	setAttribute(Qt::WA_Hover);
	setRootIsDecorated(false);
    setEditTriggers(QAbstractItemView::NoEditTriggers);
    mHoverWin = new HoverWindow(this);
	QSize curSize = SmGlobals::instance()->cursorSize();
	mHoverWin->setHoverOffset(QPoint(curSize.width() + 30, 0));
}

void FileView::setModel(QAbstractItemModel *model){
    mProxy = qobject_cast<FilesystemFileProxy*>(model);
    mModel = qobject_cast<SmDirModel*>(mProxy->sourceModel());
    SmTreeView::setModel(model);
}

QStringList FileView::selectedItems(){
    QModelIndexList items = selectionModel()->selectedRows(SmDirModel::Name);
    if(!items.isEmpty()){
        QStringList retval;
        foreach(QModelIndex idx, items){
            retval << idx.data().toString();
        }
        return retval;
    }
    return QStringList();
}

void FileView::markFiles(){
	bool ok;
	QString title = QString(tr("%1 - %2")).arg(qApp->applicationName()).arg(tr("Mark files"));
	QString glob = QInputDialog::getText(this, title, tr("Enter filename pattern"), QLineEdit::Normal, QString(), &ok);
	if(!ok){
		return;
	}
	int rowCount = model()->rowCount(rootIndex());
	if(!rowCount || glob.isEmpty()){
		return;
	}
    QRegExp re(glob, Qt::CaseInsensitive, QRegExp::WildcardUnix);
	for(int i = 0; i < rowCount; ++i){
        QModelIndex cur = mProxy->mapFromSource((mModel->rootIndex().child(i, 0)));
        if(cur.data(SmDirModel::NameRole).toString() == ".."){
			continue;
		}
        if(re.indexIn(cur.data(SmDirModel::NameRole).toString()) != -1){
			selectionModel()->select(cur, QItemSelectionModel::Select | QItemSelectionModel::Rows);
		}
	}
}

void FileView::unmarkFiles(){
	selectionModel()->clearSelection();
}

void FileView::createFolder(){
	bool ok;
    QString folderName = QInputDialog::getText(this, tr("Create folder"), tr("Enter new folder name"), QLineEdit::Normal, QString(), &ok);
	if(!ok){
		return;
	}
	if(!ok || folderName.isEmpty()){
		return;
	}
    mModel->dir().mkdir(folderName);
}

void FileView::readConfig(){
	QSettings s;
	mHoverPics = s.value("ui/hoverpics", true).toBool();
	mHoverWin->setWindowOpacity(s.value("ui/hoveropacity", 10).toFloat() / 10.0);
	mCursorOffset = s.value("ui/cursoroffset").toInt();
    readHeaderConfig();
}

void FileView::writeConfig(){
    writeHeaderConfig();
}

void FileView::closeEditor(QWidget *editor, QAbstractItemDelegate::EndEditHint hint){
    SmTreeView::closeEditor(editor, hint);
    QModelIndex sourceIdx = mProxy->mapToSource(currentIndex());
	emit editorClosed(sourceIdx);
    mModel->refreshTimer()->start();
}

void FileView::contextMenuEvent(QContextMenuEvent *e){
	mHoverWin->hide();
	QMenu contextMenu(this);
	foreach(QAction *a, actions()){
		contextMenu.addAction(a);
	}
	contextMenu.exec(e->globalPos());
}

void FileView::keyPressEvent(QKeyEvent *e){
	if(!hasFocus()){
        SmTreeView::keyPressEvent(e);
		return;
	}
	switch(e->key()){
		case Qt::Key_Backspace:
			emit upDir();
			e->accept();
			break;
		case Qt::Key_Enter:
		case Qt::Key_Return:
			emit enterPressed(currentIndex());
			e->accept();
			break;
		case Qt::Key_Delete:
			emit delFiles();
			e->accept();
			break;
		default:
            SmTreeView::keyPressEvent(e);
	}
}

void FileView::resizeEvent(QResizeEvent *e){
	if(e->size().width() != e->oldSize().width()){
		int width = e->size().width();
		int c1width = width / 2; // * 2;
		setColumnWidth(0, c1width);
	}
}

bool FileView::event(QEvent *e){
	QHoverEvent *hEvent = static_cast<QHoverEvent*>(e);
	if(!hEvent){
		return exitHover();
	}
    if(e->type() == QEvent::HoverLeave){
        return exitHover();
    }
	QPoint hotSpot(hEvent->pos().x(), hEvent->pos().y() + mCursorOffset);
	QModelIndex curIdx = indexAt(hotSpot);
	HoverFileType ft = None;
    QFileInfo curIdxInfo(curIdx.data(SmDirModel::FullPathRole).toString());
	if((e->type() == QEvent::HoverEnter) || (e->type() == QEvent::HoverMove)){
		if(!curIdx.isValid() || (!curIdx.column() == 0)){
			return exitHover();
		}
		if(curIdx.data().toString() == ".."){
			return exitHover();
		}
		if(curIdxInfo.isFile()){
			QString mimeType = Helper::mimeType(curIdxInfo.absoluteFilePath());
			if(mimeType.startsWith("image")){
				if(!mHoverPics){
					return exitHover();
				}
				ft = Image;
            }else{
				return exitHover();
			}
        }else{
			return exitHover();
		}
	}
	if(e->type() == QEvent::HoverEnter){
		mCurHover = curIdx;
		doHover(curIdxInfo, ft);
		return true;
	}else if(e->type() == QEvent::HoverMove){
		if(mCurHover != curIdx){
			mCurHover = curIdx;
			doHover(curIdxInfo, ft);
		}else{
			mHoverWin->setPos();
		}
		return true;
    }
    return SmTreeView::event(e);
}

void FileView::selectedFilesChanged(){
    QModelIndexList selected = selectionModel()->selectedRows();
    emit numSelected(selected.size());
    qint64 selSize = 0;
    qint64 dur = 0;
    foreach(QModelIndex i, selected){
        selSize += i.data(SmDirModel::SizeRole).toLongLong();
        dur += i.data(SmDirModel::DurSizeRole).toFloat();
    }
    emit selectedSize(selSize);
    emit selectedDuration(dur, false);
}

void FileView::properties(){
    QModelIndexList selected = selectionModel()->selectedRows();
    if(selected.isEmpty()){
        return;
    }
    QString fp = selected.at(0).data(SmDirModel::FullPathRole).toString();
    FilePropertiesDialog fpd(fp, this);
    fpd.exec();
}

void FileView::selectItem(const QString &item){
    QModelIndex start = mProxy->index(0, 0);
    QModelIndexList items = mProxy->match(start, Qt::DisplayRole, item, 1, Qt::MatchExactly | Qt::MatchWrap);
    if(!items.isEmpty()){
        selectionModel()->select(items.at(0), QItemSelectionModel::Rows | QItemSelectionModel::Select);
        scrollTo(items.at(0));
    }
}

void FileView::saveSelection(){
    mSelectedFiles.clear();
    QModelIndexList selected = selectionModel()->selectedRows(SmDirModel::Name);
    foreach(QModelIndex i, selected){
        mSelectedFiles << i.data().toString();
    }
}

void FileView::restoreSelection(){
    foreach(QString s, mSelectedFiles){
        QModelIndex i = mModel->find(s, SmDirModel::Name);
        if(i.isValid()){
            QModelIndex r = mProxy->mapFromSource(i);
            selectionModel()->select(r, QItemSelectionModel::Rows | QItemSelectionModel::Select);
        }
    }
}

bool FileView::exitHover(bool exitVal){
	mHoverWin->setVisible(false);
	mCurHover = QModelIndex();
	return exitVal;
}

void FileView::doHover(const QFileInfo &fi, int type){
	QPixmap pm;
    if(type == Image){
		pm.load(fi.absoluteFilePath());
		mHoverWin->setPixmap(pm);
		mHoverWin->setCaption(fi.fileName());
        mHoverWin->setPos();
        mHoverWin->setVisible(true);
    }
}