/*

* 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: VideoListDataModelPrivate class implementation

* 

*/

// Version : %version: 38.1.6 %

// INCLUDE FILES

#include <hbglobal.h>

#include <mpxmediageneraldefs.h>

#include <mpxmediavideodefs.h>

#include <thumbnailmanager_qt.h>

#include <mpxmediaarray.h>

#include <mpxmedia.h>

#include <qvariant.h>

#include <hbextendedlocale.h>

#include <qfileinfo.h>

#include "videolistdatamodel.h"

#include "videocollectionclient.h"

#include "videodeleteworker.h"

#include "videolistdatamodel_p.h"

#include "videothumbnaildata.h"

#include "vcxmyvideosdefs.h"

#include "videocollectionutils.h"

#include "videocollectioncommon.h"

#include "videocollectiontrace.h"

/**

 * global qHash function required fo creating hash values for TMPXItemId -keys

 */

inline uint qHash(TMPXItemId key) 

{ 

    QPair<uint, uint> keyPair(key.iId1, key.iId2); 

    return qHash(keyPair);

}

// ================= MEMBER FUNCTIONS =======================

//

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

// VideoListDataModelPrivate

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

//

VideoListDataModelPrivate::VideoListDataModelPrivate(VideoListDataModel *model) :

q_ptr(model),

mVideoThumbnailData(0),

mInitialized(false),

mCurrentAlbum(TMPXItemId::InvalidId())

{

	FUNC_LOG;

}

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

// ~VideoListDataModelPrivate

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

//

VideoListDataModelPrivate::~VideoListDataModelPrivate()

{

	FUNC_LOG;

    QHash<TMPXItemId, QSet<TMPXItemId> >::iterator iter = mAlbumData.begin();

    while(iter != mAlbumData.end())

    {

        iter->clear();

        ++iter;

    }

    mAlbumData.clear();

    mMediaData.clear();

}

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

// initialize

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

//

int VideoListDataModelPrivate::initialize()

{

	FUNC_LOG;

    if(mInitialized)

    {

        return 0;

    }

    mVideoThumbnailData = &(VideoThumbnailData::instance());

    if(!connect( mVideoThumbnailData, SIGNAL(thumbnailsFetched( QList<TMPXItemId>& )), 

                  this, SLOT(thumbnailsFetchedSlot( QList<TMPXItemId>& ))))

    {

        return -1;

    }

    mInitialized = true;

    return 0;

}

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

// getVideoCount

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

//

int VideoListDataModelPrivate::getVideoCount()

{

    return mMediaData.count();

}

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

// getMediaIdFromIndex

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

//

const TMPXItemId& VideoListDataModelPrivate::getMediaIdFromIndex(const int &index ) const

{

    return mMediaData.idFromIndex(index);

}

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

// getVideoNameFromIndex

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

//

const QString VideoListDataModelPrivate::getVideoNameFromIndex(const int &index )  const

{

    QString txt;

    CMPXMedia* media = mMediaData.fromIndex(index);

    VideoCollectionUtils::instance().mediaValue<QString>(media, KMPXMediaGeneralTitle, txt );

    return txt;

}

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

// getVideoThumbnailFromIndex

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

//

const QIcon* VideoListDataModelPrivate::getVideoThumbnailFromIndex(const int &index ) const

{

    if(mVideoThumbnailData)

    {

        return mVideoThumbnailData->getThumbnail( mMediaData.idFromIndex(index) );

    }

    return 0;

}

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

// getCategoryVideoCountFromIndex

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

//

quint32 VideoListDataModelPrivate::getCategoryVideoCountFromIndex(const int &index ) const

{

    quint32 count(0);

    CMPXMedia *media = mMediaData.fromIndex(index);

    VideoCollectionUtils::instance().mediaValue<quint32>(media, KVcxMediaMyVideosCategoryItemCount, count );

    return count;

}

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

// getVideoSizeFromIndex

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

//

quint32 VideoListDataModelPrivate::getVideoSizeFromIndex(const int &index ) const

{

    quint32 size(0);

    CMPXMedia *media = mMediaData.fromIndex(index);

    VideoCollectionUtils::instance().mediaValue<quint32>(media, KMPXMediaGeneralSize, size );    

    return size;

}

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

// getVideoAgeProfileFromIndex

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

//

quint32 VideoListDataModelPrivate::getVideoAgeProfileFromIndex(const int &index ) const

{

    quint32 ageProfile(0);

    CMPXMedia *media = mMediaData.fromIndex(index);

    VideoCollectionUtils::instance().mediaValue<quint32>(media, KVcxMediaMyVideosAgeProfile, ageProfile );    

    return ageProfile; 

}

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

