/*

* 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:  Container store containers table implementation.

*

*/

// ========

// INCLUDES

// ========

#include <s32mem.h>  // for descriptor read/write streams

#include "ContainerStoreContainersTable.h"

#include "ContainerStoreDefs.h"

#include "ContainerStoreEncryption.h"

#include "ContainerStoreUtils.h"

#include "PropertiesSerializer.h"

#include "MessageStoreClientServer.h"

// =========

// CONSTANTS

// =========

_LIT( KSelect,               "SELECT " );

_LIT( KComma,                "," );

_LIT( KFrom,                 " FROM " );

_LIT( KWhere,                " WHERE " );

_LIT( KAnd,                  " AND " );

_LIT( KEqualTo,              "=" );

_LIT( KGreaterThanOrEqualTo, ">=" );

_LIT( KLessThanOrEqualTo,    "<=" );

_LIT( KOrderBy,              " ORDER BY ");

_LIT( KAsc,                  " ASC"      );

// ======================

// METHOD IMPLEMENTATIONS

// ======================

// ==========================================================================

// FUNCTION: OpenL

// ==========================================================================

CContainerStoreContainersTable* CContainerStoreContainersTable::OpenL( CContainerStoreUtils&      aUtils,

																	   MCustomBehaviorProvider&   aCustomBehaviorProvider, 

													  				   TUint                      aCountsLength,

													  				   CContainerStoreEncryption& aEncryption )

	{

	CContainerStoreContainersTable* self = new(ELeave) CContainerStoreContainersTable( aUtils, aCustomBehaviorProvider, aCountsLength, aEncryption );

	CleanupStack::PushL( self );

	self->OpenTableL();

	CleanupStack::Pop( self );

	return self;	

	} // end OpenL

// ==========================================================================

// FUNCTION: CreateL

// ==========================================================================

CContainerStoreContainersTable* CContainerStoreContainersTable::CreateL( CContainerStoreUtils&      aUtils,

																	     MCustomBehaviorProvider&   aCustomBehaviorProvider, 

													  				     TUint                      aCountsLength,

													  				     CContainerStoreEncryption& aEncryption  )

	{

	CContainerStoreContainersTable* self = new(ELeave) CContainerStoreContainersTable( aUtils, aCustomBehaviorProvider, aCountsLength, aEncryption );

	CleanupStack::PushL( self );

	self->CreateTableL();

	CleanupStack::Pop( self );

	return self;	

	} // end CreateL

// ==========================================================================

// FUNCTION: Constructor

// ==========================================================================

CContainerStoreContainersTable::CContainerStoreContainersTable( CContainerStoreUtils&      aUtils,

																MCustomBehaviorProvider&   aCustomBehaviorProvider, 

															  	TUint                      aCountsLength,

									  							CContainerStoreEncryption& aEncryption ) :

    CContainerStoreTable( aUtils ),									  							

	iCustomBehaviorProvider( aCustomBehaviorProvider ),

	iCountsLength( aCountsLength ),

	iEncryption( aEncryption )

	{

	__LOG_CONSTRUCT( "msg", "CContainerStoreContainersTable" )

	} // end constructor

// ==========================================================================

// FUNCTION: Destructor

// ==========================================================================

CContainerStoreContainersTable::~CContainerStoreContainersTable()

	{

	iUtils.CloseTable( iTable );

    __LOG_DESTRUCT

	} // end destructor

// ==========================================================================

// FUNCTION: HierarchyL

// ==========================================================================

