#include "FileModel.h"
#include "FileItem.h"
#include "FileItemAction.h"

#include "IO/DICOM/ExtendMedicalImageProperties.h"
#include "DICOMPropertiesStore.h"

FileModel::FileModel(PropertyTableModel* aTableModel, QObject *parent)
    : QAbstractItemModel(parent)
    , mRootItem(new FileItem(FileItemDataPointer(new QVariant("root"))))
    , mPatientList(nullptr)
    , mTableModel(aTableModel)
{
    setModelData();
}

FileModel::~FileModel()
{
    delete mRootItem;
}

QVariant FileModel::data(const QModelIndex &aIndex, int aRole) const
{
    if (aRole != Qt::DisplayRole)
    {
        return QVariant();
    }

    if (!aIndex.isValid())
    {
        return *mRootItem->getData();
    }

    FileItem* item = static_cast<FileItem*>(aIndex.internalPointer());
    if (item == nullptr)
    {
        return QVariant();
    }

    return *item->getData();
}

QModelIndex FileModel::index(int aRow, int aColumn, const QModelIndex &aParent) const
{
    if (!hasIndex(aRow, aColumn, aParent))
    {
        return QModelIndex();
    }

    FileItem* parentItem;

    if (!aParent.isValid())
    {
        parentItem = mRootItem;
    }
    else
    {
        parentItem = static_cast<FileItem*>(aParent.internalPointer());
    }

    FileItem* childItem = parentItem->getChild(aRow);
    if (childItem)
    {
        return createIndex(aRow, aColumn, childItem);
    }
    else
    {
        return QModelIndex();
    }
}

QModelIndex FileModel::parent(const QModelIndex &aIndex) const
{
    if (!aIndex.isValid())
    {
        return QModelIndex();
    }

    FileItem *childItem = static_cast<FileItem*>(aIndex.internalPointer());
    FileItem *parentItem = childItem->getParent();

    if (parentItem == nullptr  || parentItem == mRootItem)
    {
        return QModelIndex();
    }

    return createIndex(parentItem->getIndexRow(), 0, parentItem);
}

int FileModel::rowCount(const QModelIndex& aParent) const
{
    if (aParent.column() > 0)
    {
        return 0;
    }

    if (!aParent.isValid())
    {
        return mRootItem->childCount();
    }

    FileItem* item = static_cast<FileItem*>(aParent.internalPointer());
    if(item == nullptr)
    {
        return 0;
    }
    return item->childCount();
}

int FileModel::columnCount(const QModelIndex &aParent) const
{
    return 1;
}

void FileModel::setModelData()
{
    clearModelData();
    mPatientList = DICOMPropertiesStore::GetInstance()->getPatientsList();
    beginResetModel();
    //Patient Node
    std::map<std::string,PatientInfo*>::iterator patientIter;
    for(patientIter = mPatientList->begin();patientIter != mPatientList->end(); ++patientIter)
    {
        FileItem* patient = new FileItem(FileItemDataPointer(
                new QVariant(
                        QString("Patient: %1, Name: %2, Birth Date: %3")
                                .arg(patientIter->first.c_str(),
                                        patientIter->second->patient_name.c_str(),
                                        patientIter->second->birth_date.c_str())))
                        ,mRootItem);
        //Study Node
        std::map<std::string,StudyInfo*>::iterator studyIter;
        StudiesMapType* studyMap = patientIter->second->studies;
        for(studyIter = studyMap->begin();studyIter != studyMap->end(); ++studyIter)
        {
            FileItem* study = new FileItem(FileItemDataPointer(
                    new QVariant(QString("Study: %1, Date: %2")
                    .arg(studyIter->first.c_str(),
                            studyIter->second->study_date.c_str()))),patient);
            //Series Node
            std::map<std::string,ImageSetMapType*>::iterator seriesIter;
            SeriesMapType* seriesMap = studyIter->second->series;
            for(seriesIter = seriesMap->begin();seriesIter != seriesMap->end(); ++seriesIter)
            {
                FileItem* series = new FileItem(FileItemDataPointer(
                        new QVariant(QString("Series: ")+seriesIter->first.c_str())),study);
                //Image Set Node
                std::map<std::string,ExtendMedicalImageProperties*>::iterator imageSetIter;
                ImageSetMapType* imageSetMap = seriesIter->second;
                for(imageSetIter = imageSetMap->begin();
                    imageSetIter != imageSetMap->end();
                    ++imageSetIter)
                {
                    ExtendMedicalImageProperties* property = imageSetIter->second;
                    FileItem* imageSet =
                            new FileItem(FileItemDataPointer(
                                    new QVariant(QString("ImageSet: ")
                                    + imageSetIter->first.c_str() + QString(" ")
                                    + QString::number(property->GetFileNames().size())))
                            , series
                            , FileItemActionPointer(new FileItemAction(mTableModel,property)));

                }
            }
        }
    }
    endResetModel();
}

void FileModel::clearModelData()
{
    if (rowCount() == 0)
    {
        return;
    }
    beginResetModel();
    mRootItem->clearChilds();
    endResetModel();
}

void FileModel::executeItemAction(const QModelIndex& aIndex)
{
    if(aIndex.isValid())
    {
        FileItem* item = static_cast<FileItem*>(aIndex.internalPointer());
        if (item != nullptr)
        {
            item->executeAction();
        }
    }
}