// getVideodurationFromIndex

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

//

quint32 VideoListDataModelPrivate::getVideodurationFromIndex(const int &index ) const

{

    CMPXMedia *media = mMediaData.fromIndex(index);

    return getVideoDuration(media);

}

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

// getVideodurationFromIndex

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

//

quint32 VideoListDataModelPrivate::getVideoDuration(CMPXMedia* media) const

{

    quint32 returnDuration(0);

    float duration(0);

    VideoCollectionUtils::instance().mediaValue<float>(media, KVcxMediaMyVideosDuration, duration );

    returnDuration = static_cast<quint32>(duration);

    return returnDuration;

}

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

// getVideoDateFromIndex

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

//

QDateTime VideoListDataModelPrivate::getVideoDateFromIndex(const int &index ) const

{

    return getVideoDate(mMediaData.fromIndex(index));

}

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

// getVideoDate

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

//

QDateTime VideoListDataModelPrivate::getVideoDate(CMPXMedia* media) const

{

    QDateTime date;

    quint64 dateTimeValue;

    if(!VideoCollectionUtils::instance().mediaValue<quint64>(media, KMPXMediaGeneralDate, dateTimeValue)) 

    {

        return date;

    }

    TDateTime temp = TTime( dateTimeValue ).DateTime();

    date = QDateTime(QDate(temp.Year(), temp.Month()+1, temp.Day()+1), 

                       QTime(temp.Hour(), temp.Minute(), temp.Second(), temp.MicroSecond()));

    return date;

}

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

// markVideosRemoved

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

//

const TMPXItemId VideoListDataModelPrivate::markVideoRemoved(const QModelIndex &itemIndex)

{

    return mMediaData.markItemRemoved(itemIndex.row());

}

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

// restoreRemoved

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

//

void VideoListDataModelPrivate::restoreRemoved(QList<TMPXItemId> *idList)

{

	FUNC_LOG;

    int startIndex = mMediaData.count();

    int restored = mMediaData.restoreRemovedItems(idList);

    if(restored > 0)

    {

        q_ptr->beginInsertRows(QModelIndex(), startIndex, startIndex + (restored - 1));

        q_ptr->endInsertRows();

    }

}

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

// getFilePathFromIndex

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

//

const QString VideoListDataModelPrivate::getFilePathFromIndex(const int &index) const

{

    QString filePath;

    VideoCollectionUtils::instance().mediaValue<QString>(mMediaData.fromIndex(index), 

            KMPXMediaGeneralUri, filePath );

    return filePath;

}

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

// getFilePathForId

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

//

const QString VideoListDataModelPrivate::getFilePathForId(const TMPXItemId &mediaId)

{

    QString filePath;

    int index = mMediaData.indexOfId(mediaId);

    VideoCollectionUtils::instance().mediaValue<QString>(mMediaData.fromIndex(index), 

            KMPXMediaGeneralUri, filePath );

    return filePath;

}

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

// belongsToAlbum

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

//

bool VideoListDataModelPrivate::belongsToAlbum(const TMPXItemId &itemId, TMPXItemId albumId) const

{

    bool contains(false);

    QHash<TMPXItemId, QSet<TMPXItemId> >::const_iterator iter;

    if(albumId == TMPXItemId::InvalidId())

    {    

        // album id not specified, use the current album

        iter = mAlbumData.constFind(mCurrentAlbum);

    }

    else

    {

        iter = mAlbumData.constFind(albumId);

    }     

    if (iter != mAlbumData.constEnd())

    {

        contains = iter->contains(itemId);

    }

    return contains;

}

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

// setAlbumInUse

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

//

void VideoListDataModelPrivate::setAlbumInUse(const TMPXItemId &albumId)

{

	FUNC_LOG;

    mCurrentAlbum = albumId;

}

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

// removeItemsFromAlbum

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

//

int VideoListDataModelPrivate::removeItemsFromAlbum(const TMPXItemId &albumId, 

                                        const QList<TMPXItemId> &items)

{

	FUNC_LOG;

    QHash<TMPXItemId, QSet<TMPXItemId> >::iterator iter = mAlbumData.find(albumId);

    if(iter == mAlbumData.end())

    {

        return 0;

    }

    int removeCount = 0;

    int count = items.count();

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

    {

        if(iter->remove(items.at(i)))

        {

            ++removeCount;

        }

    }   

    return removeCount;

}

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

// getMediaId

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

//

TMPXItemId VideoListDataModelPrivate::getMediaId(const CMPXMedia *media ) const