void CContainerStoreContainersTable::HierarchyL( TContainerId          aId, 

                                                 RArray<TContainerId>& aHierarchy )

	{

	__LOG_ENTER_SUPPRESS( "HierarchyL" )

	aHierarchy.Reset();

	TBool done = EFalse;

	TContainerId currentId = aId;

   	if( !iTable.SeekL( currentId ) )

   	    {

		__LOG_WRITE_ERROR( "container not found" )

		User::Leave( KErrNotFound );    	   	    

   	    } // end if

    // Set a bookmark at the original container, for a quick return.

    TDbBookmark bookmark = iTable.Bookmark();

	aHierarchy.Append( currentId );		

	// Build the hierarchy of the container.

	while( !done )

	    {

    	iTable.GetL();

		TContainerId parentId = iTable.ColUint32( iParentIdColNum );

        switch( parentId )

            {

            case KContainerInvalidId:

        		// Stop when the container has no parent container.

                done = ETrue;

                break;

            case KUncommittedContainers:

                // Stop when the container is uncommitted.

        		aHierarchy.Append( KUncommittedContainers );

                done = ETrue;

                break;

            case KToBeDeletedContainers:

    		    // If the container is the To Be Deleted hierarchy then treat this as a "not found" case.

        		__LOG_WRITE_ERROR( "container is in to be deleted hierarchy" )

		        User::Leave( KErrNotFound );

                break;

            default:

                // Add the parent to the hierarchy.

        		aHierarchy.Append( parentId );

        		// Traverse to the parent entry.

		        if( !iTable.SeekL( parentId ) )

    		        {

            		// This should not happen.  If it has, there are orphaned records in the database.            		

            		__LOG_WRITE8_FORMAT1_ERROR( "orphaned container found %i", parentId )

            		User::Leave( KErrNotFound );    	

            		} // end if

		        break;

            } // end case

		} // end while	

	// Go back to the original container.

    iTable.GotoL( bookmark );    			

	} // end HierarchyL

// ==========================================================================

// FUNCTION: SeekL

// ==========================================================================

void CContainerStoreContainersTable::SeekL( TContainerId          aId, 

                                            RArray<TContainerId>& aHierarchy )

    {

    HierarchyL( aId, aHierarchy );

	} // end SeekL

// ==========================================================================

// FUNCTION: SeekL

// ==========================================================================

void CContainerStoreContainersTable::SeekL( TContainerId aId )

	{

	__LOG_ENTER_SUPPRESS( "SeekL" )

	if( !iTable.SeekL( aId ) )

		{

		__LOG_WRITE_ERROR( "container not found" )

		User::Leave( KErrNotFound );

		} // end if

	iTable.GetL();

	} // end SeekL

// ==========================================================================

// FUNCTION: SeekL

// ==========================================================================

void CContainerStoreContainersTable::SeekL( TContainerId  aId, 

                                            TContainerId& aParentId )

    {

    SeekL( aId );

    iTable.GetL();

    aParentId = iTable.ColUint32( iParentIdColNum );

    } // end SeekL

// ==========================================================================

// FUNCTION: FindL

// ==========================================================================

TContainerId CContainerStoreContainersTable::FindL( const TDesC& aSqlQuery )

	{

	__LOG_ENTER_SUPPRESS( "FindL" )

	__LOG_WRITE_FORMAT1_DEBUG3( "query=%S", &aSqlQuery )

	TContainerId returnValue;

	iTable.FirstL();

	if( iTable.FindL( RDbRowSet::EForwards, aSqlQuery ) == KErrNotFound )

	    {

	    __LOG_WRITE_INFO( "No match found" )

	    returnValue = KContainerInvalidId;

	    }

	else 

	    {

	    iTable.GetL();

	    returnValue = iTable.ColUint32( iIdColNum );

	    } // end if

	return returnValue;	

	} // end FindL

// ==========================================================================

// FUNCTION: GotoL

// ==========================================================================

TContainerId CContainerStoreContainersTable::GotoL( TDbBookmark aBookmark )

    {

    iTable.GotoL( aBookmark );

    iTable.GetL();

    return iTable.ColUint32( iIdColNum );

    } // end GotoL

// ==========================================================================

// FUNCTION: Bookmark

// ==========================================================================

TDbBookmark CContainerStoreContainersTable::Bookmark()

    {

    return iTable.Bookmark();

    } // end Bookmark

// ==========================================================================

// FUNCTION: ParentId

// ==========================================================================

TContainerId CContainerStoreContainersTable::ParentId()

    {

    return iTable.ColUint32( iParentIdColNum );

    } // end ParentId

// ==========================================================================

// FUNCTION: OpenTableL

// ==========================================================================

