/*
  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 <QSqlDatabase>
#include <QSqlQuery>
#include <QSpinBox>
#include <QLineEdit>
#include <QComboBox>
#include <QPlainTextEdit>
#include <QDateEdit>
#include <QFormLayout>
#include <QVBoxLayout>
#include <QLabel>
#include <QGroupBox>
#include <QPalette>
#include <QSettings>
#include <QColor>
#include <QScrollArea>

#include "seriesmetadatamodel.h"
#include "smtreeitem.h"
#include "smglobals.h"
#include "helper.h"

SeriesMetadataModel::SeriesMetadataModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mColumns(9), mDataChanged(false), mCurrentId(-1){
	//setup database
	mDb = QSqlDatabase::database("treedb");
	mPopulateQuery = new QSqlQuery(mDb);
	mPopulateQuery->prepare("SELECT iseriespart_id, sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded FROM metadata WHERE iseriespart_id = :id");
	mPresentQuery = new QSqlQuery(mDb);
	mPresentQuery->prepare("SELECT COUNT(*) FROM metadata WHERE iseriespart_id = :id");
	mUpdateQuery = new QSqlQuery(mDb);
	mUpdateQuery->prepare("UPDATE metadata SET sireleaseyear = :year, tsourcemedium = :source, tsubject = :subject, treleasegroup = :group, tencoderopts = :encopts, tcomment = :comment, sipasses = :passes, dadded = :added WHERE iseriespart_id = :id");
	mInsertQuery = new QSqlQuery(mDb);
	mInsertQuery->prepare("INSERT INTO metadata (iseriespart_id, sireleaseyear, tsourcemedium, tsubject, treleasegroup, tencoderopts, tcomment, sipasses, dadded) VALUES(:id, :year, :source, :subject, :group, :encopts, :comment, :passes, :added)");

	//misc
	mColumnNames.insert(SeriesPartId, "iseriespart_id");
	mColumnNames.insert(ReleaseYear, "sireleaseyear");
	mColumnNames.insert(SourceMedium, "tsourcemedium");
	mColumnNames.insert(Subject, "tsubject");
	mColumnNames.insert(ReleaseGroup, "treleasegroup");
	mColumnNames.insert(EncoderOpts, "tencoderopts");
	mColumnNames.insert(Comment, "tcomment");
	mColumnNames.insert(Passes, "sipasses");
	mColumnNames.insert(Added, "dadded");
}

SeriesMetadataModel::~SeriesMetadataModel(){
	delete mPopulateQuery;
	delete mPresentQuery;
	delete mUpdateQuery;
	delete mInsertQuery;
	mDb = QSqlDatabase();
}

QVariant SeriesMetadataModel::data(const QModelIndex &index, int role) const{
	if(!index.isValid()){
		return QVariant();
	}
	SmTreeItem *item = itemAt(index);
	if(role == SeriesPartIdRole){
		return item->data(SeriesPartId);
	}
	if(role == ReleaseYearRole){
		return item->data(ReleaseYear);
	}
	if(role == SourceMediumRole){
		return item->data(SourceMedium);
	}
	if(role == SubjectRole){
		return item->data(Subject);
	}
	if(role == ReleaseGroupRole){
		return item->data(ReleaseGroup);
	}
	if(role == EncoderOptsRole){
		return item->data(EncoderOpts);
	}
	if(role == CommentRole){
		return item->data(Comment);
	}
	if(role == PassesRole){
		return item->data(Passes);
	}
	if(role == AddedRole){
		return item->data(Added);
	}
	return SmTreeModel::data(index, role);
}

const QList<QVariant> SeriesMetadataModel::dataList(const QModelIndex &index) const{
	if(!index.isValid()){
		return QList<QVariant>();
	}
	QList<QVariant> retval;
	SmTreeItem *item = itemAt(index);
	for(int i = 0; i < mColumns; ++i){
		retval << item->data(i);
	}
	return retval;
}

const QList<QVariant> SeriesMetadataModel::fieldList(int field, bool distinct) const{
	if(field >= mColumns){
		return QList<QVariant>();
	}
	QString queryTempl;
	if(distinct){
		queryTempl = QString("SELECT DISTINCT(%1) FROM metadata ORDER BY %1").arg(mColumnNames.value(field));
	}else{
		queryTempl = QString("SELECT %1 FROM metadata ORDER BY %1").arg(mColumnNames.value(field));
	}
	QList<QVariant> retval;
	QSqlQuery query(queryTempl, mDb);
	while(query.next()){
		retval << query.value(0);
	}
	return retval;
}

bool SeriesMetadataModel::setData(const QModelIndex &index, const QVariant &value, int role){
	if(!index.isValid()){
		return false;
	}
	mDataChanged = true;
	return SmTreeModel::setData(index, value, role);
}

bool SeriesMetadataModel::setData(const QModelIndex &parent, const QVariant &value, int row, int column, int role){
	if(row >= mColumns){
		return false;
	}
	QModelIndex idx = index(row, column, parent);
	return setData(idx, value, role);
}

bool SeriesMetadataModel::hasRecord(int seriesPartId) const{
	int count = -1;
	mPresentQuery->bindValue(":id", seriesPartId);
	if(mPresentQuery->exec()){
		while(mPresentQuery->next()){
			count = mPresentQuery->value(0).toInt();
		}
	}
	return (count > 0);
}

void SeriesMetadataModel::populate(int seriesPartId){
	mDataChanged = false;
	mCurrentId = seriesPartId;
	SmTreeItem *rootItem = new SmTreeItem(mColumns);
	rootItem->setData(SeriesPartId, -1);
	if(hasRecord(seriesPartId)){
		QList<QVariant> items;
		mPopulateQuery->bindValue(":id", seriesPartId);
		mPopulateQuery->exec();
		while(mPopulateQuery->next()){
			for(int i = 0; i < mColumns; ++i){
				items << mPopulateQuery->value(i);
			}
		}
		SmTreeItem *childItem = new SmTreeItem(items, rootItem);
		rootItem->appendChild(childItem);
	}else{
		SmTreeItem *childItem = new SmTreeItem(mColumns, rootItem);
		childItem->setData(0, seriesPartId);
		rootItem->appendChild(childItem);
	}
	setRoot(rootItem);
}

void SeriesMetadataModel::update(){
	QSqlQuery *query;
	if(hasRecord(mCurrentId)){
		query = mUpdateQuery;
	}else{
		query = mInsertQuery;
	}
	QModelIndex curIdx = find(mCurrentId, SeriesPartId);
	if(!curIdx.isValid()){
		return;
	}
	SmTreeItem *item = itemAt(curIdx);
	query->bindValue(":id", mCurrentId);
	query->bindValue(":year", item->data(ReleaseYear));
	query->bindValue(":source", item->data(SourceMedium));
	query->bindValue(":subject", item->data(Subject));
	query->bindValue(":group", item->data(ReleaseGroup));
	query->bindValue(":encopts", item->data(EncoderOpts));
	query->bindValue(":comment", item->data(Comment));
	query->bindValue(":passes", item->data(Passes));
	query->bindValue(":added", item->data(Added));
	query->exec();
}

MetadataWidget::MetadataWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f){
	//model
	mModel = static_cast<SeriesMetadataModel*>(SmGlobals::instance()->model("SeriesMetadata"));

	//layout
	QFormLayout *rowLayout = new QFormLayout;
	mReleaseYear = new QSpinBox;
	mReleaseYear->setMaximum(3000);
	mReleaseYear->setMinimum(1900);
	rowLayout->addRow(tr("Release year"), mReleaseYear);
	mReleaseGroup = new QComboBox;
	mPasses = new QSpinBox;
	rowLayout->addRow(tr("Encoding passes"), mPasses);
	mReleaseGroup->setEditable(true);
	rowLayout->addRow(tr("Release group"), mReleaseGroup);
	mSourceMedium = new QComboBox;
	mSourceMedium->setEditable(true);
	rowLayout->addRow(tr("Source medium"), mSourceMedium);
	mSubject = new QLineEdit;
	rowLayout->addRow(tr("Usenet subject"), mSubject);
	mEncoderOpts = new QLineEdit;
	rowLayout->addRow(tr("Encoder options"), mEncoderOpts);
	mAdded = new QDateEdit(QDate::currentDate());
	rowLayout->addRow(tr("Date added"), mAdded);
	QVBoxLayout *commentLayout = new QVBoxLayout;
	QLabel *commentLabel = new QLabel(tr("Comment"));
	commentLayout->addWidget(commentLabel);
	mComment = new QPlainTextEdit;
	commentLayout->addWidget(mComment);
	QVBoxLayout *mainLayout = new QVBoxLayout;
	mainLayout->addLayout(rowLayout);
	mainLayout->addLayout(commentLayout);
	setLayout(mainLayout);

	//init widgets
	QStringList relGroups = Helper::toStringList(mModel->fieldList(SeriesMetadataModel::ReleaseGroup));
	mReleaseGroup->addItems(relGroups);
	QStringList sources = Helper::toStringList(mModel->fieldList(SeriesMetadataModel::SourceMedium));
	mSourceMedium->addItems(sources);
}

void MetadataWidget::setSeriesPartId(int id){
	if(!mModel->hasRecord(id)){
		return;
	}
	mModel->populate(id);
	QModelIndex idx = mModel->find(id, SeriesMetadataModel::SeriesPartId);
	if(idx.isValid()){
		mReleaseYear->setValue(idx.data(SeriesMetadataModel::ReleaseYearRole).toInt());
		mPasses->setValue(idx.data(SeriesMetadataModel::PassesRole).toInt());
		int relGroupIdx = mReleaseGroup->findText(idx.data(SeriesMetadataModel::ReleaseGroupRole).toString());
		if(relGroupIdx != -1){
			mReleaseGroup->setCurrentIndex(relGroupIdx);
		}
		int sourceMedIdx = mSourceMedium->findData(idx.data(SeriesMetadataModel::PassesRole));
		if(sourceMedIdx != -1){
			mSourceMedium->setCurrentIndex(sourceMedIdx);
		}
		mSubject->setText(idx.data(SeriesMetadataModel::SubjectRole).toString());
		mEncoderOpts->setText(idx.data(SeriesMetadataModel::EncoderOptsRole).toString());
		mAdded->setDate(idx.data(SeriesMetadataModel::AddedRole).toDate());
		mComment->setPlainText(idx.data(SeriesMetadataModel::CommentRole).toString());
	}
}

void MetadataWidget::accept(){
	QModelIndex curIdx = mModel->find(mModel->currentId(), SeriesMetadataModel::SeriesPartId);
	QModelIndex parent = curIdx.parent();
	int row = curIdx.row();
	mModel->setData(parent, mReleaseYear->value(), row, SeriesMetadataModel::ReleaseYear);
	mModel->setData(parent, mPasses->value(), row, SeriesMetadataModel::Passes);
	mModel->setData(parent, mReleaseGroup->currentText(), row, SeriesMetadataModel::ReleaseGroup);
	mModel->setData(parent, mSourceMedium->currentText(), row, SeriesMetadataModel::SourceMedium);
	mModel->setData(parent, mSubject->text(), row, SeriesMetadataModel::Subject);
	mModel->setData(parent, mEncoderOpts->text(), row, SeriesMetadataModel::EncoderOpts);
	mModel->setData(parent, mAdded->date(), row, SeriesMetadataModel::Added);
	mModel->setData(parent, mComment->toPlainText(), row, SeriesMetadataModel::Comment);
	mModel->update();
}

MetadataDisplay::MetadataDisplay(QWidget *parent) : QWidget(parent){
	//model
	mModel = static_cast<SeriesMetadataModel*>(SmGlobals::instance()->model("SeriesMetadata"));

	//display
	QGroupBox *gb = new QGroupBox(tr("Metadata"));
	QHBoxLayout *gbLayout = new QHBoxLayout;
	mDisplay = new QLabel(tr("No metadata available"));
	mDisplay->setAlignment(Qt::AlignTop | Qt::AlignHCenter);
	mDisplay->setWordWrap(true);
	QScrollArea *sa = new QScrollArea;
	sa->setWidgetResizable(true);
	sa->setWidget(mDisplay);
	gbLayout->addWidget(sa);
	gb->setLayout(gbLayout);

	//laoyut
	QVBoxLayout *mainLayout = new QVBoxLayout;
	mainLayout->addWidget(gb);
	setLayout(mainLayout);
}

void MetadataDisplay::setSeriesPartId(int seriesPartId){
	//setup label + model
	if(mModel->hasRecord(seriesPartId)){
		mModel->populate(seriesPartId);
		QSettings s;
		QColor baseColor = s.value("ui/basecolor").value<QColor>();
		QString baseHtml = Helper::colorToHtml(baseColor);
		QColor alternateColor = s.value("ui/alternatecolor").value<QColor>();
		QString alternateHtml = Helper::colorToHtml(alternateColor);
		QModelIndex mdIdx = mModel->index(0, 0, QModelIndex());
		QList<QVariant> metaData = mModel->dataList(mdIdx);
		QString text("<table>");
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Release Year</span></td><td>%2</td></tr>")).arg(baseHtml).arg(QString::number(metaData.at(SeriesMetadataModel::ReleaseYear).toInt())));
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Encoding Passes</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(QString::number(metaData.at(SeriesMetadataModel::Passes).toInt())));
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Release Group</span></td><td>%2</td></tr>")).arg(baseHtml).arg(metaData.at(SeriesMetadataModel::ReleaseGroup).toString()));
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Source Medium</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(metaData.at(SeriesMetadataModel::SourceMedium).toString()));
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Usenet Subject</span></td><td>%2</td></tr>")).arg(baseHtml).arg(metaData.at(SeriesMetadataModel::Subject).toString()));
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Encoder Options</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(metaData.at(SeriesMetadataModel::EncoderOpts).toString()));
		QDate dateAdded = metaData.at(SeriesMetadataModel::Added).toDate();
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Added</span></td><td>%2</td></tr>")).arg(baseHtml).arg(dateAdded.toString(Qt::ISODate)));
		text.append(QString(tr("<tr style=\"background-color: #%1\"><td style=\"padding-right: 20px; padding-left: 5px\"><span style=\"font-style: italic;\">Comment</span></td><td>%2</td></tr>")).arg(alternateHtml).arg(metaData.at(SeriesMetadataModel::Comment).toString()));
		text.append("</table>");
		mDisplay->setText(text);
	}else{
		mDisplay->setText(tr("No metadata available"));
	}
}