/*
  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 <QFont>
#include <QFile>
#include <QLocale>

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

PicFilesModel::PicFilesModel(const QStringList &headers, QObject *parent) : SmTreeModel(headers, parent) {
    //conjure up model
    mMappingTreeModel = static_cast<MappingTreeModel*>(SmGlobals::instance()->model("MappingTree"));

    //setup database
    mDb = QSqlDatabase::database("treedb");
    mPopulateQS = QString("SELECT DISTINCT(pics.ipicsid), pics.tfilename, pics.isize, pics.tformat, pics.dtadded, pics.cmd5sum, pics.cpicsize FROM pics, pics_mappings WHERE pics_mappings.imappings_parents_id IN (%1) AND pics_mappings.ipics_id = pics.ipicsid ORDER BY pics.tfilename");
    mMappingsQS = QString("SELECT DISTINCT(pics_mappings.imappings_parents_id) FROM pics_mappings, pics WHERE pics_mappings.ipics_id IN (%1)");
}

void PicFilesModel::setMapping(int pMapId){
    QList<QVariant> ids = mMappingTreeModel->childList(pMapId, MappingTreeModel::MappingId);
    mMappingIds.clear();
    foreach(QVariant i, ids){
        mMappingIds << i.toInt();
    }
}

QVariant PicFilesModel::data(const QModelIndex &index, int role) const {
    if(role == Qt::FontRole){
        if(index.column() == Md5Sum){
            return QFont("Monospace");
        }
    }
    if(role == Qt::ForegroundRole){
        if(index.column() == Size){
            int fileSize = index.data(SizeRole).toInt();
            if(fileSize > 1024 * 1024 * 1024){
                return QColor(Qt::red);
            }else{
                return QColor(Qt::green);
            }
        }
    }
    SmTreeItem *item = itemAt(index);
    if(role == FileNameRole){
        return item->data(FileName);
    }
    if(role == SizeRole){
        return item->data(Size);
    }
    if(role == MimeTypeRole){
        return item->data(MimeType);
    }
    if(role == FullPathRole){
        return item->data(FullPath);
    }
    if(role == IdRole){
        return item->data(Id);
    }
    if(role == AddedRole){
        return item->data(Added);
    }
    if(role == Md5SumRole){
        return item->data(Md5Sum);
    }
    if(role == PicSizeRole){
        return item->data(PicSize);
    }
    return SmTreeModel::data(index, role);
}

QList<QVariant> PicFilesModel::dataList(const QModelIndex &idx) const{
    QList<QVariant> retval;
    if(!idx.isValid()){
        return retval;
    }
    SmTreeItem *item = itemAt(idx);
    for(int i = 0; i < NumFields; ++i){
        retval << item->data(i);
    }
    QList<MappingData> mapData = mappingDataFromFile(idx.data(PicFilesModel::IdRole).toInt());
    QList<QStringList> mappings;
    foreach(MappingData d, mapData){
        mappings << d.path;
    }

    retval.append(QVariant::fromValue(mappings));
    return retval;
}

QList<QList<QVariant> > PicFilesModel::allFiles() const {
    QList<QList<QVariant> >  retval;
    //assume depth of exactly 1
    SmTreeItem *rootItem = root();
    for(int i = 0; i < rootItem->childCount(); ++i){
        SmTreeItem *cur = rootItem->child(i);
        QList<QVariant> data;
        for(int j = 0; j < cur->columnCount(); ++j){
            data << cur->data(j);
        }
        retval << data;
    }
    return retval;
}

void PicFilesModel::removeFiles(const QList<QPair<int, QString> > &files){
    QSqlQuery deleteFile(mDb);
    deleteFile.prepare("DELETE FROM pics WHERE ipicsid = :id");
    QList<int> success;
    // remove from model
    for(int i = 0; i < files.size(); ++i){
        QPair<int, QString> cur = files.at(i);
        deleteFile.bindValue(":id", cur.first);
        if(deleteFile.exec()){
            success << cur.first;
            QFile::remove(cur.second);
        }
    }
    // remove from view
    foreach(int id, success){
        QModelIndex idx = find(id, Id);
        if(idx.isValid()){
            removeRows(idx.row(), 1, QModelIndex());
        }
    }
}

bool PicFilesModel::changeMappings(const QList<int> &fileIds, const QList<QVariant> &parentIds){
    mDb.transaction();
    QSqlQuery deleteMappingsQ(mDb);
    deleteMappingsQ.prepare("DELETE FROM pics_mappings WHERE ipics_id = :id");
    QSqlQuery addMappingsQ(mDb);
    addMappingsQ.prepare("INSERT INTO pics_mappings(ipics_id, imappings_parents_id) VALUES(:pid, :id)");
    foreach(int fid, fileIds){
        deleteMappingsQ.bindValue(":id", fid);
        if(!deleteMappingsQ.exec()){
            goto error;
        }
        foreach(QVariant pid, parentIds){
            addMappingsQ.bindValue(":pid", fid);
            addMappingsQ.bindValue(":id", pid);
            if(!addMappingsQ.exec()){
                goto error;
            }
        }
    }
    mDb.commit();
    return true;

    error:
    mDb.rollback();
    return false;
}

QList<MappingData> PicFilesModel::mappingDataFromFile(int fileId) const{
    QList<int> d = QList<int>() << fileId;
    return mappingDataFromFiles(d);
}

QList<MappingData> PicFilesModel::mappingDataFromFiles(const QList<int> fileIds) const{
    QList<int> parentIds = mappingPIdsFromFiles(fileIds);
    if(parentIds.isEmpty()){
        return QList<MappingData>();
    }
    QList<MappingData> retval;
    foreach(int pId, parentIds){
        QModelIndex curIdx =  mMappingTreeModel->findRecursive(pId, MappingTreeModel::MappingId, mMappingTreeModel->rootIndex());
        MappingData curData;
        curData.mappingId = curIdx.data(MappingTreeModel::MappingIdRole).toInt();
        curData.parentId = curIdx.data(MappingTreeModel::MappingParentIdRole).toInt();
        curData.name = curIdx.data(MappingTreeModel::NameRole).toString();
        curData.path << mMappingTreeModel->path(curIdx);
        retval << curData;
    }
    return retval;
}

QList<int> PicFilesModel::mappingPIdsFromFiles(QList<int> fileIds) const{
    if(fileIds.isEmpty()){
        return QList<int>();
    }
    QStringList idList;
    foreach(int id, fileIds){
        idList << QString::number(id);
    }
    QString query = mMappingsQS.arg(idList.join(","));
    QSqlQuery q(query, mDb);
    QList<int> retval;
    while(q.next()){
        retval << q.value(0).toInt();
    }
    return retval;
}

void PicFilesModel::populate(){
    SmTreeItem *root = new SmTreeItem(NumFields);
    QStringList idList;
    foreach(int id, mMappingIds){
        idList << QString::number(id);
    }
    QString query = mPopulateQS.arg(idList.join(","));
    QSqlQuery q(query, mDb);
    while(q.next()){
        QList<QVariant> data;
        data << q.value(1) << q.value(2) << q.value(3); // Filename, size and Mime type
        data << Helper::createArchivePath(q.value(1).toString(), q.value(5).toString()); // full path;
        data << q.value(0) << q.value(4) << q.value(5); //Id, added and md5
        data << q.value(6); // picsize
        SmTreeItem *child = new SmTreeItem(data, root);
        root->appendChild(child);
    }
    setRoot(root);
}