/*
  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 "smtreeitem.h"
#include "archivemodel.h"

ArchiveModel::ArchiveModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent), mOrder(SeriesName){
    mDb = QSqlDatabase::database("treedb");
    mAvailableOrders.insert("Series Name", SeriesName);
    mAvailableOrders.insert("Actor", Actor);
    mAvailableOrders.insert("Genre", Genre);
    setOrder(mOrder);
}

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);
        }
    }
    return SmTreeModel::data(index, role);
}

void ArchiveModel::setOrder(int order) {
    mOrder = order;
    switch (order) {
        case SeriesName:
            populateBySeriesName();
            break;
        case Actor:
            populateByActor();
            break;
        case Genre:
            populateByGenre();
            break;
        default:
            return;
    }
}

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

void ArchiveModel::populateBySeriesName() {
    SmTreeItem *rootItem = new SmTreeItem(NumFields);
    fetchChildren(rootItem);
    fetchSeries(QVariant(), rootItem);
    for(int i = 0; i < rootItem->childCount(); ++i){
        fetchParts(QVariant(), rootItem->child(i));
    }
    setRoot(rootItem);
}

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

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

void ArchiveModel::fetchChildren(SmTreeItem *parent){
    for(int i = 0; i < parent->childCount(); ++i){
        fetchSeries(parent->child(i)->data(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(GenericId), seriesItem);
        }
    }
}

void ArchiveModel::fetchSeries(const QVariant &id, SmTreeItem *parent){
    QSqlQuery seriesIdQuery(mDb);
    switch (mOrder) {
        case SeriesName:
            seriesIdQuery.prepare("SELECT iseries_id, tseries_name FROM series ORDER BY tseries_name");
            break;
        case 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 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() << SeriesNode << false << QVariant() << QVariant() << QVariant();
        SmTreeItem *seriesItem = new SmTreeItem(seriesData, parent);
        parent->appendChild(seriesItem);
    }
    parent->setData(Count, parent->childCount());
}


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