/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:   Videosortfilterproxymodel implementation

*

*/

// INCLUDE FILES

#include <qstringlist.h>

#include <qset.h>

#include <qtimer.h>

#include <qdatetime.h>

#include <vcxmyvideosdefs.h>

#include "videothumbnaildata.h"

#include "videocollectioncommon.h"

#include "videosortfilterproxymodel.h"

#include "videolistdatamodel.h"

#include "videocollectionclient.h"

#include "videocollectionwrapper.h"

#include "videocollectiontrace.h"

const TMPXItemId INVALID_ID = TMPXItemId::InvalidId();

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::VideoSortFilterProxyModel

// -----------------------------------------------------------------------------

//

VideoSortFilterProxyModel::VideoSortFilterProxyModel(VideoCollectionCommon::TModelType type, QObject *parent) :

QSortFilterProxyModel(parent),

mModel(0),

mCollectionClient(0),

mType(type),

mLevel(VideoCollectionCommon::ELevelInvalid),

mGenericFilterId(TMPXItemId::InvalidId()),

mGenericFilterValue(false),

mIdleSortTimer(0),

mWantedSortRole(VideoCollectionCommon::KeyDateTime),

mWantedSortOrder(Qt::AscendingOrder)

{

	FUNC_LOG_ADDR(this);

	INFO_2("VideoSortFilterProxyModel::VideoSortFilterProxyModel() [0x%x]: type: %d", this, type);

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::~VideoSortFilterProxyModel

// -----------------------------------------------------------------------------

//

VideoSortFilterProxyModel::~VideoSortFilterProxyModel()

{

	FUNC_LOG_ADDR(this);

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::initialize

// -----------------------------------------------------------------------------

//

int VideoSortFilterProxyModel::initialize(VideoListDataModel *sourceModel)

{

	FUNC_LOG_ADDR(this);

    if(!sourceModel)

    {

        return -1;

    }

    if(!mModel) 

    {

        mModel = sourceModel;

        if(!connectSignals()) 

        {

            ERROR_1(-1, "VideoSortFilterProxyModel::initialize() [0x%x] failed to connect signals.", this);

            disconnectSignals();

            mModel = 0;

            return -1;

        }

        mCollectionClient = mModel->getCollectionClient();

        setSourceModel(sourceModel); 

    }           

    return 0;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::connectSignals

// -----------------------------------------------------------------------------

//

bool VideoSortFilterProxyModel::connectSignals()

{

	FUNC_LOG_ADDR(this);

    if(!connect(mModel, SIGNAL(modelChanged()),

                    this, SLOT(invalidate()))) 

    {

        return false;

    }

    if(mType == VideoCollectionCommon::EModelTypeCollectionContent)

    {

        if(!connect(mModel, SIGNAL(albumChanged()),

                    this, SLOT(albumChangedSlot()))) 

        {

            return false;

        }

    }

    return true;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::disconnectSignals

// -----------------------------------------------------------------------------

//

void VideoSortFilterProxyModel::disconnectSignals()

{

	FUNC_LOG_ADDR(this);

    disconnect(mModel, SIGNAL(modelChanged()), this, SLOT(invalidate()));

    if(mType == VideoCollectionCommon::EModelTypeCollectionContent)

    {

        disconnect(mModel, SIGNAL(albumChanged()), this, SLOT(albumChangedSlot()));

    }

    if(mType == VideoCollectionCommon::EModelTypeCollections)

    {

        disconnect(mModel, SIGNAL(itemModified(const TMPXItemId &)), 

                   this, SLOT(itemModifiedSlot(const TMPXItemId &)));

    }

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::open

// -----------------------------------------------------------------------------

//

int VideoSortFilterProxyModel::open(VideoCollectionCommon::TCollectionLevels level)

{

	FUNC_LOG_ADDR(this);

	INFO_2("VideoSortFilterProxyModel::open() [0x%x] level: %d", this, level);

    if(!mCollectionClient)

    {

        return -1;

    }

    if(mLevel != level) 

    {

       INFO_1("VideoSortFilterProxyModel::open() [0x%x] opening different level, invalidating.", this);

       mLevel = level;

       invalidateFilter();

       // sorting call required here to setup correct sort order in cases where source model allready 

       // contains items but proxy is not yet updated. (invalidate -call does not work since it updates proxy and

       // calls sort in different order for us to use)

       sort(0, mWantedSortOrder);

    }

    // need to call open every time to make sure all items are 

    // inserted to UI ( recent open might have been cancelled)

    return mCollectionClient->startOpenCollection(level);

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::doSorting

// -----------------------------------------------------------------------------

//

void VideoSortFilterProxyModel::doSorting(int sortingRole, Qt::SortOrder order, 

        bool async)

{

	FUNC_LOG_ADDR(this);

	INFO_3("VideoSortFilterProxyModel::doSorting() [0x%x] sortingRole: %d, order: %d", this, sortingRole, order);

    if(sortingRole != VideoCollectionCommon::KeyTitle &&

       sortingRole != VideoCollectionCommon::KeySizeValue &&

       sortingRole != VideoCollectionCommon::KeyDateTime &&

       sortingRole != VideoCollectionCommon::KeyNumberOfItems)

    {

        // default sorting order is by date for other models but collections.

        if(mType != VideoCollectionCommon::EModelTypeCollections)

        {   

            mWantedSortRole = VideoCollectionCommon::KeyDateTime;

        }

        else

        {

            mWantedSortRole = VideoCollectionCommon::KeyTitle;

        }

    }

    else

    {

        mWantedSortRole = sortingRole;

    }

    mWantedSortOrder = order;

    if(async)

    {

        if(mIdleSortTimer)

        {

            if(mIdleSortTimer->isActive())

            {

                mIdleSortTimer->stop();

            }

        }

        else

        {

            mIdleSortTimer = new QTimer(this);

            connect(mIdleSortTimer, SIGNAL(timeout()), this, SLOT(processSorting()));

        }

        mIdleSortTimer->start(0);

    }

    else

    {

        processSorting();

    }

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::getSorting

// -----------------------------------------------------------------------------

//

void VideoSortFilterProxyModel::getSorting(int &sortingRole, Qt::SortOrder &order)

{

	FUNC_LOG_ADDR(this);

	sortingRole = mWantedSortRole;

	order       = mWantedSortOrder;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::deleteItems

// -----------------------------------------------------------------------------

//

int VideoSortFilterProxyModel::deleteItems(const QModelIndexList &indexList)

{

	FUNC_LOG_ADDR(this);

	// Disable thumbnail fetching while items are removed from the model. 

	VideoThumbnailData::instance().enableBackgroundFetching(false);

    if(mModel)

    {

        QModelIndexList mappedList;

        for(int i = 0; i < indexList.count(); ++i)

        {

            mappedList.append(mapToSource(indexList.at(i)));

        }

        if(mModel->removeRows(mappedList))

        {

            // Start fetching thumbnails at start of the model.

            VideoThumbnailData::instance().enableBackgroundFetching(true);

            VideoThumbnailData::instance().startBackgroundFetching(0, 0);

            return 0;

        }

    }

    VideoThumbnailData::instance().enableBackgroundFetching(true);

    return -1;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::openItem

// -----------------------------------------------------------------------------

//

int VideoSortFilterProxyModel::openItem(TMPXItemId mediaId)

{

	FUNC_LOG_ADDR(this);

    if(mediaId != TMPXItemId::InvalidId() && mCollectionClient)

    {

        if(mCollectionClient->openItem(mediaId) == 0)

        {

            if(mediaId.iId2 != KVcxMvcMediaTypeVideo)

            { 

                mLevel = VideoCollectionCommon::ELevelAlbum;

                mModel->setAlbumInUse(mediaId);

                INFO_1("VideoSortFilterProxyModel::open() [0x%x] opening album or category, invalidating.", this);

                invalidateFilter();

                // sorting call required here to setup correct sort order in cases where source model allready 

                // contains items but proxy is not yet updated. (invalidate -call does not work since it updates proxy and

                // calls sort in different order for us to use)

                sort(0, mWantedSortOrder);

            } 

            return 0;

        }

    }

    return -1;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::back

// -----------------------------------------------------------------------------

//

int VideoSortFilterProxyModel::back()

{

	FUNC_LOG_ADDR(this);

    if(mCollectionClient && mCollectionClient->back() == 0)

    {

        if(mLevel == VideoCollectionCommon::ELevelAlbum)

        {

            mLevel = VideoCollectionCommon::ELevelCategory;

        }

        else

        {

            mLevel = VideoCollectionCommon::ELevelVideos;

        }

        return 0;

    }

    return -1;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::fetchItemDetails

// -----------------------------------------------------------------------------

//

int VideoSortFilterProxyModel::fetchItemDetails(const QModelIndex &index)

{

	FUNC_LOG_ADDR(this);

    // no need to map index beforehand, because 

	// getMediaIdAtIndex maps it

    TMPXItemId mpxId1 = getMediaIdAtIndex(index);

    if(mpxId1 != TMPXItemId::InvalidId() && mCollectionClient)

    {

        if(mCollectionClient->getVideoDetails(mpxId1) == 0)

        {

            emit shortDetailsReady(mpxId1);

            return 0;

        }

    }

    return -1;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::processSorting

// -----------------------------------------------------------------------------

//

void VideoSortFilterProxyModel::processSorting()

{

	FUNC_LOG_ADDR(this);

    if(mIdleSortTimer)

    {

        mIdleSortTimer->stop();

    }

    if(sortRole() != mWantedSortRole)

    {

        setSortRole(mWantedSortRole);

    }

    if(sortColumn() == -1 || sortOrder() != mWantedSortOrder)

    {

        // if sorting column is not yet setted, it indicates

        // that we've setted the sorting order for the first time

        // and sorting has not yet been done. After we have called sort once,

        // the sort columnt gets updated and following sorts gets executed

        // by setSortRole -call as long as role changes.

        // Another case is when we need to change the sort order, as there is

        // no other way of setting the sort order than calling sort().

        sort(0, mWantedSortOrder);

    }

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::lessThan

// -----------------------------------------------------------------------------

//

bool VideoSortFilterProxyModel::lessThan(const QModelIndex &left,

    const QModelIndex &right) const

{

    if (!mModel)

    {

        return false;

    }

    int index = left.row();

    TMPXItemId leftId = mModel->mediaIdAtIndex(index);

    index = right.row();

    TMPXItemId rightId = mModel->mediaIdAtIndex(index);

    // Default categories are always first in the following order:

    // Recently played (missing currently)

    // Captured

    // Downloaded

    // Podcasts (missing currently)

    bool lessThan(false);

    bool proceedDataSorting(false);

    if(leftId.iId2  == KVcxMvcMediaTypeCategory &&

       rightId.iId2 == KVcxMvcMediaTypeCategory)

    {

        if(leftId.iId1 == KVcxMvcCategoryIdCaptured)

        {

            lessThan = true;

        }

        else if(leftId.iId1 == KVcxMvcCategoryIdDownloads)

        {

            if(rightId.iId1 != KVcxMvcCategoryIdCaptured)

            {

                lessThan = true;

            }

        }

    }

    else if(leftId.iId2 == KVcxMvcMediaTypeCategory ||

            rightId.iId2 == KVcxMvcMediaTypeCategory)

    {

        lessThan = (leftId.iId2 == KVcxMvcMediaTypeCategory);

    }

    else

    {

        proceedDataSorting = true;

    }

    if(!proceedDataSorting)

    {

        return mWantedSortOrder == Qt::AscendingOrder ? lessThan : !lessThan;

    }

    // Do comparisation based on the role:

    //  VideoCollectionCommon::KeyTitle,

    //  VideoCollectionCommon::KeySizeValue,

    //  VideoCollectionCommon::KeyNumberOfItems,

    //  VideoCollectionCommon::KeyDateValue

    // 

    // If role does not match, do not sort

    int sRole = sortRole();

    QVariant leftData = sourceModel()->data(left, sRole);

    QVariant rightData = sourceModel()->data(right, sRole);

    if(!leftData.isValid() || !rightData.isValid())

    {

        return false;

    }

    if(sRole == VideoCollectionCommon::KeyTitle)

    {

        QString leftString = leftData.toString().toUpper();

        QString rightString = rightData.toString().toUpper();

        return QString::localeAwareCompare(leftString, rightString) < 0;

    }

    else if(sRole == VideoCollectionCommon::KeySizeValue ||

            sRole == VideoCollectionCommon::KeyNumberOfItems)

    {

        quint32 leftSize = leftData.toUInt();

        quint32 rightSize = rightData.toUInt();

        return leftSize < rightSize;

    }

    else if(sRole == VideoCollectionCommon::KeyDateTime)

    {

        QDateTime leftDateTime = leftData.toDateTime();

        QDateTime rightDateTime = rightData.toDateTime();

        // datetime sorting role has inverted sorting order compared to other roles 

        return rightDateTime < leftDateTime;

    }

    return false;

}

// -----------------------------------------------------------------------------

// VideoSortFilterProxyModel::filterAcceptsRow

// -----------------------------------------------------------------------------

//

bool VideoSortFilterProxyModel::filterAcceptsRow(int source_row, const QModelIndex &source_parent) const

{

    Q_UNUSED(source_parent);

    if(!sourceModel())

    {

        return false;

    }

    if(source_row < 0 || source_row >= sourceModel()->rowCount())

    {

        return false;

    }

    TMPXItemId id = mModel->mediaIdAtIndex(source_row);

    if(id == TMPXItemId::InvalidId())

    {

        return false;

    }

    if (mType == VideoCollectionCommon::EModelTypeAllVideos)

    {

        if(id.iId2 == KVcxMvcMediaTypeVideo)

        {

            return true;

        }

    }

    else if(mType == VideoCollectionCommon::EModelTypeCollections)

    {

        if(mLevel == VideoCollectionCommon::ELevelCategory && id.iId2 != KVcxMvcMediaTypeVideo)

        {

            return true;

        }       

    }

    else if (mType == VideoCollectionCommon::EModelTypeCollectionContent)

    {

        // if item belongs to the open album, accept it

        if (mModel->belongsToAlbum(id))

        {

            return true;