/*
  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 <QSqlQuery>
#include <QStringList>
#include <QIcon>
#include <QSettings>

#include "moviemodel.h"
#include "coveritem.h"

MovieModel::MovieModel(QObject *parent) : QAbstractItemModel(parent) {
	mHeaders << tr("Title") << tr("Filename") << tr("MD5Sum") << tr("Size") << tr("Genre") << tr("Quality") << tr("Archived");
	mInsertQuery = new QSqlQuery;
	mInsertQuery->prepare("SELECT insert_movie(:title, :filename, :md5, :filesize, :genre, :quality, :dvd, :seriesno, :partno)");
	mDeleteQuery = new QSqlQuery;
	mDeleteQuery->prepare("DELETE FROM movies WHERE imovid = :id");
	mDeleteActorsForMovie = new QSqlQuery;
	mDeleteActorsForMovie->prepare("DELETE FROM movieactormap WHERE imovid = :id");
	mInsertActorsForMovie = new QSqlQuery;
	mInsertActorsForMovie->prepare("INSERT INTO movieactormap VALUES(:movid, :actorid)");
	mDeleteCovers = new QSqlQuery;
	mDeleteCovers->prepare("DELETE FROM covers WHERE imovid = :id");
	mInsertCovers = new QSqlQuery;
	mInsertCovers->prepare("INSERT INTO covers VALUES(:filename, :movid, :covertype, :md5sum)");
	mOtherPartsQuery = new QSqlQuery;
	mOtherPartsQuery->prepare("SELECT imovid FROM movies WHERE ttitle = :title AND iseriesno = :seriesno AND imovid != :id");
	QSqlQuery *c1 = new QSqlQuery;
	c1->prepare("UPDATE movies SET ttitle = :value WHERE imovid = :id");
	mColumnQueries << c1;
	QSqlQuery *c2 = new QSqlQuery;
	c2->prepare("UPDATE movies SET tfilename = :value WHERE imovid = :id");
	mColumnQueries << c2;
	QSqlQuery *c3 = new QSqlQuery;
	c3->prepare("UPDATE movies SET cmd5sum = :value WHERE imovid = :id");
	mColumnQueries << c3;
	QSqlQuery *c4 = new QSqlQuery;
	c4->prepare("UPDATE movies SET bisize = :value WHERE imovid = :id");
	mColumnQueries << c4;
	QSqlQuery *c5 = new QSqlQuery;
	c5->prepare("UPDATE movies SET igenreid = :value WHERE imovid = :id");
	mColumnQueries << c5;
	QSqlQuery *c6 = new QSqlQuery;
	c6->prepare("UPDATE movies SET iquality = :value WHERE imovid = :id");
	mColumnQueries << c6;
	QSqlQuery *c7 = new QSqlQuery;
	c7->prepare("UPDATE movies SET idvd = :value WHERE imovid = :id");
	mColumnQueries << c7;
	QSqlQuery *c8 = new QSqlQuery;
	c8->prepare("UPDATE movies SET iseriesno = :value WHERE imovid = :id");
	mColumnQueries << c8;
	QSqlQuery *c9 = new QSqlQuery;
	c9->prepare("UPDATE movies set ipartno = :value WHERE imovid = :id");
	mColumnQueries << c9;
	populate();
}

MovieModel::~MovieModel(){
	qDeleteAll(mItems);
	qDeleteAll(mColumnQueries);
	delete mInsertQuery;
	delete mDeleteQuery;
	delete mDeleteActorsForMovie;
	delete mInsertActorsForMovie;
	delete mDeleteCovers;
	delete mInsertCovers;
	delete mOtherPartsQuery;
}

QModelIndex MovieModel::index(int row, int column, const QModelIndex &parent) const{
	if((parent != QModelIndex()) || (!hasIndex(row, column, parent)) || (row > mItems.size())){
		return QModelIndex();
	}
	MovieItem *internal = mItems.at(row);
	return createIndex(row, column, internal);
}

QModelIndex MovieModel::index(int movieId, int column) const{
	QModelIndex retval = QModelIndex();
	for(int i = 0; i < rowCount(QModelIndex()); ++i){
		MovieItem *item = mItems.at(i);
		if(item->id() == movieId){
			retval = createIndex(i, column, item);
			break;
		}
	}
	return retval;
}

QModelIndexList MovieModel::columnContains(const QVariant &content, int column) const{
	QModelIndexList retval;
	if((column == MovieItem::Title) || (column == MovieItem::Filename) || (column == MovieItem::Md5Sum)){
		QString part = content.toString();
		for(int i = 0; i < mItems.size(); ++i){
			QString current = mItems.at(i)->dataAt(column).toString();
			if(current.contains(part)){
				retval << createIndex(i, column, mItems.at(i));
			}
		}
	}else{
		qint64 value = content.toLongLong();
		for(int i = 0; i < mItems.size(); ++i){
			qint64 current = mItems.at(i)->dataAt(column).toLongLong();
			if(value == current){
				retval << createIndex(i, column, mItems.at(i));
			}
		}
	}
	return retval;
}

QVariant MovieModel::data(const QModelIndex &index, int role) const{
	if(!index.isValid()){
		return QVariant();
	}
	QSettings s;
	MovieItem *item = static_cast<MovieItem*>(index.internalPointer());
	Q_ASSERT(item != 0);
	if(role == Qt::DisplayRole){
		if(index.column() == 0){
			QString retval = item->dataAt(MovieItem::Title).toString();
			int seriesno = item->dataAt(MovieItem::SeriesNo).toInt();
			int partno = item->dataAt(MovieItem::PartNo).toInt();
			if(seriesno != -1){
				retval.append(QString(" %1").arg(QString::number(seriesno)));
			}
			if(partno != -1){
				retval.append(QString(" (part %1)").arg(QString::number(partno)));
			}
			return retval;
		}else{
			return item->dataAt(index.column());
		}
	}
	if(role == ActorsRole){
		return item->actors();
	}
	if(role == ActorsMap){
		return QVariant(item->actorMap());
	}
	if(role == CoverRole){
		return item->covers();
	}
	if(role == IdRole){
		return item->id();
	}
	if(role == TitleBaseRole){
		return item->dataAt(MovieItem::Title);
	}
	if(role == SeriesNoRole){
		return item->dataAt(MovieItem::SeriesNo);
	}
	if(role == PartNoRole){
		return item->dataAt(MovieItem::PartNo);
	}
	if(role == FilenameRole){
		return item->dataAt(MovieItem::Filename);
	}
	if(role == Md5Role){
		return item->dataAt(MovieItem::Md5Sum);
	}
	if(role == SizeRole){
		return item->dataAt(MovieItem::Size);
	}
	if(role == GenreRole){
		return item->dataAt(MovieItem::Genre);
	}
	if(role == QualityRole){
		return item->dataAt(MovieItem::Quality);
	}
	if(role == DvdRole){
		return item->dataAt(MovieItem::Dvd);
	}
	if(role == FullPathRole){
		QString archivePath = s.value("paths/archivedir").toString();
		QString md5 = item->dataAt(MovieItem::Md5Sum).toString();
		QString fileName = item->dataAt(MovieItem::Filename).toString();
		QString retval = QString("%1/%2/%3/%4").arg(archivePath).arg(md5.at(0)).arg(md5.at(1)).arg(fileName);
		return retval;
	}
	if(role == CoverPathRole){
		QList<QVariant> retval;
		QList<QVariant> covers = item->covers();
		foreach(QVariant c, covers){
			CoverItem i = c.value<CoverItem>();
			retval << i.fullPath();
		}
		return retval;
	}
	if(role == OtherPartsRole){
		QList<QVariant> retval;
		mOtherPartsQuery->bindValue(":title", item->dataAt(MovieItem::Title));
		mOtherPartsQuery->bindValue(":seriesno", item->dataAt(MovieItem::SeriesNo));
		mOtherPartsQuery->bindValue(":id", item->id());
		mOtherPartsQuery->exec();
		while(mOtherPartsQuery->next()){
			retval << mOtherPartsQuery->value(0);
		}
		return retval;
	}
	if((role == Qt::DecorationRole) && (index.column() == 0)){
		return QIcon(":/dildo.png");
	}
	return QVariant();
}

Qt::ItemFlags MovieModel::flags(const QModelIndex &index) const{
	if(!index.isValid()){
		return 0;
	}
	return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
}

QVariant MovieModel::headerData(int section, Qt::Orientation o, int role) const{
	if((o == Qt::Horizontal) && (role == Qt::DisplayRole)){
		if(section < mHeaders.size()){
			return mHeaders.at(section);
		}
	}
	return QVariant();
}

bool MovieModel::insertRows(int row, int count, const QModelIndex &){
	if(row > rowCount(QModelIndex())){
		return false;
	}
	beginInsertRows(QModelIndex(), row, row);
	for(int i = row; i < (row + count); ++i){
		MovieItem *newItem = new MovieItem(-1, 0);
		mItems.insert(row, newItem);
	}
	endInsertRows();
	return true;
}

bool MovieModel::removeRows(int row, int count, const QModelIndex &){
	if(row >= rowCount(QModelIndex())){
		return false;
	}
	beginRemoveRows(QModelIndex(), row, row + count - 1);
	for(int i = row; i < (row + count); ++i){
		MovieItem *item = mItems.at(i);
		delete item;
		mItems.removeAt(i);
	}
	endRemoveRows();
	return true;
}

bool MovieModel::setRow(const QModelIndex &idx, const QList<QVariant> &data, const QList<QVariant> &actors, const QList<CoverItem> &covers){
	if(!idx.isValid() || (data.size() > MovieItem::NumRows)){
		return false;
	}
	MovieItem *item = static_cast<MovieItem*>(idx.internalPointer());
	Q_ASSERT(item != 0);
	if(item->id() != -1){
		qWarning("ID not as expected: item->id() == %d", item->id());
		return false;
	}
	for(int i = 0; i < MovieItem::NumRows; ++i){
		mInsertQuery->bindValue(i, data[i]);
	}
	mInsertQuery->exec();
	int id(0);
	while(mInsertQuery->next()){
		id = mInsertQuery->value(0).toInt();
	}
	if(id == -1){
		return false;
	}
	if(!actors.isEmpty()){
		setActors(id, actors);
	}
	if(!covers.isEmpty()){
		setCovers(id, covers);
	}
	item->setId(id);
	QModelIndex start = index(idx.row(), 0, QModelIndex());
	QModelIndex end = index(idx.row(), MovieItem::NumRows - 1, QModelIndex());
	emit dataChanged(start, end);
	return true;
}

bool MovieModel::setDataAt(const QModelIndex &idx, const QVariant &data){
	if(!idx.isValid()){
		return false;
	}
	MovieItem *item = static_cast<MovieItem *>(idx.internalPointer());
	Q_ASSERT(item != 0);
	int id = item->id();
	int column = idx.column();
	QSqlQuery *query = mColumnQueries.at(column);
	query->bindValue(":value", data);
	query->bindValue(":id", id);
	if(!query->exec()){
		return false;
	}
	item->setDataAt(column, data);
	emit dataChanged(idx, idx);
	return true;
}

void MovieModel::setActors(int id, const QList<QVariant> &actors){
	mDeleteActorsForMovie->bindValue(":id", id);
	mDeleteActorsForMovie->exec();
	foreach(QVariant a, actors){
		mInsertActorsForMovie->bindValue(":movid", id);
		mInsertActorsForMovie->bindValue(":actorid", a);
		mInsertActorsForMovie->exec();
	}
	foreach(MovieItem *m, mItems){
		if(m->id() == id){
			m->setActors();
		}
	}
}

void MovieModel::setCovers(int id, const QList<CoverItem> &covers){
	mDeleteCovers->bindValue(":id", id);
	mDeleteCovers->exec();
	foreach(CoverItem c, covers){
		mInsertCovers->bindValue(":filename", c.fileName());
		mInsertCovers->bindValue(":movid", id);
		mInsertCovers->bindValue(":covertype", c.type());
		mInsertCovers->bindValue(":md5", c.md5());
		mInsertCovers->exec();
	}
	foreach(MovieItem *m, mItems){
		if(m->id() == id){
			m->setCovers();
		}
	}
}

void MovieModel::addMovie(const QList<QVariant> &data, const QList<QVariant> &actors, const QList<CoverItem> &covers){
	int row = rowCount(QModelIndex());
	insertRows(row, 1, QModelIndex());
	QModelIndex i = index(row, 0, QModelIndex());
	setRow(i, data, actors, covers);
	emit moviesChanged();
}

void MovieModel::removeMovie(const QModelIndex &idx){
	if(!idx.isValid()){
		return;
	}
	MovieItem *item = static_cast<MovieItem*>(idx.internalPointer());
	Q_ASSERT(item != 0);
	int id = item->id();
	mDeleteQuery->bindValue(":id", id);
	if(!mDeleteQuery->exec()){
		return;
	}
	removeRows(idx.row(), 1, QModelIndex());
}

const QVariant MovieModel::maxValue(int column) const{
	if(mItems.isEmpty()){
		return QVariant();
	}
	QVariant sample = mItems.at(0)->dataAt(column);
	if(sample.canConvert(QVariant::LongLong)){
		qint64 retval(-1);
		foreach(MovieItem* i, mItems){
			qint64 value = i->dataAt(column).toLongLong();
			if(value > retval){
				retval = value;
			}
		}
		return retval;
	}
	if(sample.canConvert(QVariant::String)){
		QString retval;
		foreach(MovieItem *i, mItems){
			QString value = i->dataAt(column).toString();
			if(value > retval){
				retval = value;
			}
		}
		return retval;
	}
	return QVariant();
}

void MovieModel::populate(){
	QSqlQuery movieQuery("SELECT imovid FROM movies");
	while(movieQuery.next()){
		int id = movieQuery.value(0).toInt();
		MovieItem *item = new MovieItem(id);
		mItems << item;
	}
}