/*

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

*

*/

/**

 * @internal reviewed 11/07/2007 by M Byrne

 */

#include "glxdatasourcetaskmdscommand.h"

#include <bautils.h>

#include <e32math.h>

#include <glxcommandrequest.h>

#include <glxpanic.h>

#include <glxtracer.h>

#include <caf/manager.h>

#include <mdeconstants.h>

#include <mdeeventdef.h>

#include <mdelogiccondition.h>

#include <mdeobject.h>

#include <mdeobjectdef.h>

#include <mdeobjectquery.h>

#include <mdepropertydef.h>

#include <mderelationcondition.h>

#include <mderelationdef.h>

#include <mderelationquery.h>

#include <mdesession.h>

#include <mdetextproperty.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediageneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessageprogressdefs.h>

#include <pathinfo.h>

#include <glxstringcache.h>

#include <glxcollectionplugincamera.hrh>

#include <glxcollectionplugintags.hrh>

#include <glxcollectionpluginalbums.hrh>

#include <glxcollectionpluginall.hrh>

#include "glxdatasourcemds.h"

#include "glxdatasourcemdsutility.h"

#include "glxdatasourcemds.hrh"

#include <glxpluginalbums.rsg>

#include <data_caging_path_literals.hrh>

#include <f32file.h>

#include <barsc.h>

#include <bautils.h>

// CONSTANTS

_LIT(KPropertyDefNameDescription, "Comment");

_LIT(KPropertyDefNameTitle, "Title" );

_LIT(KPropertyDefNameSize, "Size");

_LIT(KPropertyDefNameCreationDate, "CreationDate");

_LIT(KPropertyDefNameLastModifiedDate, "LastModifiedDate");

_LIT(KPropertyDefNameAlbumType, "Type");

_LIT(KPropertyDefItemType, "ItemType");

// Item type for Album

_LIT( KAlbumItemType, "application/vnd.nokia.mde.album" );

// Item type for Tag

_LIT( KTagItemType, "application/vnd.nokia.mde.tag" );

const TInt KDriveLetterLength = 1;

_LIT(KColonBackslash, ":\\");

_LIT(KFileNameFormatString, "(%+02u)");

// Items to be deleted from File server at a time before calling scheduler wait

const TInt KDeletedItemCount = 10;

const TInt KDeleteOperationInterval = 1000;

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

// Destructor

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

//

CGlxDataSourceTaskMdeCommand::~CGlxDataSourceTaskMdeCommand()

	{

    TRACER("CGlxDataSourceTaskMdeCommand::~CGlxDataSourceTaskMdeCommand()");

	iLeftIds.Close();

    iRightIds.Close();

    delete iTitle;

    delete iObjectToRename;

    delete iStringCache;

    if(iTimer && iTimer->IsActive())

		{

		iTimer->Cancel();

		}

	delete iTimer;

    delete iSchedulerWait;    

    }

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

// Constructor

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

//

CGlxDataSourceTaskMdeCommand::CGlxDataSourceTaskMdeCommand(

       CGlxCommandRequest* aRequest, MGlxDataSourceRequestObserver& aObserver, 

       CGlxDataSource* aDataSource)

    : CGlxDataSourceTaskMde(aRequest, aObserver, aDataSource) 

	{

    TRACER("CGlxDataSourceTaskMdeCommand::CGlxDataSourceTaskMdeCommand()");

	// No implementation required

	}

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

// Second phase constructor

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

//

void CGlxDataSourceTaskMdeCommand::ConstructL()

	{

    TRACER("CGlxDataSourceTaskMdeCommand::ConstructL()");

	iResponse = CMPXCommand::NewL(static_cast<CGlxCommandRequest*>(iRequest)->Command());

    DataSource()->CancelFetchThumbnail();

    iTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iSchedulerWait = new (ELeave) CActiveSchedulerWait();

	}

/// @todo minor: Rowland Cook 12/06/2007 Add method decription.

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

// CGlxDataSourceTaskMdeCommand::ExecuteRequestL

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

//

