/*
  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 "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("SELECT insert_movie(:title, :filename, :md5, :filesize, :genre, :quality, :dvd");
	mDeleteQuery = new QSqlQuery("DELETE FROM movies WHERE imovid = :id");
	mDeleteActorsForMovie = new QSqlQuery("DELETE FROM movieactormap WHERE imovid = :id");
	mInsertActorsForMovie = new QSqlQuery("INSERT INTO movieactormap VALUES(:movid, :actorid");
	mDeleteCovers = new QSqlQuery("DELETE FROM covers WHERE imovid = :id");
	mInsertCovers = new QSqlQuery("INSERT INTO covers VALUES(:filename, :movid, :covertype, :md5sum");
	mColumnQueries << new QSqlQuery("UPDATE movies SET ttitle = :value WHERE imovid = :id");
	mColumnQueries << new QSqlQuery("UPDATE movies SET tfilename = :value WHERE imovid = :id");
	mColumnQueries << new QSqlQuery("UPDATE movies SET cmd5sum = :value WHERE imovid = :id");
	mColumnQueries << new QSqlQuery("UPDATE movies SET bisize = :value WHERE imovid = :id");
	mColumnQueries << new QSqlQuery("UPDATE movies SET igenreid = :value WHERE imovid = :id");
	mColumnQueries << new QSqlQuery("UPDATE movies SET iquality = :value WHERE imovid = :id");
	mColumnQueries << new QSqlQuery("UPDATE movies SET idvd = :value WHERE imovid = :id");
	populate();
}

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

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);
}

QVariant MovieModel::data(const QModelIndex &index, int role) const{
	if(!index.isValid()){
		return QVariant();
	}
	if(role == Qt::DisplayRole){
		MovieItem *item = static_cast<MovieItem*>(index.internalPointer());
		Q_ASSERT(item != 0);
		switch (index.column()){
			case MovieItem::Dvd:
				return QVariant(QString(tr("DVD %1")).arg(QString::number(item->dataAt(MovieItem::Dvd).toInt())));
		}
		return item->dataAt(index.column());
	}
	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();
	}
}

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();
	}
}

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);
}

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());
}

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