/*

* Copyright (c) 2006 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:   

*

*/

#include "glxdatasourcetaskmdeattribute.h"

#include <glxcollectionpluginCamera.hrh>

#include <glxcollectionpluginDownloads.hrh>

#include <glxcollectionpluginMonths.hrh>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectionpluginall.hrh>

#include <glxcollectionplugintags.hrh>

#include <glxerrors.h>

#include <glxfilterfactory.h>

#include <glxgetrequest.h>

#include <glxgetrequest.h>

#include <glxidlistrequest.h>

#include <glxlog.h>

#include <glxmediacollectioninternaldefs.h>

#include <glxmediageneraldefs.h>

#include <glxrequest.h>

#include <glxthumbnailattributeinfo.h>

#include <glxthumbnailrequest.h>

#include <glxtndatabase.h>

#include <glxtnfileinfo.h>

#include <glxtnthumbnailcreator.h>

#include <imageconversion.h>

#include <lbsposition.h>

#include <mdeconstants.h>

#include <mdelogiccondition.h>

#include <mdeobject.h>

#include <mdeobjectdef.h>

#include <mdeobjectquery.h>

#include <mdepropertydef.h>

#include <mderelationdef.h>

#include <mdesession.h>

#include <mdetextproperty.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h> 

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediadrmdefs.h>

#include <mpxmediageneraldefs.h>

#include "glxdatasourcemde.h"

#include "glxdatasourcemde.h"

#include "glxdatasourcemde.hrh"

// CONSTANTS

_LIT(KPropertyDefNameAlbumType, "Type");

_LIT(KPropertyDefNameComment, "Comment");

_LIT(KPropertyDefNameCreationDate, "CreationDate");

_LIT(KPropertyDefNameDRM, "DRM");

_LIT(KPropertyDefNameDuration, "Duration");

_LIT(KPropertyDefNameFrameCount, "FrameCount");

_LIT(KPropertyDefNameHeight, "Height");

_LIT(KPropertyDefNameItemType, "ItemType");

_LIT(KPropertyDefNameLastModifiedDate, "LastModifiedDate");

_LIT(KPropertyDefNameLatitude, "Latitude");

_LIT(KPropertyDefNameLongitude, "Longitude");

_LIT(KPropertyDefNameSize, "Size");

_LIT(KPropertyDefNameTitle, "Title");

_LIT(KPropertyDefNameUsageCount, "UsageCount");

_LIT(KPropertyDefNameWidth, "Width");

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

//  Constructor

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

//  

CGlxDataSourceTaskMdeAttribute::CGlxDataSourceTaskMdeAttribute(CGlxGetRequest* aRequest, MGlxDataSourceRequestObserver& aObserver, CGlxDataSource* aDataSource)

    : CGlxDataSourceTaskMde(aRequest, aObserver, aDataSource)

    {

    GLX_LOG_ENTRY_EXIT("CGlxDataSourceTaskMdeAttribute::CGlxDataSourceTaskMdeAttribute()");

    iFilterProperties = TGlxFilterFactory::ExtractAttributes(iRequest->Filter());

    }

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

//  Destructor

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

//  

CGlxDataSourceTaskMdeAttribute::~CGlxDataSourceTaskMdeAttribute()

	{

    GLX_LOG_ENTRY_EXIT("CGlxDataSourceTaskMdeAttribute::~CGlxDataSourceTaskMdeAttribute()");

    delete iMediaArray;

    iQueryAttributes.Close();

	}

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

//  CGlxDataSourceTaskMdeAttribute::ExecuteRequestL

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

//      

void CGlxDataSourceTaskMdeAttribute::ExecuteRequestL()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::ExecuteRequestL()");

    CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);

    __ASSERT_DEBUG(request->MediaIds().Count() > 0, User::Invariant());

    if (request->MediaIds().Count() > 1)

        {

        iMediaArray = CMPXMediaArray::NewL();

        }

    if (request->MediaIds()[0] == KGlxCollectionRootId)

    	{

        __ASSERT_DEBUG(request->MediaIds().Count() == 1, User::Invariant());

        AddCollectionAttributesL(iResponse);

    	}

    else

    	{

        __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));

        CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);   

        const RArray<TItemId>& mediaIds = reinterpret_cast<const RArray<TItemId>&>(request->MediaIds());

        switch(iFilterProperties.iItemType)

            {

            case EGlxFilterVideoAndImages:

            case EGlxFilterImage:

            case EGlxFilterVideo:

                {

            	QueueImageVideoObjectQueriesL(mediaIds, iFilterProperties);

        	    if (LocationAttributeRequested())

        	        {

        	        QueueLocaitonQueryL();

        	        }

                break;

                }

            case EGlxFilterAlbum:

                {

            	QueueAlbumObjectQueryL(mediaIds);

                break;

                }

            case EGlxFilterTag:

                {

                QueueTagObjectQueryL(mediaIds);

                break;

                }

            case EGlxFilterMonth:

                {

                QueueMonthObjectQueryL(mediaIds);

                break;

                }

            }

    	}

    DoNextQueryL();

    }

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

