path: root/archivemodel.cpp

/*
  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 <QSqlError>
#include <QSqlQuery>

#include "smtreeitem.h"
#include "archivemodel.h"

ArchiveModel::ArchiveModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mOrder(NoOrder){
    mDb = QSqlDatabase::database("treedb");
    mAvailableOrders.insert("Series Name", SeriesName);
    mAvailableOrders.insert("Actor", Actor);
    mAvailableOrders.insert("Genre", Genre);
    mCollector = new ArchiveCollector(NumFields, this);
    connect(mCollector, SIGNAL(finished()), this, SLOT(collectorFinished()));
}

const QStringList ArchiveModel::availableOrders() const {
    QStringList retval = mAvailableOrders.keys();
    qSort(retval);
    return retval;
}

QVariant ArchiveModel::data(const QModelIndex &index, int role) const{
    SmTreeItem *item = itemAt(index);
    if(role == Qt::DisplayRole && index.column() == 0){
        QString retval;
        int part = item->data(SeriesPart).toInt();
        int childCount = item->data(Count).toInt();
        int nodeType = item->data(Type).toInt();
        if(nodeType == SeriesNode || nodeType == GenreNode || nodeType == ActorNode){
            retval = QString("%1 (%2)").arg(item->data(Name).toString()).arg(QString::number(childCount));
        }else if(nodeType == SeriesPartNode){
            if(part > 0){
                retval = QString("%1 %2").arg(item->data(Name).toString()).arg(QString::number(part));
            }else{
                QString subtitle = item->data(Subtitle).toString();
                if(!subtitle.isEmpty()){
                    retval = QString("%1 - %2").arg(item->data(Name).toString()).arg(item->data(Subtitle).toString());
                }
            }
        }else{
            retval = item->data(Name).toString();
        }
        return retval;
    }
    if(role == Qt::ForegroundRole){
        bool favorite = item->data(Favorite).toBool();
        if(favorite){
            return QColor(Qt::darkGreen);
        }
    }
    if(role == NameRole){
        return item->data(Name);
    }
    if(role == TypeRole){
        return item->data(Type);
    }
    return SmTreeModel::data(index, role);
}

bool ArchiveModel::setData(const QModelIndex &idx, const QVariant &value, int role){
    if(role != Qt::EditRole){
        return false;
    }
    SmTreeItem *item = itemAt(idx);
    int nodeType = item->data(Type).toInt();
    QSqlQuery updateQuery(mDb);
    if(nodeType == GenreNode){
        updateQuery.prepare("UPDATE genres SET tgenrename = :value WHERE igenres_id = :id");
    }else if(nodeType == ActorNode){
        updateQuery.prepare("UPDATE actors SET tactorname = :value WHERE iactors_id = :id");
    }else if(nodeType == SeriesNode){
        updateQuery.prepare("UPDATE series SET tseries_name = :value WHERE iseries_id = :id");
    }else{
        return false;
    }
    QVariant id = item->data(GenericId);
    updateQuery.bindValue(":value", value);
    updateQuery.bindValue(":id", id);
    if(updateQuery.exec()){
        if(nodeType == GenreNode || nodeType == ActorNode){
            item->setData(Name, value);
            emit dataChanged(idx, idx);
            return true;
        }else if(nodeType == SeriesNode){
            item->setData(Name, value);
            emit needRefresh();
            return true;
        }
    }else{
        emitDatabaseError(updateQuery.lastError());
    }
    return false;
}

bool ArchiveModel::matchRecursive(const QModelIndex &parent, const QRegExp &regex, int column) const {
    if(!parent.isValid()){
        return false;
    }
    // first try the parent itself
    QString value = parent.data().toString();
    if(value.isEmpty()){
        return false;
    }
    if(value.contains(regex)){
        return true;
    }

    // no match, check for children
    SmTreeItem *item = static_cast<SmTreeItem*>(parent.internalPointer());
    if(!item->childCount()){
        //leaf, chech parents
        return checkParents(item, regex, column);
    }

    // we have children, traverse them
    bool retval = false;
    for(int i = 0; i < item->childCount(); ++i){
        QModelIndex newIdx = createIndex(i, column, item->child(i));
        retval = matchRecursive(newIdx, regex, column);
        if(retval){
            break;
        }
    }
    return retval;
}

bool ArchiveModel::removeNode(const QModelIndex &idx){
    if(!idx.isValid()){
        return false;
    }
    SmTreeItem *item = itemAt(idx);
    if(item->childCount()){
        return false;
    }
    int nodeType = item->data(Type).toInt();
    QSqlQuery removeQuery(mDb);
    if(nodeType == GenreNode){
        removeQuery.prepare("DELETE FROM genres WHERE igenres_id = :id");
    }else if(nodeType == ActorNode){
        removeQuery.prepare("DELETE FROM actors WHERE iactors_id = :id");
    }else if(nodeType == SeriesNode){
        removeQuery.prepare("DELETE FROM series WHERE iseries_id = :id");
    }else{
        return false;
    }
    QVariant id = item->data(GenericId);
    removeQuery.bindValue(":id", id);
    if(removeQuery.exec()){
        if(nodeType == GenreNode || nodeType == ActorNode){
            removeRows(idx.row(), 1, idx.parent());
            return true;
        }else if(nodeType == SeriesNode){
            emit needRefresh();
            return true;
        }
    }else{
        emitDatabaseError(removeQuery.lastError());
    }
    return false;
}

QStringList ArchiveModel::indexToPath(const QModelIndex &idx) const {
    QStringList retval;
    SmTreeItem *item = itemAt(idx);
    while (item) {
        retval << item->data(Name).toString();
        item = item->parent();
    }
    std::reverse(retval.begin(), retval.end());
    return retval;
}

QModelIndexList ArchiveModel::pathToIndex(const QStringList &path) const {
    QModelIndexList retval;
    QModelIndex parentIdx = QModelIndex();
    for(int i = 0; i < path.count(); ++i){
        QString curItem = path.at(i);
        QModelIndex found = find(curItem, Name, parentIdx);
        if(found.isValid()){
            retval << found;
            parentIdx = found;
        }
    }
    return retval;
}

void ArchiveModel::setOrder(int order) {
    mOrder = order;
    SmTreeItem *rootItem = new SmTreeItem(NumFields);
    mCollector->populate(mOrder, rootItem);
    if(!mCollector->isRunning()){
        mCollector->start();
    }
}

void ArchiveModel::setOrder(const QString &order){
    int orderNum = mAvailableOrders.value(order);
    setOrder(orderNum);
}

void ArchiveModel::refresh(){
    setOrder(mOrder);
}

void ArchiveModel::collectorFinished(){
    SmTreeItem *item = mCollector->rootItem();
    setRoot(item);
}

bool ArchiveModel::checkParents(const SmTreeItem *item, const QRegExp &regex, int column) const {
    while(item != root()){
        QString value = item->data(column).toString();
        if(value.contains(regex)){
            return true;
        }
        item = item->parent();
    }
    return false;
}

void ArchiveModel::emitDatabaseError(const QSqlError &e){
    QString databaseText = e.databaseText().isEmpty() ? tr("(none)") : e.databaseText();
    QString driverText = e.driverText().isEmpty() ? tr("(none)") : e.driverText();
    QString errormsg = QString(tr("<b>Database error:</b><br/><ul><li>driverText(): %1</li><li>databaseText(): %2</li></ul>")).arg(driverText).arg(databaseText);
    emit databaseError(errormsg);
}

ArchiveCollector::ArchiveCollector(int numFields, QObject *parent) : QThread(parent), mNumFields(numFields) {
    mDb = QSqlDatabase::cloneDatabase(QSqlDatabase::database("treedb"), "archivedb");
    mDb.open();
}

void ArchiveCollector::populate(int order, SmTreeItem *rootItem){
    mRootItem = rootItem;
    mSortOrder = order;
}

void ArchiveCollector::run(){
    switch (mSortOrder){
        case ArchiveModel::SeriesName:
            populateBySeriesName();
            break;
        case ArchiveModel::Genre:
            populateByGenre();
            break;
        case ArchiveModel::Actor:
            populateByActor();
            break;
        default:
            return;
    }
}

void ArchiveCollector::populateBySeriesName() {
    fetchSeries(QVariant(), mRootItem);
    for(int i = 0; i < mRootItem->childCount(); ++i){
        QString msg = QString("Processing %1").arg(mRootItem->child(i)->data(ArchiveModel::Name).toString());
        emit message(msg);
        fetchParts(QVariant(), mRootItem->child(i));
    }
}

void ArchiveCollector::populateByGenre(){
    QSqlQuery genreIdQuery = QSqlQuery("SELECT igenres_id, tgenrename FROM genres ORDER BY tgenrename", mDb);
    while(genreIdQuery.next()){
        QList<QVariant> genreIdData;
        genreIdData << genreIdQuery.value(1) << genreIdQuery.value(0) << QVariant() << QVariant() << ArchiveModel::GenreNode << false << QVariant() << QVariant();
        SmTreeItem *genreIdItem = new SmTreeItem(genreIdData, mRootItem);
        mRootItem->appendChild(genreIdItem);
    }
    fetchChildren(mRootItem);
}

void ArchiveCollector::populateByActor(){
    QSqlQuery actorIdQuery = QSqlQuery("SELECT iactors_id, tactorname FROM actors ORDER BY tactorname", mDb);
    while(actorIdQuery.next()){
        QList<QVariant> actorIdData;
        actorIdData << actorIdQuery.value(1) << actorIdQuery.value(0) << QVariant() << QVariant() << ArchiveModel::ActorNode << false << QVariant() << QVariant();
        SmTreeItem *actorIdItem = new SmTreeItem(actorIdData, mRootItem);
        mRootItem->appendChild(actorIdItem);
    }
    fetchChildren(mRootItem);
}

void ArchiveCollector::fetchChildren(SmTreeItem *parent){
    for(int i = 0; i < parent->childCount(); ++i){
        QString msg = QString("Processing %1").arg(parent->child(i)->data(ArchiveModel::Name).toString());
        emit message(msg);
        fetchSeries(parent->child(i)->data(ArchiveModel::GenericId), parent->child(i));
        for(int j = 0; j < parent->child(i)->childCount(); ++j){
            SmTreeItem *seriesItem = parent->child(i)->child(j);
            fetchParts(parent->child(i)->data(ArchiveModel::GenericId), seriesItem);
        }
    }
}

void ArchiveCollector::fetchSeries(const QVariant &id, SmTreeItem *parent){
    QSqlQuery seriesIdQuery(mDb);
    switch (mSortOrder) {
        case ArchiveModel::SeriesName:
            seriesIdQuery.prepare("SELECT iseries_id, tseries_name FROM series ORDER BY tseries_name");
            break;
        case ArchiveModel::Genre:
            seriesIdQuery.prepare("SELECT distinct(series.iseries_id), tseries_name FROM series, seriesparts, seriesparts_genremap WHERE seriesparts_genremap.igenres_id = :genreid AND seriesparts_genremap.iseriesparts_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id ORDER BY tseries_name");
            seriesIdQuery.bindValue(":genreid", id);
            break;
        case ArchiveModel::Actor:
            seriesIdQuery.prepare("SELECT distinct(series.iseries_id), tseries_name FROM series, seriesparts, seriesparts_actormap WHERE seriesparts_actormap.iactors_id = :actorid AND seriesparts_actormap.iseriesparts_id = seriesparts.iseriesparts_id AND seriesparts.iseries_id = series.iseries_id ORDER BY tseries_name");
            seriesIdQuery.bindValue(":actorid", id);
            break;
        default:
            qFatal("ArchiveTreeModel::fetchSeries: invalid order!");
            return;
    }
    if(!seriesIdQuery.exec()){
        qWarning("ArchiveTreeModel::fetchSeries: failed to exectue query!");
        return;
    }
    while(seriesIdQuery.next()){
        QList<QVariant> seriesData;
        seriesData << seriesIdQuery.value(1) << seriesIdQuery.value(0) << QVariant() << QVariant() << ArchiveModel::SeriesNode << false << QVariant() << QVariant();
        SmTreeItem *seriesItem = new SmTreeItem(seriesData, parent);
        parent->appendChild(seriesItem);
    }
    parent->setData(ArchiveModel::Count, parent->childCount());
}


void ArchiveCollector::fetchParts(const QVariant &id, SmTreeItem *parent){
    QSqlQuery partsQuery(mDb);
    if(mSortOrder == ArchiveModel::SeriesName){
        partsQuery.prepare("SELECT iseriesparts_id, iseriespart, bfavorite, tsubtitle FROM seriesparts WHERE iseries_id = :id ORDER BY iseriespart");
        partsQuery.bindValue(":id", parent->data(ArchiveModel::GenericId));
    }else if(mSortOrder == ArchiveModel::Genre){
        partsQuery.prepare("SELECT seriesparts.iseriesparts_id, iseriespart, bfavorite, tsubtitle FROM seriesparts, seriesparts_genremap WHERE iseries_id = :id AND seriesparts.iseriesparts_id = seriesparts_genremap.iseriesparts_id AND seriesparts_genremap.igenres_id = :genreid ORDER BY iseriespart");
        partsQuery.bindValue(":id", parent->data(ArchiveModel::GenericId));
        partsQuery.bindValue(":genreid", id);
    }else if(mSortOrder == ArchiveModel::Actor){
        partsQuery.prepare("SELECT seriesparts.iseriesparts_id, iseriespart, bfavorite, tsubtitle FROM seriesparts, seriesparts_actormap WHERE iseries_id = :id AND seriesparts.iseriesparts_id = seriesparts_actormap.iseriesparts_id AND seriesparts_actormap.iactors_id = :actorid ORDER BY iseriespart");
        partsQuery.bindValue(":id", parent->data(ArchiveModel::GenericId));
        partsQuery.bindValue(":actorid", id);
    }
    partsQuery.exec();
    while(partsQuery.next()){
        QList<QVariant> partData;
        partData << parent->data(ArchiveModel::Name) << parent->data(ArchiveModel::GenericId) << partsQuery.value(0) << partsQuery.value(1) << ArchiveModel::SeriesPartNode << partsQuery.value(2) << partsQuery.value(3) << QVariant();
        SmTreeItem *partItem = new SmTreeItem(partData, parent);
        parent->appendChild(partItem);
    }
    parent->setData(ArchiveModel::Count, parent->childCount());
}