void CGlxDataSourceTaskMdeCommand::ExecuteRequestL()

	{

    TRACER("CGlxDataSourceTaskMdeCommand::ExecuteRequestL()");

    __ASSERT_DEBUG(DataSource()->NamespaceDef(), Panic(EGlxPanicIllegalState));

	const CMPXCommand& command = static_cast<CGlxCommandRequest*>(iRequest)->Command();

	if ( command.IsSupported(KMPXCommandGeneralCollectionId) )

		{

		iCollectionUid = command.ValueTObjectL<TUid>(KMPXCommandGeneralCollectionId);

		}

	else

		{

		// if the collection Uid has not been set on the command, use the Ud of the plugin in use.

		iCollectionUid = iRequest->CollectionPluginUid();

		}

	TGlxCommandParser::ParseL(*this, command);

	}

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

// Add container

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

//

void CGlxDataSourceTaskMdeCommand::AddContainerL(const TDesC& aContainerName)

	{

    TRACER("CGlxDataSourceTaskMdeCommand::AddContainerL()");

	iTitle = aContainerName.AllocL();

	AppendContainerTitleCountQueryL(ECommandAddContainer, aContainerName);

    ExecuteQueryL();

    }

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

// Add items to container by id

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

//

void CGlxDataSourceTaskMdeCommand::AddToContainerL(const RArray<TGlxMediaId>& aSourceIds,

        const RArray<TGlxMediaId>& aTargetContainers)

	{

    TRACER("CGlxDataSourceTaskMdeCommand::AddToContainerL(const RArray<TGlxMediaId>& aSourceIds,const RArray<TGlxMediaId>& aTargetContainers)");	

	__ASSERT_DEBUG(aSourceIds.Count() && aTargetContainers.Count(), 

	        Panic(EGlxPanicEmptyArray));

    iLeftIds.Reset();

    iRightIds.Reset();

	CMdEQuery* query = DataSource()->Session().NewRelationQueryL(

	        *DataSource()->NamespaceDef(), this); 

	AppendQueryL(query, ECommandAddToContainer);

    CMdELogicCondition& rootCondition = query->Conditions();

    CMdERelationCondition& containerRelationCondition = 

    rootCondition.AddRelationConditionL(DataSource()->ContainsDef(),

            ERelationConditionSideLeft);

    CMdELogicCondition& leftLogicCondition = containerRelationCondition.LeftL();

    CMdELogicCondition& rightLogicCondition = containerRelationCondition.RightL();

    leftLogicCondition.SetOperator(ELogicConditionOperatorOr);

    rightLogicCondition.SetOperator(ELogicConditionOperatorOr);

    TItemId containerId = ContainerItemId(aTargetContainers[0]);

    // It is currenly a safe assumption that all containers are of the same type (either albums or tags)

    // and thus they will either all be on the left or all be on the right of the logic condition. Therefore, 

    // we only need to test the first container to see if it is on the left or on the right. 

    CMdEObject* container = DataSource()->Session().GetObjectL(containerId);

    if (!container)

        {

        User::Leave(KErrNotFound);

        }

    TBool containerIsLeft = DataSource()->ContainerIsLeft(container->Def());

    delete container;

    container = NULL;

    if (containerIsLeft)

        {

        // the container is on the left

        NGlxDataSourceMdsUtility::CopyMediaIdArrayL(iLeftIds, aTargetContainers);

        NGlxDataSourceMdsUtility::CopyMediaIdArrayL(iRightIds, aSourceIds);

        }

    else

        {

        // the container is on the right

        NGlxDataSourceMdsUtility::CopyMediaIdArrayL(iRightIds, aTargetContainers);

        NGlxDataSourceMdsUtility::CopyMediaIdArrayL(iLeftIds, aSourceIds);

        }

    leftLogicCondition.AddObjectConditionL(iLeftIds);

    rightLogicCondition.AddObjectConditionL(iRightIds);

    query->SetResultMode(EQueryResultModeItem);	 

    ExecuteQueryL();

    }

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

// Add item to containers by URI.

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

//

void CGlxDataSourceTaskMdeCommand::AddToContainerL(const TDesC& aSourceUri, 

		                        const RArray< TGlxMediaId >& aTargetContainers)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::AddToContainerL()");

    CMdEObject* sourceObject = DataSource()->Session().GetObjectL(aSourceUri);

    if (!sourceObject)

        {

        User::Leave(KErrNotFound);

        }

    RArray<TGlxMediaId> sourceIds;

    CleanupClosePushL(sourceIds);

    sourceIds.AppendL(TGlxMediaId(sourceObject->Id()));

    AddToContainerL(sourceIds, aTargetContainers);

    CleanupStack::PopAndDestroy(&sourceIds);

    }

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

