/*

* Copyright (c) 2002-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:  Add, update and remove items in DB.

*                 Basic DB manipulation engine.

*

*/

#include "mdssqlobjectmanipulate.h"

#include "mdcitem.h"

#include "mdsdbconnectionpool.h"

#include "mdssqliteconnection.h"

#include "mdsfindsqlclausedef.h"

#include "mdsschema.h"

#include "mdsnamespacedef.h"

#include "mdsobjectdef.h"

#include "mdspropertydef.h"

#include "mdsclausebuffer.h"

#include "mdsobjectlocklist.h"

#include "mdsindexer.h"

#include "mdspreferences.h"

#include "mdslogger.h"

#include "mdcserializationbuffer.h"

#include "mdssqldbmaintenance.h"

#include "mdcresult.h"

#include "mdeinternalerror.h"

#include "mdsgetimeiao.h"

#include <e32math.h>

#include <mdeobject.h>

/** logging instance */

__USES_LOGGER

const TInt KMaxBuffers = 5;

_LIT( KMemoryCard, "MC" );

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

// CLASS      CMdSSqlObjectManipulate

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

CMdSIdentifierGenerator* CMdSIdentifierGenerator::NewL( )

    {

    CMdSIdentifierGenerator* self = CMdSIdentifierGenerator::NewLC( );

    CleanupStack::Pop( self );

    return self;

    }