{

    TMPXItemId mediaId = TMPXItemId::InvalidId();

    VideoCollectionUtils::instance().mediaValue<TMPXItemId>(media, KMPXMediaGeneralId, mediaId );

    return mediaId;

}

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

// appendDataToContainerL

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

//

void VideoListDataModelPrivate::appendDataToContainerL(

    CMPXMediaArray *videoArray,

    unsigned int startIndex)

{

	FUNC_LOG;

    if (!videoArray ||

        startIndex >= videoArray->Count())

    {

        return;

    }

    INFO_2("VideoListDataModelPrivate::appendDataToContainerL() array count: %d, start index: %d", videoArray->Count(), startIndex);

    CMPXMedia *newMedia = 0;

    CMPXMedia *mediaFromArray = 0;

    TMPXItemId itemId = TMPXItemId::InvalidId();

    int count = videoArray->Count();

    for(int i = startIndex; i < count; ++i)

    {

        mediaFromArray = videoArray->AtL(i);

        itemId = getMediaId(mediaFromArray);

        if (isValid(*mediaFromArray, itemId))

        {

            newMedia = CMPXMedia::NewL(*mediaFromArray);

            mMediaData.append(newMedia);

            newMedia = 0;

        }

    }

}

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

// isValid

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

//

bool VideoListDataModelPrivate::isValid(const CMPXMedia &media,

    const TMPXItemId &itemId) const

{

    if(itemId == TMPXItemId::InvalidId())

    {

        return false;

    }    

    // temporary to remove all items with out a title

    QString title;

    VideoCollectionUtils::instance().mediaValue<QString>(&media,

        KMPXMediaGeneralTitle,

        title);

    if (!title.length())

    {

        return false;

    }

    // recently played and podcasts are not yet supported

    if(itemId.iId2 == KVcxMvcMediaTypeCategory && 

        (itemId.iId1 != KVcxMvcCategoryIdDownloads &&

         itemId.iId1 != KVcxMvcCategoryIdCaptured))

    {

        return false;

    }

    return true;

}

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

// albumDataChangedL

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

//

void VideoListDataModelPrivate::albumDataChangedL(TMPXItemId &albumId,

    CMPXMediaArray *videoArray)

{

	FUNC_LOG;

    if (!videoArray || albumId == TMPXItemId::InvalidId())

    {

        return;

    }

    QSet<TMPXItemId> items;

    int oldCount = mAlbumData[albumId].count();

    // remove existing

    mAlbumData.remove(albumId);

    int videoCount = videoArray->Count();

    CMPXMedia *media = 0;

    TMPXItemId id = TMPXItemId::InvalidId();

    for (int i = videoCount - 1; i >= 0; i--)

    {

        media = videoArray->AtL(i);

        id = getMediaId(media);

        if (id != TMPXItemId::InvalidId() && id.iId2 == KVcxMvcMediaTypeVideo)

        {          

            items.insert(id);

        }

    }  

    mAlbumData[albumId] = items;

    if(oldCount != items.count())

    {

        // signal that album has been updated

        emit q_ptr->albumChanged();

        // signal that model has changed.

        emit q_ptr->modelChanged();

    }

}

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

// thumbnailsFetchedSlot

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

//

void VideoListDataModelPrivate::thumbnailsFetchedSlot(QList<TMPXItemId> &mediaIds)

{

    TMPXItemId id;

    QModelIndex rowIndex;

    while(!mediaIds.isEmpty())

    {

        id = mediaIds.takeFirst();

        rowIndex = q_ptr->index(mMediaData.indexOfId(id), 0);

		if(rowIndex.isValid())

		{

	        emit q_ptr->dataChanged( rowIndex, rowIndex);

		}

    }

}

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

// newVideoListSlot

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

//

void VideoListDataModelPrivate::newVideoListSlot( CMPXMediaArray *newVideoList )

{

	FUNC_LOG;

    if( !newVideoList )

    {

        return;

    }

    int startIndex = mMediaData.count();

    TRAP_IGNORE(appendDataToContainerL(newVideoList));

    int endIndex = mMediaData.count() - 1;

    if(startIndex <= endIndex)

    {

        q_ptr->beginInsertRows(QModelIndex(), startIndex, endIndex);

        q_ptr->endInsertRows();

        emit q_ptr->modelChanged();

    }

}

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

// appendVideoListSlot

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

//

void VideoListDataModelPrivate::appendVideoListSlot(CMPXMediaArray* videoList)

{

	FUNC_LOG;

    if(!videoList)

    {

        return;

    }

    if(videoList->Count() == 0 || videoList->Count() <= mMediaData.count())

    {

        // nothing to append or count matches, no changes -> nothing to append

        return;

    }

    // array gotten is in same order as existing data from the start,