/*

* Copyright (c) 2007-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:  This is Manipulation engine to manage adding,

*                deleting and modifying metadata database entries

*

*/

// INCLUDE FILES

#include "mdsmanipulationengine.h"

#include "mdcresult.h"

#include "mdcitem.h"

#include "mdsschema.h"

#include "mdsnotifier.h"

#include "mdsdbconnectionpool.h"

#include "mdslogger.h"

#include "mdssqlobjectmanipulate.h"

#include "mdssqliteconnection.h"

#include "mdsnamespacedef.h"

#include "mdcserializationbuffer.h"

#include "mdeinternalerror.h"

#include "mdeerror.h"

#include "mdscommoninternal.h"

// for CleanupResetAndDestroyPushL

#include <mmf/common/mmfcontrollerpluginresolver.h>

__USES_LOGGER

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

// NewL

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

//

CMdSManipulationEngine* CMdSManipulationEngine::NewL( CMdsSchema& aSchema,

    CMdSNotifier& aNotifier, CMdSObjectLockList& aLockList )

    {

    CMdSManipulationEngine* self = CMdSManipulationEngine::NewLC( aSchema, 

    		aNotifier, aLockList );

    CleanupStack::Pop( self );

    return self;

    }

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

// NewLC

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

//

CMdSManipulationEngine* CMdSManipulationEngine::NewLC( CMdsSchema& aSchema,

    CMdSNotifier& aNotifier, CMdSObjectLockList& aLockList )

    {

    CMdSManipulationEngine* self = new (ELeave) CMdSManipulationEngine(

        aSchema, aNotifier, aLockList );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Default constructor

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

//

CMdSManipulationEngine::CMdSManipulationEngine( CMdsSchema& aSchema,

    CMdSNotifier& aNotifier, CMdSObjectLockList& aLockList )

    : iManipulate( NULL ), iSchema( aSchema ), iNotifier( aNotifier ), 

    iGarbageCollector( NULL ), iLockList( aLockList )

    {

    }

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

// ConstructL

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

//

void CMdSManipulationEngine::ConstructL()

    {

    iManipulate = CMdSSqlObjectManipulate::NewL( iSchema, iLockList );

    iGarbageCollector = CMdSGarbageCollector::NewL(*this);

    }

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

// Destructor

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

//

CMdSManipulationEngine::~CMdSManipulationEngine()

    {

    delete iManipulate;

    delete iGarbageCollector;

    }

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

// Manipulate

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

//

CMdSSqlObjectManipulate& CMdSManipulationEngine::Manipulate()

    {

    return *iManipulate;

    }

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

// GarbageCollector

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

//

CMdSGarbageCollector& CMdSManipulationEngine::GarbageCollector()

	{

	return *iGarbageCollector;

	}

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

// AddL adds objects from serialized buffer

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

//

void CMdSManipulationEngine::AddL( CMdCSerializationBuffer& aBuffer, 

		CMdCSerializationBuffer& aResultBuffer, 

		const CMdSServerSession* aServerSession )

	{

	const TMdCItems& items = TMdCItems::GetFromBufferL( aBuffer );

	const CMdsNamespaceDef* namespaceDef = iSchema.GetNamespaceByIdL( 

			items.iNamespaceDefId );

	if ( !namespaceDef )

		{

		User::Leave( KErrMdEUnknownNamespaceDef );

		}

	iManipulate->SetNamespace( namespaceDef );

	CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

	TMdCItemIds resultIds;

	resultIds.iNamespaceDefId = items.iNamespaceDefId;

	resultIds.iErrorCode = KErrNone;

	aResultBuffer.PositionL( sizeof(TMdCItemIds) );

	// add objects

	const TInt KObjectCount = items.iObjects.iPtr.iCount;

	if ( KObjectCount > 0 )

		{

		resultIds.iObjectIds.iPtr.iOffset = aResultBuffer.Position();

		resultIds.iObjectIds.iPtr.iCount = items.iObjects.iPtr.iCount;

        RMdsStatement baseObjStmt;

        CleanupClosePushL(baseObjStmt);

        RMdsStatement objStmt;

        CleanupClosePushL(objStmt);

        RMdSTransaction transaction( connection );

        const TInt beginError( transaction.Error() );

        if( beginError != KErrNone )

            {

            CleanupStack::PopAndDestroy( &transaction );

            }

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

            {

            aBuffer.PositionL( items.iObjects.iPtr.iOffset + i * sizeof(TMdCObject) );

            TItemId id = KNoId;

            TRAPD( err, id = iManipulate->AddObjectL( connection, aBuffer, 

                    baseObjStmt, objStmt, aServerSession ) );

            if (err == KErrNone)

                {

                aResultBuffer.InsertL( id );

                iAddedObjectsCount++;

                }

            else

                {

                aResultBuffer.InsertL( KNoId );

                if(resultIds.iErrorCode == KErrNone)

                    {

                    resultIds.iErrorCode = err;

                    }

                }

            }

        if( beginError == KErrNone )

            {

            transaction.CommitL();

            CleanupStack::PopAndDestroy( &transaction );

            }

        CleanupStack::PopAndDestroy(&objStmt);

        CleanupStack::PopAndDestroy(&baseObjStmt);

		}

	else

		{

		resultIds.iObjectIds.iPtr.iOffset = KNoOffset;

		resultIds.iObjectIds.iPtr.iCount = 0;

		}

	 // add events

    const TInt KEventCount = items.iEvents.iPtr.iCount;

    if ( KEventCount > 0 )

		{

		resultIds.iEventIds.iPtr.iOffset = aResultBuffer.Position();

		resultIds.iEventIds.iPtr.iCount = KEventCount;

        RMdSTransaction transaction( connection );

        CleanupClosePushL(transaction);

        const TInt beginError( transaction.Error() );

        if( beginError != KErrNone )

            {

            CleanupStack::PopAndDestroy( &transaction );

            }

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

			{

			aBuffer.PositionL( items.iEvents.iPtr.iOffset + 

					i * sizeof(TMdCEvent) );

			TItemId id = KNoId;

			TRAPD( err, id = iManipulate->AddEventL( connection, aBuffer ) );

			if (err == KErrNone)

				{

				aResultBuffer.InsertL( id );

				}

			else

				{

				aResultBuffer.InsertL( KNoId );

				if(resultIds.iErrorCode == KErrNone)

					{

					resultIds.iErrorCode = err;

					}

				}

			}

        if( beginError == KErrNone )

            {

            transaction.CommitL();

            CleanupStack::PopAndDestroy( &transaction );

            }

		}

	else

		{

		resultIds.iEventIds.iPtr.iOffset = KNoOffset;

		resultIds.iEventIds.iPtr.iCount = 0;

		}

	// add relations

    const TInt KRelationCount = items.iRelations.iPtr.iCount;

    if ( KRelationCount > 0 )

		{

		resultIds.iRelationIds.iPtr.iOffset = aResultBuffer.Position();

		resultIds.iRelationIds.iPtr.iCount = KRelationCount;

        RMdSTransaction transaction( connection );

        CleanupClosePushL(transaction);

        const TInt beginError( transaction.Error() );

        if( beginError != KErrNone )

            {

            CleanupStack::PopAndDestroy( &transaction );

            }

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

			{

			aBuffer.PositionL( items.iRelations.iPtr.iOffset + 

					i * sizeof(TMdCRelation) );

			TItemId id = KNoId;

			TRAPD( err, id = iManipulate->AddRelationL( connection, aBuffer ) );

			if (err == KErrNone)

				{

				aResultBuffer.InsertL( id );

				}

			else

				{

				aResultBuffer.InsertL( KNoId );

				if(resultIds.iErrorCode == KErrNone)

					{

					resultIds.iErrorCode = err;

					}

				}

			}

        if( beginError == KErrNone )

            {

            transaction.CommitL();

            CleanupStack::PopAndDestroy( &transaction );

            }

		}

	else

		{

		resultIds.iRelationIds.iPtr.iOffset = KNoOffset;

		resultIds.iRelationIds.iPtr.iCount = 0;

		}

	// set up result header

	aResultBuffer.PositionL( KNoOffset );

	resultIds.SerializeL( aResultBuffer );

	iManipulate->SetNamespace( NULL );

	iNotifier.NotifyAddedL( aBuffer, aResultBuffer );

    if( iAddedObjectsCount > KTriggerDbMaintenanceTreasholdValue )

	   {

	   RMdSTransaction transaction( connection );

	   CleanupClosePushL(transaction);

	   const TInt beginError( transaction.Error() );

	   if( beginError != KErrNone )

	       {

	       CleanupStack::PopAndDestroy( &transaction );

	       }

	   iManipulate->AnalyzeL();

	   if( beginError == KErrNone )

	       {

	       transaction.CommitL();

	       CleanupStack::PopAndDestroy( &transaction );

	       }

	   iAddedObjectsCount = 0;

	   }

	}

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

// RemoveL

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

//

void CMdSManipulationEngine::RemoveL( CMdCSerializationBuffer& aBuffer, 

		CMdCSerializationBuffer& aResultBuffer )

    {

    // Read item ids from buffer.

    const TMdCItemIds& itemIds = TMdCItemIds::GetFromBufferL( aBuffer );

	const CMdsNamespaceDef* namespaceDef = iSchema.GetNamespaceByIdL( 

			itemIds.iNamespaceDefId );

	if ( !namespaceDef )

		{

		User::Leave( KErrMdEUnknownNamespaceDef );

		}

	iManipulate->SetNamespace( namespaceDef );

    TMdCItemIds resultIds;

	resultIds.iNamespaceDefId = itemIds.iNamespaceDefId;

	resultIds.iErrorCode = KErrNone;

	resultIds.iObjectUris.iPtr.iCount = 0;

	resultIds.iObjectUris.iPtr.iOffset = KNoOffset;

	aResultBuffer.PositionL( sizeof(TMdCItemIds) );

	RArray<TItemId> idArray;

	CleanupClosePushL( idArray );

	RArray<TItemId> removedRelations;

	CleanupClosePushL( removedRelations );

	RArray<TItemId> removedEvents;

	CleanupClosePushL( removedEvents );

	RPointerArray<HBufC> removedItemUriArray;

	CleanupResetAndDestroyPushL( removedItemUriArray );

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

    const TBool uriNotify = iNotifier.CheckForNotifier(EObjectNotifyRemoveWithUri);

    // Remove objects by id or URI.

    if (itemIds.iObjectIds.iPtr.iCount + itemIds.iObjectUris.iPtr.iCount > 0)

		{

	    RMdSTransaction transaction( connection );

	    CleanupClosePushL(transaction);

	    User::LeaveIfError( transaction.Error() );

		if (itemIds.iObjectUris.iPtr.iCount > 0)

			{

			aBuffer.PositionL( itemIds.iObjectUris.iPtr.iOffset );

			iManipulate->RemoveObjectsByUriL( aBuffer, itemIds.iObjectUris.iPtr.iCount,

					idArray, removedRelations, removedEvents, uriNotify, removedItemUriArray );

			}

		else

			{

		    // pause garbage collector so it does not remove the objects

			// before uris are read

		    if( iGarbageCollector && uriNotify )

		        {

		        iGarbageCollector->Pause();

		        }

			aBuffer.PositionL( itemIds.iObjectIds.iPtr.iOffset );

			iManipulate->RemoveObjectsByIdL( aBuffer, itemIds.iObjectIds.iPtr.iCount,

					idArray, removedRelations, removedEvents, uriNotify, removedItemUriArray );

			}

	    transaction.CommitL();

		CleanupStack::PopAndDestroy( &transaction );

        // write it to the buffer

        const TInt count = idArray.Count();

		resultIds.iObjectIds.iPtr.iOffset = aResultBuffer.Position();

        resultIds.iObjectIds.iPtr.iCount = count;

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

        	{

        	aResultBuffer.InsertL( idArray[i] );

        	if (idArray[i] == KNoId && resultIds.iErrorCode==KErrNone)

        		{

        		resultIds.iErrorCode = KErrNotFound;

        		}

        	}

        idArray.Reset();

		}

    else

    	{

    	resultIds.iObjectIds.iPtr.iCount = 0;

    	resultIds.iObjectIds.iPtr.iOffset = KNoOffset;

    	}

    // Remove events by id.

	if (itemIds.iEventIds.iPtr.iCount > 0)

		{

		// process events

		aBuffer.PositionL( itemIds.iEventIds.iPtr.iOffset );

	    RMdSTransaction transaction( connection );

	    CleanupClosePushL(transaction);

	    User::LeaveIfError( transaction.Error() );

		iManipulate->RemoveEventsL( aBuffer, itemIds.iEventIds.iPtr.iCount, idArray );

	    transaction.CommitL();

		CleanupStack::PopAndDestroy( &transaction );

        const TInt count = idArray.Count();

        resultIds.iEventIds.iPtr.iOffset = aResultBuffer.Position();

        resultIds.iEventIds.iPtr.iCount = count;

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

        	{

        	aResultBuffer.InsertL( idArray[i] );

        	if (idArray[i] == KNoId && resultIds.iErrorCode==KErrNone)

        		{

        		resultIds.iErrorCode = KErrNotFound;

        		}

        	}

		idArray.Reset();

		}

	else

		{

        resultIds.iEventIds.iPtr.iOffset = KNoOffset;

        resultIds.iEventIds.iPtr.iCount = 0;

		}

	// Remove relations by id.

	if (itemIds.iRelationIds.iPtr.iCount > 0)

		{

		// process relations

		aBuffer.PositionL( itemIds.iRelationIds.iPtr.iOffset );

	    RMdSTransaction transaction( connection );

	    CleanupClosePushL(transaction);

	    User::LeaveIfError( transaction.Error() );

		iManipulate->RemoveRelationsL( aBuffer, itemIds.iRelationIds.iPtr.iCount, idArray );

	    transaction.CommitL();

		CleanupStack::PopAndDestroy( &transaction );

        const TInt count = idArray.Count();

        resultIds.iRelationIds.iPtr.iOffset = aResultBuffer.Position();

        resultIds.iRelationIds.iPtr.iCount = count;

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

        	{

        	aResultBuffer.InsertL( idArray[i] );

        	if (idArray[i] == KNoId && resultIds.iErrorCode==KErrNone)

        		{

        		resultIds.iErrorCode = KErrNotFound;

        		}

        	}

		}

	else

		{

        resultIds.iRelationIds.iPtr.iOffset = KNoOffset;

        resultIds.iRelationIds.iPtr.iCount = 0;

		}

	aResultBuffer.PositionL( KNoOffset );

	resultIds.SerializeL( aResultBuffer );

	TBool notify = iNotifier.CheckForNotifier(EObjectNotifyRemove|EEventNotifyRemove|ERelationNotifyRemove);

	// notify about items removed 

	if( uriNotify || notify )

	    {

	    iNotifier.NotifyRemovedL( aResultBuffer, EFalse, removedItemUriArray, this );

		notify = ETrue;

	    }

	// notify about additional items removed

	const TInt KRemovedItemsCount = removedRelations.Count() + removedEvents.Count();

    if ( notify && KRemovedItemsCount > 0 )

    	{

    	const TInt32 bufferSize = sizeof(TMdCItemIds)

							+ KRemovedItemsCount * CMdCSerializationBuffer::KRequiredSizeForTItemId;

		CMdCSerializationBuffer* buffer = CMdCSerializationBuffer::NewLC( bufferSize );

		buffer->PositionL( sizeof(TMdCItemIds) );

		TMdCItemIds additResultIds;

		additResultIds.iNamespaceDefId = itemIds.iNamespaceDefId;

		additResultIds.iErrorCode = KErrNone;

		additResultIds.iObjectIds.iPtr.iOffset = KNoOffset;

		additResultIds.iObjectIds.iPtr.iCount = 0;

		additResultIds.iObjectUris.iPtr.iOffset = KNoOffset;

		additResultIds.iObjectUris.iPtr.iCount = 0;

		// Insert list of removed events to the serialization buffer.

		const TInt KRemovedEventsCount = removedEvents.Count();

		additResultIds.iEventIds.iPtr.iCount = KRemovedEventsCount;

		if ( KRemovedEventsCount > 0 )

			{

			additResultIds.iEventIds.iPtr.iOffset = buffer->Position();

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