/*

* 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"

__USES_LOGGER

// ======== LOCAL FUNCTIONS ========

static void TransactionCleanupL(void* aConn)

   {

   CMdSSqLiteConnection* conn = (CMdSSqLiteConnection*)aConn;

   conn->TransactionRollbackL();

   }

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

// 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);

		if( KObjectCount > 1 )

		    {

	        RMdSTransaction transaction( connection );

	        CleanupClosePushL(transaction);

	        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 );

				    }

			    else

				    {

				    aResultBuffer.InsertL( KNoId );

				    if(resultIds.iErrorCode == KErrNone)

					    {

					    resultIds.iErrorCode = err;

					    }

				    }

			    }

		    if( beginError == KErrNone )

		        {

	            transaction.CommitL();

	            CleanupStack::PopAndDestroy( &transaction );

		        }

		    }

		else

		    {

            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 );

                    }

                else

                    {

                    aResultBuffer.InsertL( KNoId );

                    if(resultIds.iErrorCode == KErrNone)

                        {

                        resultIds.iErrorCode = err;

                        }

                    }

                }

		    }

        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;

	    if( KEventCount > 1 )

	        {

	        //More than 1 event, transaction will be used.

	        connection.TransactionBeginL();

	        CleanupStack::PushL(TCleanupItem(&TransactionCleanupL, &connection));

	        }

		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( KEventCount > 1 )

		    {

		    connection.TransactionCommitL();

		    CleanupStack::Pop();  //TransactionCleanup()

	        }

		}

	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;

	    if( KRelationCount > 1 )

	        {

	        //More than 1 relation, transaction will be used.

	        connection.TransactionBeginL();

	        CleanupStack::PushL(TCleanupItem(&TransactionCleanupL, &connection));

	        }

	    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( KRelationCount > 1 )

	        {

	        connection.TransactionCommitL();

	        CleanupStack::Pop();   //TransactionCleanup()

	        }

		}

	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 );

	}

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

// 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 );

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

    // 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 );

			}

		else

			{

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

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

					idArray, removedRelations, removedEvents );

			}

	    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 );

	// notify about items removed

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

	if (notify)

		{

		iNotifier.NotifyRemovedL( aResultBuffer, EFalse );

		}

	// 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 )

				{

				buffer->InsertL( removedEvents[i] );

				}

			}

		else

			{

			additResultIds.iEventIds.iPtr.iOffset = KNoOffset;

			}

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

		const TInt KRemovedRelationsCount = removedRelations.Count();

		additResultIds.iRelationIds.iPtr.iCount = KRemovedRelationsCount;

		if ( KRemovedRelationsCount > 0 )

			{

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

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

				{

				buffer->InsertL( removedRelations[i] );