// Copy files to another drive.

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

//

void CGlxDataSourceTaskMdeCommand::CopyL(const RArray<TGlxMediaId>& aSourceIds, 

        const TDesC& aDrive)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::CopyL()");

    FileOperationL(aSourceIds.Array(), aDrive, ECopy);

    }

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

// Move files to another drive.

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

//

void CGlxDataSourceTaskMdeCommand::MoveL(const RArray<TGlxMediaId>& aSourceIds, 

        const TDesC& aDrive)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::MoveL()");

    FileOperationL(aSourceIds.Array(), aDrive, EMove);

    }

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

// Remove items from a container.

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

//

void CGlxDataSourceTaskMdeCommand::RemoveFromContainerL(

        const RArray<TGlxMediaId>& aItemIds, const TGlxMediaId& aContainerId)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::RemoveFromContainerL()");

    // Answer to question in @bug above: No

	CMdEObject* object = NULL;

	object = DataSource()->Session().GetObjectL(aContainerId.Value());

    CleanupStack::PushL(object);

	if (!object)

    	{

    	User::Leave(KErrNotFound);

    	}

	CMdEQuery* query = DataSource()->Session().NewRelationQueryL(

	        *DataSource()->NamespaceDef(), this); 

	AppendQueryL(query, ECommandRemoveFromContainer); // query is now owned by the query array.

    CMdELogicCondition& rootCondition = query->Conditions();

    CMdERelationCondition& containerRelationCondition = 

    rootCondition.AddRelationConditionL(

            DataSource()->ContainsDef(), ERelationConditionSideLeft);

    CMdELogicCondition* containerLogicCondition = NULL;

    CMdELogicCondition* itemLogicCondition = NULL;

    // Containers are on the left for albums, right for tags

    if ( DataSource()->ContainerIsLeft(object->Def()) )

    	{

    	containerLogicCondition = &containerRelationCondition.LeftL();

    	itemLogicCondition = &containerRelationCondition.RightL();

    	}

    else

    	{

    	containerLogicCondition = &containerRelationCondition.RightL();

    	itemLogicCondition = &containerRelationCondition.LeftL();

    	}

    containerLogicCondition->AddObjectConditionL(aContainerId.Value());

    itemLogicCondition->SetOperator(ELogicConditionOperatorOr);

    NGlxDataSourceMdsUtility::AddObjectConditionL(*itemLogicCondition,aItemIds);

    query->SetResultMode(EQueryResultModeId);	 

    CleanupStack::PopAndDestroy(object);

    ExecuteQueryL();

    }

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

// Delete files, Remove container.

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

//

void CGlxDataSourceTaskMdeCommand::DeleteL(const RArray<TGlxMediaId>& aItemIds)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::DeleteL()");

    CMdEObjectDef* containerObjectDef = NULL;

    TInt err = ContainerObjectDef(containerObjectDef);

    if (err == KErrNone)

    	{

	    QueueObjectQueryL(*containerObjectDef, 

	            aItemIds, ECommandDeleteContainers);

    	}

    // Assume that only items are left

    QueueObjectQueryL(DataSource()->ObjectDef(), 

                aItemIds, ECommandDeleteItems);

    ExecuteQueryL();

    }

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

// Rename files, Rename container.

//

/// @todo test this method.

//

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

//

void CGlxDataSourceTaskMdeCommand::RenameL(const TGlxMediaId& aSourceItemId, 

        const TDesC& aTitle)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::RenameL()");

    delete iTitle;

    iTitle = NULL;

	iTitle = aTitle.AllocL();

	RArray<TGlxMediaId> sourceIdArray;

	CleanupClosePushL(sourceIdArray);

	sourceIdArray.AppendL(aSourceItemId);

	QueueObjectQueryL(DataSource()->ObjectDef(), sourceIdArray , ECommandRename);

	CleanupStack::PopAndDestroy(&sourceIdArray);

	ExecuteQueryL();

    }

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

// Set description.

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

//