CMdSIdentifierGenerator* CMdSIdentifierGenerator::NewLC( )

    {

    CMdSIdentifierGenerator* self = new ( ELeave ) CMdSIdentifierGenerator( );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

CMdSIdentifierGenerator::~CMdSIdentifierGenerator()

    {

    delete iDigest;

    iDigest = NULL;

    }

void CMdSIdentifierGenerator::ConstructL( )

    {

    CMdsGetImeiAO * imeigetter = CMdsGetImeiAO::NewLC();

    iImei = imeigetter->GetIMEI();

    TTime uTime;

    uTime.UniversalTime();

    TInt64 intTime = uTime.Int64();

    TUint32 rand = Math::Rand( intTime );

    iImei ^= (TInt64)(rand & 0xFF000000) << ( sizeof( TUint32 ) * 8 );

    CleanupStack::PopAndDestroy(imeigetter);

    iLastTime = 0;

    iDigest = CMessageDigestFactory::NewDigestL( CMessageDigest::EMD5 );

    }

void CMdSIdentifierGenerator::GenerateGuid( TInt64& aGuidHigh, TInt64& aGuidLow )

	{

	if (aGuidHigh == 0 && aGuidLow == 0)

		{

		TTime currTime;

		currTime.UniversalTime();

		const TInt64 tickCount = currTime.Int64();

		if (iLastTime < tickCount)

			{

			iLastTime = tickCount;

			}

		else

			{

			++iLastTime;

			}

		//MD5 hash GUID

		const TInt64 KXorImei = I64LIT( 0x2C3E773D1A25916E );

		const TInt64 xorImei = iImei ^ KXorImei;

		const TInt KMaxQuidLength = 16;

		TBuf8<KMaxQuidLength> message;

		message.SetLength( KMaxQuidLength );

		Mem::Copy( (TAny*)( message.Ptr() ), &xorImei, sizeof( TInt64 ) );

		Mem::Copy( (TAny*)( message.Ptr() + sizeof( TInt64 ) ), &iLastTime, sizeof( TInt64 ) );

		TPtrC8 hash = iDigest->Final( message );

		__ASSERT_DEBUG( hash.Size() >= KMaxQuidLength, User::Panic( _L("CMdSIdentifierGenerator::GenerateGuid"), KErrGeneral ) );

		Mem::Copy( &aGuidHigh, hash.Ptr(), sizeof( TInt64 ) );

		Mem::Copy( &aGuidLow, hash.Ptr() + sizeof( TInt64 ), sizeof( TInt64 ) );

		//MD5 hash GUID end

		}

	}

HBufC* CMdSIdentifierGenerator::GenerateUriL( const CMdsObjectDef& aObjectDef, 

		const TInt64& aGuidHigh, const TInt64& aGuidLow ) const

	{

	_LIT( KDot, "." );

	HBufC* uri = HBufC::NewLC( aObjectDef.GetName().Length() + 2 /*two dots*/+ 

			2*KMaxUint64ValueLength );

	TPtr uriPtr( uri->Des() );

	uriPtr.Append( aObjectDef.GetName() );

	uriPtr.Append( KDot );

	uriPtr.AppendNum( aGuidHigh );

	uriPtr.Append( KDot );

	uriPtr.AppendNum( aGuidLow );

	CleanupStack::Pop( uri );

	return uri;

	}

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

// CLASS      CMdSSqlObjectManipulate

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

CMdSSqlObjectManipulate* CMdSSqlObjectManipulate::NewL( 

		const CMdsSchema& aSchema, CMdSObjectLockList& aLockList )

    {

    CMdSSqlObjectManipulate* self = CMdSSqlObjectManipulate::NewLC( aSchema, 

    		aLockList );

    CleanupStack::Pop( self );

    return self;

    }

CMdSSqlObjectManipulate* CMdSSqlObjectManipulate::NewLC( 

		const CMdsSchema& aSchema, CMdSObjectLockList& aLockList )

    {

    CMdSSqlObjectManipulate* self = new ( ELeave ) CMdSSqlObjectManipulate( 

    		aSchema, aLockList );

    CleanupStack::PushL( self );

    self->ConstructL( );

    return self;

    }

CMdSSqlObjectManipulate::~CMdSSqlObjectManipulate()

    {

    // doesn't own namespace definition

	iNamespaceDef = NULL;

	const TInt count = iBuffers.Count();

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

		{

		delete iBuffers[i].iBuffer;

		iBuffers[i].iBuffer = NULL;

		}

	iBuffers.Close();

	delete iGenerator;

	iGenerator = NULL;

	delete iUri;

	iUri = NULL;

    }

CMdSSqlObjectManipulate::CMdSSqlObjectManipulate( const CMdsSchema& aSchema, 

		CMdSObjectLockList& aLockList )

	: iSchema( aSchema ), iGenerator(NULL), iLockList( aLockList ) 

    {

    }

void CMdSSqlObjectManipulate::ConstructL( )

    {

	iGenerator = CMdSIdentifierGenerator::NewL();

	iNamespaceDef = NULL;

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

		{

	    TLockBuffer lockBuffer;

	    lockBuffer.iLock = EFalse;

	    lockBuffer.iBuffer = CMdsClauseBuffer::NewLC( 1024 );

		iBuffers.AppendL( lockBuffer );

		CleanupStack::Pop(); // buffer

		}

    }

TBool CMdSSqlObjectManipulate::GarbageCollectionL()

	{

	return DoGarbageCollectionL();

	}

void CMdSSqlObjectManipulate::SetNamespace( 

		const CMdsNamespaceDef* aNamespaceDef )

	{

	iNamespaceDef = aNamespaceDef;

	}

void CMdSSqlObjectManipulate::AddMemoryCardL(TUint32 aMediaId)

	{

	TTime currentTime;

	currentTime.UniversalTime();

	TInt modifiedRowCount = MMdsPreferences::UpdateL( KMemoryCard, 

			MMdsPreferences::EPreferenceExtraSet, aMediaId, 

			currentTime.Int64() );

	if( modifiedRowCount <= 0 )

		{

		MMdsPreferences::InsertL( KMemoryCard, 

								  MMdsPreferences::EPreferenceBothSet, 

								  aMediaId, currentTime.Int64() );

		}

	}

void CMdSSqlObjectManipulate::GetMemoryCardL(TUint32& aMediaId)

	{

	TInt rowCount = MMdsPreferences::GetL( KMemoryCard, 

										   MMdsPreferences::EPreferenceValueGet | MMdsPreferences::EPreferenceExtraSortDesc, 

								  		   aMediaId );

	// if no rows found leave

	if( rowCount <= 0 )

		{

		User::Leave( KErrNotFound );

		}

	}

TBool CMdSSqlObjectManipulate::CheckMemoryCardL(TUint32 aMediaId)

	{

	TInt rowCount = MMdsPreferences::GetL( KMemoryCard, 

										   MMdsPreferences::EPreferenceValueGet | MMdsPreferences::EPreferenceValueSet, 

								  		   aMediaId );

	if( rowCount > 0 )

		{

		return ETrue;

		}

	return EFalse;

	}

void CMdSSqlObjectManipulate::SetMediaL(TUint32 aMediaId, TChar aDrive,

		TBool aPresentState)

	{

	_LIT( KInsertMedia, "INSERT OR REPLACE INTO MdS_Medias VALUES(?,?,?,?);" );

	RClauseBuffer commonClause( *this, KInsertMedia.iTypeLength );

	CleanupClosePushL( commonClause );

	CMdsClauseBuffer& clauseBuffer = commonClause.BufferL();

	clauseBuffer.BufferL() = KInsertMedia;

	TTime currentTime;

	currentTime.UniversalTime();

	const TInt64 currentTime64 = currentTime.Int64();

    RRowData var;

    CleanupClosePushL( var );

    var.ReserveL( 4 ); // reserve space for media ID, drive, present state and time

    var.AppendL( TColumn( aMediaId ) );

    var.AppendL( TColumn( (TInt32)aDrive ) );

    var.AppendL( TColumn( aPresentState ) );

    var.AppendL( TColumn( currentTime64 ) );

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

	connection.ExecuteL( clauseBuffer.ConstBufferL(), var );

	CleanupStack::PopAndDestroy( 2, &commonClause ); // var, commonClauseOne

	}

TBool CMdSSqlObjectManipulate::GetMediaL(TUint32 aMediaId, TChar& aDrive, 

		TBool& aPresentState)

	{

	_LIT( KGetMedia, "SELECT Drive, PresentState FROM MdS_Medias WHERE MediaId=?;" );

	RClauseBuffer commonClause( *this, KGetMedia.iTypeLength );

	CleanupClosePushL( commonClause );

	CMdsClauseBuffer& clauseBuffer = commonClause.BufferL();

	clauseBuffer.BufferL() = KGetMedia;

    RRowData var;

    CleanupClosePushL( var );

    var.AppendL( TColumn( aMediaId ) );

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

	RMdsStatement statement;

	CleanupClosePushL( statement );

	connection.ExecuteQueryL( clauseBuffer.ConstBufferL(), statement, var );

	var.Free();

	var.Reset();

	TInt32 drive = 0;

    var.ReserveL( 2 ); // reserve space for drive and present state

	var.AppendL( TColumn( drive ) );

	var.AppendL( TColumn( aPresentState ) );

	TBool found = EFalse;

	if( connection.NextRowL( statement, var ) )

		{

		var.Column( 0 ).Get( drive );

		var.Column( 1 ).Get( aPresentState );

		aDrive = drive;

		found = ETrue;

		}

	CleanupStack::PopAndDestroy( 3, &commonClause ); // statement, var, commonClauseOne

	return found;

	}

TInt32 CMdSSqlObjectManipulate::GetPresentMediasL(TDes8& aMediaInfoBuffer)

	{

	_LIT( KGetPresentMedias, "SELECT MediaId, Drive FROM MdS_Medias WHERE PresentState!=?;" );

	RClauseBuffer commonClause( *this, KGetPresentMedias.iTypeLength );

	CleanupClosePushL( commonClause );

	CMdsClauseBuffer& clauseBuffer = commonClause.BufferL();

	clauseBuffer.BufferL() = KGetPresentMedias;

	const TBool notPresentState = EFalse;

    RRowData var;

    CleanupClosePushL( var );

    var.AppendL( TColumn( notPresentState ) );

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

	RMdsStatement statement;

	CleanupClosePushL( statement );

	connection.ExecuteQueryL( clauseBuffer.ConstBufferL(), statement, var );

	var.Free();

	var.Reset();

	TUint32 mediaId = 0;

	TInt32 drive = 0;

    var.ReserveL( 2 ); // reserve space for drive and present state

	var.AppendL( TColumn( mediaId ) );

	var.AppendL( TColumn( drive ) );

	TInt32 count = 0;

	TInt bufferPosition = 0;

	const TInt lastBufferPosition = aMediaInfoBuffer.MaxSize() - sizeof( TMdEMediaInfo );

	const TUint8* aMediaInfoBufferPtr = aMediaInfoBuffer.Ptr();

	while( connection.NextRowL( statement, var ) )

		{

		var.Column( 0 ).Get( mediaId );

		var.Column( 1 ).Get( drive );

		TMdEMediaInfo mediaInfo;

		mediaInfo.iMediaId = mediaId;

		mediaInfo.iDrive = drive;

		if( bufferPosition > lastBufferPosition )

			{

			User::Leave( KErrBadDescriptor );

			}

		TUint8* ptr = (TUint8*)( aMediaInfoBufferPtr + bufferPosition );

		Mem::Copy( ptr, &mediaInfo, sizeof( TMdEMediaInfo ) );

		bufferPosition += sizeof( TMdEMediaInfo );

		++count;

		}

	aMediaInfoBuffer.SetLength( bufferPosition );

	CleanupStack::PopAndDestroy( 3, &commonClause ); // statement, var, commonClauseOne

	return count;

	}

TItemId CMdSSqlObjectManipulate::SearchNotPresentFileL(TUint32 aMediaId, 

		TDesC16& aUri, TMdSFileInfo& aFileInfo,

		TFilePresentStates& aPlaceHolder, TBool& aNotPresentState)

	{

	_LIT( KSearchNotPresentFile, "SELECT ObjectId, Flags, LastModifiedDate, Size FROM Object%u WHERE NOT Flags&? AND (Flags&? OR Flags&? OR Flags&? ) AND MediaId=? AND URI=?;" );

	RClauseBuffer commonClauseOne(*this, KSearchNotPresentFile.iTypeLength + KMaxUintValueLength);

	CleanupClosePushL( commonClauseOne );

	CMdsClauseBuffer& clauseBuffer = commonClauseOne.BufferL();

	clauseBuffer.BufferL().Format( KSearchNotPresentFile, KDefaultNamespaceDefId );

	TItemId objectId = KNoId;

	TUint32 flags = 0;

    RRowData var;

    CleanupClosePushL( var );

    var.ReserveL( 6 );

    var.AppendL( TColumn( EMdEObjectFlagRemoved ) );

    var.AppendL( TColumn( EMdEObjectFlagNotPresent ) ); // not present flag

    var.AppendL( TColumn( EMdEObjectFlagStartUpNotPresent ) ); // start up not present flag

    var.AppendL( TColumn( EMdeObjectFlagPending ) ); // pending for composing - needed to complete composing

    var.AppendL( TColumn( aMediaId ) );

    var.AppendL( TColumn( aUri ) );

    CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();

	RMdsStatement statement;

	CleanupClosePushL( statement );

    connection.ExecuteQueryL( clauseBuffer.ConstBufferL(), statement, var );

    TInt64 modifiedTime(0);

    TUint32 size(0);

    RRowData result;

    CleanupClosePushL( result );

    result.ReserveL( 4 );

    result.AppendL( TColumn( objectId ) );

    result.AppendL( TColumn( flags ) );

    result.AppendL( TColumn( modifiedTime ) );

    result.AppendL( TColumn( size ) );

    // default values (used if object doesn't exist)

	aPlaceHolder = EMdsNotFound;

	aNotPresentState = EFalse;

	if( connection.NextRowL( statement, result ) )

		{

		result.Column( 0 ).Get( objectId );

		result.Column( 1 ).Get( flags );

		if ( flags & EMdEObjectFlagPlaceholder )

			{

			aPlaceHolder = EMdsPlaceholder;

			}

		else

			{

			result.Column( 2 ).Get( modifiedTime );

			result.Column( 3 ).Get( size );

			// check if file is modified

    		if ( ( aFileInfo.iModifiedTime == modifiedTime ) && ( aFileInfo.iSize == size ) )

    			{

    			aPlaceHolder = EMdsNormal;

    	        // If images were pending for composing, composer needs to be notified for the composing to complete 

    	        if( (flags & EMdeObjectFlagPending) && (flags & EMdEObjectFlagStartUpNotPresent) )

    	            {

    	            aNotPresentState = ETrue;

    	            }

    			}

    		else

    			{

    			aPlaceHolder = EMdsModified;

    			}

			}

		if( flags & EMdEObjectFlagNotPresent )

			{

			aNotPresentState = ETrue;

			}

		}

	CleanupStack::PopAndDestroy( &result );

	CleanupStack::PopAndDestroy( &statement );

	CleanupStack::PopAndDestroy( &var );

	CleanupStack::PopAndDestroy( &commonClauseOne );

	return objectId;

	}

void CMdSSqlObjectManipulate::SetFilesToPresentL(const RArray<TItemId>& aObjectIds)

	{

	const TInt objectCount = aObjectIds.Count();

    if ( objectCount > 0 )

    	{

		_LIT( KSetFileToPresent, "UPDATE Object%u SET Flags=Flags&? WHERE (Flags&?)<>0 AND ObjectId IN (?" );

		_LIT( KCommaQuestionmark, ",?");

		_LIT( KBracketSemicolon, ");");

		RClauseBuffer commonClauseOne(*this, KSetFileToPresent.iTypeLength + KMaxUintValueLength +

				( KCommaQuestionmark.iTypeLength * ( objectCount-1 ) ) +

				KBracketSemicolon.iTypeLength );

		CleanupClosePushL( commonClauseOne );

		CMdsClauseBuffer& clauseBuffer = commonClauseOne.BufferL();

		clauseBuffer.BufferL().Format( KSetFileToPresent, KDefaultNamespaceDefId );

	    RRowData var;

	    var.ReserveL( 3 );

	    CleanupClosePushL( var );

	    // reset not present and start up not present flags

	    var.AppendL( TColumn( ~(EMdEObjectFlagNotPresent | EMdEObjectFlagStartUpNotPresent) ) );

	    var.AppendL( TColumn( (EMdEObjectFlagNotPresent | EMdEObjectFlagStartUpNotPresent) ) );

	    var.AppendL( TColumn( aObjectIds[0] ) );

	    for ( TInt i = 1; i < objectCount; i++ )

	    	{

	    	clauseBuffer.AppendL( KCommaQuestionmark );

		    var.AppendL( TColumn( aObjectIds[i] ) );