// CGlxDataSourceTaskMde::DoHandleQueryCompletedL

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

//

void CGlxDataSourceTaskMdeAttribute::DoHandleQueryCompletedL(CMdEQuery& /*aQuery*/)

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleQueryCompletedL()");   

    switch (iQueryTypes[0])

        {

        case ELocationAttributeQuery:

            DoHandleLocationQueryCompletedL();

        break;

        case EAttributeQuery:

            DoHandleAttributeQueryCompletedL();

        break;

        case EImageVideoQuery:

            DoHandleImageVideoQueryCompletedL();

        break;

        case EContainerFirstItemQuery:

            // Fall through to panic, DoHandleQueryCompletedL can't handle this query type.

        default:

            Panic(EGlxPanicLogicError);

        break;

        }  

    }

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

//  CGlxDataSourceTaskMdeAttribute::DoNextQueryL

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

//    

void CGlxDataSourceTaskMdeAttribute::DoNextQueryL()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoNextQueryL()");

    if (iQueries.Count())

        {

        ExecuteQueryL();

        }

    else

    	{

    	DoHandleAttributeResponseCompleteL();

    	}

    }

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

//  CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL

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

//     

void CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL()

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::DoHandleAttributeResponseCompleteL()");

    __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));

    CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);

    if(request->MediaIds().Count() > 1)

        {

        iResponse->SetCObjectValueL(KMPXMediaArrayContents, iMediaArray);

        iResponse->SetTObjectValueL(KMPXMediaArrayCount, iMediaArray->Count());

        delete iMediaArray;

        iMediaArray = NULL;

        }

    HandleRequestComplete(KErrNone);

    }

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

// CGlxDataSourceTaskMdeAttribute::AddAttributesLC

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

//      

void CGlxDataSourceTaskMdeAttribute::AddAttributesL(CMdEObject& aObject, CMPXMedia* aEntry)

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddAttributesL(CMdEObject& aObject, CMPXMedia* aEntry)");

    __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));

    CGlxDataSource::TContainerType containerType = DataSource()->ContainerType(&aObject);

    if( containerType != CGlxDataSource::EContainerTypeNotAContainer )

        {

        AddContainerAttributesL(aEntry, &aObject, containerType);

        }

    else 

        {

        CGlxDataSource::TItemType itemType = DataSource()->ItemType(&aObject);

        if ( itemType != CGlxDataSource::EItemTypeNotAnItem )

            {

            AddItemAttributesL(aEntry, &aObject, itemType);

            }

        else

            {

            User::Leave(KErrNotSupported);

            }

        }       

    }

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

// CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL

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

//     

void CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL(CMPXMedia* aEntry)

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddCollectionAttributesL(CMPXMedia* aEntry)");

    __ASSERT_DEBUG(aEntry, Panic(EGlxPanicLogicError));

    __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));

    CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);

    for ( TInt i = 0; i < request->Attributes().Count(); i++ )

        {

        if ( request->Attributes()[i] == KMPXMediaGeneralId )

            {

            aEntry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, (TMPXItemId)request->CollectionPluginUid().iUid);

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralType )

            {

            aEntry->SetTObjectValueL(KMPXMediaGeneralType, EMPXNoType);

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralCategory )

            {

            aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXCollection);

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralTitle )

            {

            request->AppendCpiAttributeL(KMPXMediaGeneralTitle);

            }

        else if ( request->Attributes()[i] == KGlxMediaGeneralSystemItem )

            {

            aEntry->SetTObjectValueL(KGlxMediaGeneralSystemItem, ETrue);

            }

 #ifdef GLX_SUB_TITLE_REL8

        //Attributes to get the Count of Images in Container                

        else if	( request->Attributes()[i] == KGlxMediaItemTypeImage )    

        	{

        	TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);

            CMdEObjectDef* objectDef = &DataSource()->ObjectDef();

            TBool isContent = ETrue;

            TGlxFilterProperties filterProperties = iFilterProperties;

            switch(iRequest->CollectionPluginUid().iUid)

	            {

	        	case KGlxCollectionPluginCameraImplementationUid:

	        		{        		

	                 container = DataSource()->CameraAlbumId();

	                 objectDef = &DataSource()->AlbumDef();

	                 filterProperties.iItemType = EGlxFilterImage;

	                 QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, EQueryResultModeCount, container, request->Attributes()[i], aEntry,  filterProperties);

	                 break;                    	

	        		}

	        	default:

	        		{

	        		break;	

	        		}

	        	 }

        	}           	

		//Attributes to get the Count of Videos in Container                    	

         else if ( request->Attributes()[i] == KGlxMediaItemTypeVideo )    

        	{

        	TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);

            CMdEObjectDef* objectDef = &DataSource()->ObjectDef();

            TBool isContent = ETrue;

            TGlxFilterProperties filterProperties = iFilterProperties;

            switch(iRequest->CollectionPluginUid().iUid)

	            {

	        	case KGlxCollectionPluginCameraImplementationUid:

	        		{        		

	                 container = DataSource()->CameraAlbumId();

	                 objectDef = &DataSource()->AlbumDef();

	                 filterProperties.iItemType = EGlxFilterVideo;

	                 QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, EQueryResultModeCount, container, request->Attributes()[i], aEntry,  filterProperties);

	                 break;                    	

	        		}

	        	default:

	        		{

	        		break;	

	        		}

	        	 }

        	}

#endif

        else if ( ( request->Attributes()[i] == KMPXMediaGeneralCount ) || ( request->Attributes()[i] == KGlxMediaCollectionInternalUsageCount ) )

            {

            TGlxMediaId container = TGlxMediaId(KGlxCollectionRootId);

            CMdEObjectDef* objectDef = &DataSource()->ObjectDef();

            TBool isContent = ETrue;

            TGlxFilterProperties filterProperties = iFilterProperties;

            switch(iRequest->CollectionPluginUid().iUid)

                {

                case KGlxCollectionPluginAlbumsImplementationUid:

                    {

                    isContent = EFalse;

                    objectDef = &DataSource()->AlbumDef();

                    break;

                    }

                case KGlxCollectionPluginCameraImplementationUid:

                    {

                    container = DataSource()->CameraAlbumId();

                    objectDef = &DataSource()->AlbumDef();

                    break;

                    }

                case KGlxTagCollectionPluginImplementationUid: 

                    {

                    isContent = EFalse;

                    objectDef = &DataSource()->TagDef();

                    break;

                    }

                case KGlxCollectionPluginMonthsImplementationUid:

                    {

                    container = DataSource()->CameraAlbumId();

                    objectDef = &DataSource()->AlbumDef();

                    break;

                    }

                default:

                    {

                    // default gallery query returns all objects as per filter

                    break;

                    }

                }

            QueueObjectQueryL(*objectDef, isContent, EAttributeQuery, EQueryResultModeCount, container, request->Attributes()[i], aEntry,  filterProperties);

            }

        else if ( request->Attributes()[i] == KMPXMediaColDetailSpaceId )

            {

            aEntry->SetTObjectValueL(KMPXMediaColDetailSpaceId, KGlxDataSourceMdeImplementationUid);

            }

        else if ( request->Attributes()[i] == KGlxMediaCollectionInternalStartDate )

            {

            TGlxFilterProperties filterProperties = iFilterProperties;

            filterProperties.iSortOrder = EGlxFilterSortOrderCaptureDate;

            filterProperties.iSortDirection = EGlxFilterSortDirectionAscending;

            QueueObjectQueryL(DataSource()->AlbumDef(), ETrue, EAttributeQuery, EQueryResultModeObjectWithoutFreetexts, DataSource()->CameraAlbumId(), KGlxMediaCollectionInternalStartDate, aEntry, filterProperties);

            }

        else if ( request->Attributes()[i] == KGlxMediaCollectionInternalEndDate )

            {

            // not necessary to be requested, returned when StartDate requested

            }

        else if ( request->Attributes()[i] == KGlxMediaGeneralSlideshowableContent )

            {

            aEntry->SetTObjectValueL(KGlxMediaGeneralSlideshowableContent, 0);

            }

        else if ( request->Attributes()[i] == KMPXMediaDrmProtected )

            {

            // collection itself is not protected

            aEntry->SetTObjectValueL(KMPXMediaDrmProtected, EFalse); 

            }

        else

            {

            User::Leave(KErrNotSupported);

            }

        }

    }

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

// CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL

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

//

void CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL(CMPXMedia* aEntry, CMdEObject* aContainer, CGlxDataSource::TContainerType aType)

    {

    GLX_LOG_ENTRY_EXIT("void CGlxDataSourceTaskMdeAttribute::AddContainerAttributesL()");

    __ASSERT_DEBUG(aEntry, Panic(EGlxPanicLogicError));

    __ASSERT_DEBUG(aContainer, Panic(EGlxPanicLogicError));

    __ASSERT_DEBUG(dynamic_cast<CGlxGetRequest*>(iRequest), Panic(EGlxPanicLogicError));

    CGlxGetRequest* request = static_cast<CGlxGetRequest*>(iRequest);

    /// @todo check property defs are valid and type is correct

    for ( TInt i = 0; i < request->Attributes().Count(); i++ )

        {

        if ( request->Attributes()[i] == KMPXMediaGeneralId )

            {

            aEntry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, (TMPXItemId)aContainer->Id());

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralType )

            {

            aEntry->SetTObjectValueL(KMPXMediaGeneralType, EMPXGroup);

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralCategory )

            {

            if( CGlxDataSource::EContainerTypeAlbum == aType)

                {

                aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXAlbum);

                }

            else if( CGlxDataSource::EContainerTypeTag == aType)

                {

                aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXTag);

                }

            else if( CGlxDataSource::EContainerTypeMonth == aType)

                {

                aEntry->SetTObjectValueL(KMPXMediaGeneralCategory, EMPXMonth);

                }

            else

                {

                User::Leave(KErrNotSupported);

                }

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralUri )

            {

            aEntry->SetTextValueL(KMPXMediaGeneralUri, aContainer->Uri());

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralTitle )

            {

            CMdEProperty* title;

            CMdEPropertyDef* titleProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameTitle);

            TInt titleIndex = aContainer->Property(*titleProperty, title);

            if(titleIndex == KErrNotFound)

                {

                TParsePtrC parser(aContainer->Uri());

                aEntry->SetTextValueL(KMPXMediaGeneralTitle, parser.Name());

                }

            else

                {

                aEntry->SetTextValueL(KMPXMediaGeneralTitle, static_cast<CMdETextProperty*>(title)->Value());

                }

            switch (aType)

                {

                case CGlxDataSource::EContainerTypeAlbum:

                    {

                    CMdEProperty* albumType;

                    CMdEPropertyDef* albumTypeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameAlbumType);

                    TInt albumTypeIndex = aContainer->Property(*albumTypeProperty, albumType);

                    if( KErrNotFound != albumTypeIndex )

                        {

                        TUint16 albumTypeValue = static_cast<CMdEUint16Property*>(albumType)->Value();

                        if ( albumTypeValue != MdeConstants::Album::EAlbumUser ) 

                            {

                            request->AppendCpiAttributeL(KMPXMediaGeneralTitle);

                            aEntry->SetTObjectValueL(KGlxMediaCollectionInternalSystemItemType, albumTypeValue);

                            }

                        }

                    break;

                    }

                case CGlxDataSource::EContainerTypeTag:

                    {

                    break;

                    }

                case CGlxDataSource::EContainerTypeMonth:

                    {

                    request->AppendCpiAttributeL(KMPXMediaGeneralTitle);

                    CMdEProperty* time;

                    CMdEPropertyDef* timeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameCreationDate);

                    TInt timeIndex = aContainer->Property(*timeProperty, time);

                    if( KErrNotFound == timeIndex )

                        {

                        User::Leave(KErrCorrupt);

                        }

                    aEntry->SetTObjectValueL(KGlxMediaCollectionInternalStartDate, static_cast<CMdETimeProperty*>(time)->Value());

                    break;

                    }

                }

            }

        else if ( request->Attributes()[i] == KMPXMediaGeneralDate )

            {

            CMdEProperty* time;

            CMdEPropertyDef* timeProperty = aContainer->Def().GetPropertyDefL(KPropertyDefNameCreationDate);

            TInt timeIndex = aContainer->Property(*timeProperty, time);

            if( KErrNotFound == timeIndex )

                {