void CContainerStoreContainersTable::OpenTableL()

	{

	__LOG_ENTER( "OpenTableL" )

	iUtils.OpenTableL( iTable, KContainersTableName );

	// Get the column numbers for the containers table.

	CDbColSet* colSet = iTable.ColSetL();

	CleanupStack::PushL( colSet );

	iIdColNum              = colSet->ColNo( KContainersTableIdCol );

	iParentIdColNum        = colSet->ColNo( KContainersTableParentIdCol );

	iChildrenCountsColNum  = colSet->ColNo( KContainersTableChildrenCountsCol );

	iChildrenCountColNum   = colSet->ColNo( KContainersTableChildrenCountCol );

	iPropertiesColNum      = colSet->ColNo( KContainersTablePropertiesCol );

	iQuickPropertiesColNum = colSet->ColNo( KContainersTableQuickPropertiesCol );

	iCountsColNum          = colSet->ColNo( KContainersTableCountsCol );

    iIsRowEncryptedColNum  = colSet->ColNo( KContainersTableIsRowEncryptedCol );

	CleanupStack::PopAndDestroy( colSet );

	// Set the table's index to the ID index.

	User::LeaveIfError( iTable.SetIndex( KContainersTableIdIndex ) );

	__LOG_EXIT

	} // end OpenTableL

// ==========================================================================

// FUNCTION: CreateTableL

// ==========================================================================

void CContainerStoreContainersTable::CreateTableL()

	{

	__LOG_ENTER( "CreateContainersTableL" )

	// Create table columns

	CDbColSet* colSet = CDbColSet::NewLC();

	TDbCol idCol( KContainersTableIdCol, EDbColUint32 );

	colSet->AddL( idCol );	

	TDbCol parentIdCol( KContainersTableParentIdCol, EDbColUint32 );

	colSet->AddL( parentIdCol );	

	TDbCol childrenCountCol( KContainersTableChildrenCountCol, EDbColUint16 );

	colSet->AddL( childrenCountCol );	

	TDbCol childrenCountsCol( KContainersTableChildrenCountsCol, EDbColBinary, iCountsLength );

	colSet->AddL( childrenCountsCol );	

	TDbCol propertiesCol( KContainersTablePropertiesCol, EDbColLongBinary );

	colSet->AddL( propertiesCol );	

	TDbCol quickPropertiesCol( KContainersTableQuickPropertiesCol, EDbColLongBinary );

	colSet->AddL( quickPropertiesCol );	

	TDbCol countsCol( KContainersTableCountsCol, EDbColBinary, iCountsLength );

	colSet->AddL( countsCol );	

    TDbCol isEncryptedCol( KContainersTableIsRowEncryptedCol, EDbColUint8 );

    colSet->AddL( isEncryptedCol );  

	// Create table.

	iUtils.CreateTableL( KContainersTableName, *colSet );

	CleanupStack::PopAndDestroy( colSet );

	// Create table index.

    CreateIndexL( KContainersTableName, KContainersTableIdIndex, KContainersTableIdCol );

	OpenTableL();

	__LOG_EXIT	

	} // end CreateTableL

// ==========================================================================

// FUNCTION: WritePropertiesColumnL

// ==========================================================================

void CContainerStoreContainersTable::WritePropertiesColumnL( const TDesC8& aProperties )

    {	

    __LOG_ENTER_SUPPRESS( "WritePropertiesColumnL" )

    if( aProperties.Length() > 0 )

        {

        if ( IsEncrypted() )

            {

            EncryptAndWritePropertiesColumnL( aProperties );

            }

        else

            {

            WriteUnencryptedPropertiesColumnL( aProperties );

            }

        }

    else

        {

        iTable.SetColNullL( iPropertiesColNum );

        } // end if

    } // end WritePropertiesColumnL

// ==========================================================================

// FUNCTION: ReadPropertiesColumnL

// ==========================================================================

void CContainerStoreContainersTable::ReadPropertiesColumnL( RBuf8& aProperties )

    {

    __LOG_ENTER_SUPPRESS( "ReadPropertiesColumnL" )

    if ( IsEncrypted() )

        {

        ReadAndDescrptPropertiesColumnL( aProperties );

        }

    else

        {

        ReadUnencryptedPropertiesColumnL( aProperties );

        }

    } // end ReadPropertiesColumnL

// ==========================================================================

// FUNCTION: CreateContainerL

// ==========================================================================