void CGlxDataSourceTaskMdeCommand::SetDescriptionL(const RArray<TGlxMediaId>& aItemIds, 

        const TDesC& aDescription)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::SetDescriptionL()");

    CMdEPropertyDef& descriptionPropertyDef = DataSource()->MediaDef().GetPropertyDefL(

            KPropertyDefNameDescription);

    if (descriptionPropertyDef.PropertyType() != EPropertyText)

    	{

    	User::Leave(KErrCorrupt);

    	}

    TInt count = aItemIds.Count();

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

    	{

    	TItemId itemId = aItemIds[i].Value();

    	CMdEObject* object = DataSource()->Session().OpenFullObjectL(itemId);

    	if (!object)

    		{

    		User::Leave(KErrNotFound);

    		}

    	CleanupStack::PushL(object);

    	CMdEProperty* descriptionProperty = NULL;

    	TInt index = object->Property(descriptionPropertyDef, descriptionProperty);

	    if (index < KErrNotFound)

	    	{

	    	User::Leave(index);

	    	}

	    if (index != KErrNotFound)

	    	{

	    	// Check whether the description string is empty

	    	if( aDescription.Length()  )

	    	    {	    	   

	    	    static_cast<CMdETextProperty*>(descriptionProperty)->SetValueL(aDescription);

	    	    }

	        //if entered description string is blank then remove the old property

	    	else

                {

                object->RemoveProperty(index);

                }

	    	}

    	else

    	    {

    	    if( aDescription.Length()  )

	    	    {

    	    object->AddTextPropertyL(descriptionPropertyDef, aDescription);

	    	    }

    	    }

	    DataSource()->Session().CommitObjectL(*object); 

	    CleanupStack::PopAndDestroy(object);

    	}

    HandleRequestComplete(KErrNone);

    }

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

// Set capture location.

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

//

void CGlxDataSourceTaskMdeCommand::SetCaptureLocationL(const RArray<TGlxMediaId>& aItemIds, 

        const TCoordinate& aCoordinate)

    {

    TRACER("CGlxDataSourceTaskMdeCommand::SetCaptureLocationL()") ;   

    if (!Math::IsNaN(aCoordinate.Latitude()) || !Math::IsNaN(aCoordinate.Longitude()))

    	{

    	User::Leave(KErrArgument);

    	}

	CMdEQuery* query = DataSource()->Session().NewRelationQueryL(*DataSource()->NamespaceDef(), this); 

	AppendQueryL(query, ECommandRemoveLocation); // query is now owned by the query array.

    CMdELogicCondition& rootCondition = query->Conditions();

    CMdERelationCondition& containerRelationCondition = rootCondition.AddRelationConditionL(

            ERelationConditionSideLeft);

    CMdELogicCondition& locationLogicCondition = containerRelationCondition.RightL();

    CMdELogicCondition& itemLogicCondition = containerRelationCondition.LeftL();

    locationLogicCondition.AddObjectConditionL(DataSource()->LocationDef());

    itemLogicCondition.SetOperator(ELogicConditionOperatorOr);

    itemLogicCondition.AddObjectConditionL(reinterpret_cast<const RArray<TItemId>&>(aItemIds));

    query->SetResultMode(EQueryResultModeId);	 

    ExecuteQueryL();

    }

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

// CGlxDataSourceTaskMdeCommand::ThumbnailCleanupL

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

//

void CGlxDataSourceTaskMdeCommand::ThumbnailCleanupL()

	{

    TRACER("CGlxDataSourceTaskMdeCommand::ThumbnailCleanupL()");

	HandleRequestComplete(KErrNone);	

	}

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

// CGlxDataSourceTaskMdeCommand::HandleQueryCompletedL

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

//

void CGlxDataSourceTaskMdeCommand::DoHandleQueryCompletedL(CMdEQuery& aQuery)

	{

    TRACER("CGlxDataSourceTaskMdeCommand::DoHandleQueryCompletedL()");

    TGlxQueryType queryType = iQueryTypes[0];

    switch (queryType)

    	{

	    case ECommandRemoveFromContainer: // don't break

	    case ECommandRemoveLocation:

			{

			TInt queryCount = aQuery.Count();

			RArray<TItemId> relationsToRemove;

			CleanupClosePushL(relationsToRemove);

			User::LeaveIfError(relationsToRemove.Reserve(queryCount));

			RArray<TItemId> successfullyRemovedReleations;

			CleanupClosePushL(successfullyRemovedReleations);

			User::LeaveIfError(successfullyRemovedReleations.Reserve(queryCount));

			for(TInt i = queryCount - 1; i >= 0; i--)

				{		

				relationsToRemove.AppendL(aQuery.ResultId(i));

				}

			if (queryCount)

				{