void CContainerStoreContainersTable::CreateContainerL( TContainerId  aId,

                                                       TContainerId  aParentId,

											           const TDesC8& aProperties,

											           RBuf8&        aQuickProperties )

	{

	__LOG_ENTER_SUPPRESS( "CreateContainerL" )

	RBuf8 countsBuf;

	CleanupClosePushL( countsBuf );

	countsBuf.CreateL( iCountsLength );

	iCustomBehaviorProvider.InitializeCounts( countsBuf );

	// Insert an entry in the folders table.

	iTable.LastL();

	InsertRowLC();

	iTable.SetColL( iIdColNum,             aId );

	iTable.SetColL( iParentIdColNum,       aParentId );

	iTable.SetColL( iChildrenCountColNum,  0 );

	iTable.SetColL( iChildrenCountsColNum, countsBuf );

    iTable.SetColL( iIsRowEncryptedColNum, static_cast<TUint8>( iEncryption.IsEncryptionOn() ) );

    WritePropertiesColumnL( aProperties );

    // Add the type bits to the assigned ID.

	TUint type = aId & KContainerTypeMask;

	UpdateQuickPropertiesAndCountsL( type, aProperties, aQuickProperties, countsBuf );

	_LIT( KMyCounts, "myCounts" );

    iCustomBehaviorProvider.LogCounts( KMyCounts, countsBuf );

	PutRowUpdatesL();

	if( aParentId != KUncommittedContainers && aParentId != KContainerInvalidId )

	    {

	    SeekL( aParentId );

	    IncrementParentCountsL( countsBuf );				    	    

	    } // end if

	CleanupStack::PopAndDestroy( &countsBuf );

	} // end CreateContainerL

// ==========================================================================

// FUNCTION: IncrementParentCountsL

// ==========================================================================

void CContainerStoreContainersTable::IncrementParentCountsL( const TDesC8& aCountsDelta )

	{	

	__LOG_ENTER_SUPPRESS( "IncrementParentCountsL" )

	PrepareRowForUpdateLC();

	// Read old values.

	TUint16 childrenCount = iTable.ColUint16( iChildrenCountColNum );

	RBuf8 countsBuf;

	CleanupClosePushL( countsBuf );

	countsBuf.CreateL( iTable.ColDes8( iChildrenCountsColNum ) );

	_LIT( KOldChildrenCounts, "oldChildrenCounts" );

    iCustomBehaviorProvider.LogCounts( KOldChildrenCounts, countsBuf );

	// Update values.

	childrenCount++;

	iCustomBehaviorProvider.IncrementParentCounts( countsBuf, aCountsDelta );

    _LIT( KNewChildrenCounts, "newChildrenCounts" );

    iCustomBehaviorProvider.LogCounts( KNewChildrenCounts, countsBuf );

	// Write new values to database.	

	iTable.SetColL( iChildrenCountColNum, childrenCount );

	iTable.SetColL( iChildrenCountsColNum, countsBuf );

	CleanupStack::PopAndDestroy( &countsBuf );

	PutRowUpdatesL();

	} // end IncrementParentCountsL	

// ==========================================================================

// FUNCTION: DecrementParentCountsL

// ==========================================================================

void CContainerStoreContainersTable::DecrementParentCountsL( const TDesC8& aCountsDelta )

	{

	__LOG_ENTER_SUPPRESS( "DecrementParentCountsL" )

	PrepareRowForUpdateLC();

	// Read old values.

	TUint16 childrenCount = iTable.ColUint16( iChildrenCountColNum );

	RBuf8 countsBuf;

	CleanupClosePushL( countsBuf );

	countsBuf.CreateL( iTable.ColDes8( iChildrenCountsColNum ) );

	_LIT( KOldChildrenCounts, "oldChildrenCounts" );

    iCustomBehaviorProvider.LogCounts( KOldChildrenCounts, countsBuf );

	// Update values.

	childrenCount--;

	iCustomBehaviorProvider.DecrementParentCounts( countsBuf, aCountsDelta );

	_LIT( KNewChildrenCounts, "newChildrenCounts" );

    iCustomBehaviorProvider.LogCounts( KNewChildrenCounts, countsBuf );

	// Write new values to database.	

	iTable.SetColL( iChildrenCountColNum, childrenCount );

	iTable.SetColL( iChildrenCountsColNum, countsBuf );

	CleanupStack::PopAndDestroy( &countsBuf );

	PutRowUpdatesL();

	} // end DecrementParentCountsL	

// ==========================================================================

// FUNCTION: UpdateQuickPropertiesAndCountsL

// ==========================================================================

void CContainerStoreContainersTable::UpdateQuickPropertiesAndCountsL( TContainerId  aType,

															 		  const TDesC8& aProperties,

															 		  RBuf8&        aQuickProperties,

															 		  TDes8&        aCounts )

	{

	__LOG_ENTER_SUPPRESS( "UpdateQuickPropertiesAndCountsL" )