/*

* 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 sorting table implementation.

*

*/

#include "ContainerStoreSortingTable.h"

#include "msgstoretypes.h"

#include "MessageStoreClientServer.h"

#include "ContainerStoreDefs.h"

#include "MsgStoreSortResultRowSet.h"

#include "MsgStoreStringSortResultRowSet.h"

#include "ContainerStoreUtils.h"

#include "ContainerStoreEncryption.h"

#include "MsgStoreInMemorySortRowSet.h"

_LIT( KSelect,  "SELECT "   );

_LIT( KDelete,  "DELETE "   );

_LIT( KFrom,    " FROM "    );

_LIT( KWhere,   " WHERE "   );

_LIT( KEquals,  " = "       );

_LIT( KOrderBy, " ORDER BY ");

_LIT( KComma,   ", "        );

_LIT( KAsc,     " ASC"      );

_LIT( KDesc,    " DESC"     );

_LIT( KStar,    "* "        );

const TUint KQuerryBufSize = 200;

const TUint KQuerrySizeSmall = 60;

enum TMsgStorePriorityScore

	{

	EPriorityScoreLow    = -10,

	EPriorityScoreNormal =   0,

	EPriorityScoreHigh   =  10

	};

    enum TMsgStoreReadScore

        {

        EReadScoreUnread     = 0,

        EReadScoreRead       = 1,

        EReadScoreReadLocal  = 2,

        EReadScoreReadBoth   = 3

        };

    enum TMsgStoreFlagStatusScore

    	{

    	EFlagStatusScoreNone             = 0,

    	EFlagStatusScoreFollowUpComplete = 10,

    	EFlagStatusScoreFollowUp         = 20 

    	};

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

// CLASS: CContainerStoreSortingTable

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

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

// FUNCTION: OpenL

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

CContainerStoreSortingTable* CContainerStoreSortingTable::OpenL( CContainerStoreUtils&        aUtils,

                                                                 CContainerStoreEncryption&   aEncryption,

                                                                 MSortingTableObserver&       aObserver )

	{

	CContainerStoreSortingTable* self = new(ELeave) CContainerStoreSortingTable( aUtils, aEncryption, aObserver );

	CleanupStack::PushL( self );

	self->OpenTableL();

	CleanupStack::Pop( self );

	return self;

	}

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

// FUNCTION: CreateL

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

CContainerStoreSortingTable* CContainerStoreSortingTable::CreateL( CContainerStoreUtils&        aUtils,

                                                                   CContainerStoreEncryption&   aEncryption,

                                                                   MSortingTableObserver&       aObserver )

	{

	CContainerStoreSortingTable* self = new(ELeave) CContainerStoreSortingTable( aUtils, aEncryption, aObserver );

	CleanupStack::PushL( self );

	self->CreateTableL();

	CleanupStack::Pop( self );

	return self;

	}

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

// FUNCTION: Constructor

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

CContainerStoreSortingTable::CContainerStoreSortingTable( CContainerStoreUtils&        aUtils,

                                                          CContainerStoreEncryption&   aEncryption,

                                                          MSortingTableObserver&       aObserver )

: CContainerStoreTable( aUtils ), iEncryption( aEncryption ), iObserver( aObserver )

	{

	__LOG_CONSTRUCT( "msg", "CContainerStoreSortingTable" )

	__LOG_CLOSE_BETWEEN_WRITES

	} // end constructor

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

// FUNCTION: Destructor

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

CContainerStoreSortingTable::~CContainerStoreSortingTable()

	{

	iUtils.CloseTable( iTable );

    iEncryptedBuffer.Close();

	__LOG_DESTRUCT	

	} // end destructor

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

// FUNCTION: OpenTableL

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

void CContainerStoreSortingTable::OpenTableL()

	{

	__LOG_ENTER( "OpenTableL" )

	iUtils.OpenTableL( iTable, KSortingTableName );

	// Get the column numbers for the containers table.

	CDbColSet* colSet = iTable.ColSetL();

	CleanupStack::PushL( colSet );

    iMessageIdColNum      = colSet->ColNo( KSortingTableMessageIdCol );

    iFolderIdColNum       = colSet->ColNo( KSortingTableFolderIdCol );

    iMailBoxIdColNum      = colSet->ColNo( KSortingTableMailBoxIdCol );

    iReceivedDateColNum   = colSet->ColNo( KSortingTableReceivedDateCol );

    iReadUnreadColNum     = colSet->ColNo( KSortingTableReadUnreadCol );

    iPriotiryColNum       = colSet->ColNo( KSortingTablePriorityCol );

    iFlagStatusColNum     = colSet->ColNo( KSortingTableFlagStatusCol );

    iSizeColNum           = colSet->ColNo( KSortingTableSizeCol );

    iAttachmentFlagColNum = colSet->ColNo( KSortingTableAttachmentFlagCol );

    iFromColNum           = colSet->ColNo( KSortingTableFromCol );

    iToColNum             = colSet->ColNo( KSortingTableToCol );

    iSubjectColNum        = colSet->ColNo( KSortingTableSubjectCol );

    iIsEncryptedColNum    = colSet->ColNo( KSortingTableIsEncryptedCol );

	CleanupStack::PopAndDestroy( colSet );

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

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

	__LOG_EXIT	

	}

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

// FUNCTION: CreateTableL

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

void CContainerStoreSortingTable::CreateTableL()

	{

	__LOG_ENTER( "CreateTableL" )

	// Create table columns

	CDbColSet* colSet = CDbColSet::NewLC();

	TDbCol msgIdCol( KSortingTableMessageIdCol, EDbColUint32 );

	colSet->AddL( msgIdCol );	

	TDbCol folderIdCol( KSortingTableFolderIdCol, EDbColUint32 );

	colSet->AddL( folderIdCol );	

	TDbCol mailboxIdCol( KSortingTableMailBoxIdCol, EDbColUint32 );

	colSet->AddL( mailboxIdCol );	

	TDbCol receivedDateCol( KSortingTableReceivedDateCol, EDbColInt64 );

	colSet->AddL( receivedDateCol );	

	TDbCol readUnreadCol( KSortingTableReadUnreadCol, EDbColInt8 );

	colSet->AddL( readUnreadCol );	

	TDbCol priorityCol( KSortingTablePriorityCol, EDbColInt8 );

	colSet->AddL( priorityCol );	

	TDbCol flagStatusCol( KSortingTableFlagStatusCol, EDbColInt8 );

	colSet->AddL( flagStatusCol );	

	TDbCol sizeCol( KSortingTableSizeCol, EDbColUint32 );

	colSet->AddL( sizeCol );	

	TDbCol attCol( KSortingTableAttachmentFlagCol, EDbColInt8 );

	colSet->AddL( attCol );	

    TDbCol fromCol( KSortingTableFromCol, EDbColLongBinary );

    colSet->AddL( fromCol );

    TDbCol toCol( KSortingTableToCol, EDbColLongBinary );

    colSet->AddL( toCol );  

    TDbCol subjectCol( KSortingTableSubjectCol, EDbColLongBinary );

    colSet->AddL( subjectCol );  

    TDbCol encryptedCol( KSortingTableIsEncryptedCol, EDbColUint8 );

    colSet->AddL( encryptedCol );  

	// Create table.

	iUtils.CreateTableL( KSortingTableName, *colSet );

	CleanupStack::PopAndDestroy( colSet );

	CreateIndexL( KSortingTableName, KSortingTableMessageIdIndex,      KSortingTableMessageIdCol    );

	CreateIndexL( KSortingTableName, KSortingTableFolderIdIndex,       KSortingTableFolderIdCol     );

    CreateIndexL( KSortingTableName, KSortingTableMailBoxIdIndex,      KSortingTableMailBoxIdCol    );

	CreateIndexL( KSortingTableName, KSortingTableReceivedDateIndex,   KSortingTableReceivedDateCol );

	CreateIndexL( KSortingTableName, KSortingTableReadUnreadIndex,     KSortingTableReadUnreadCol,     KSortingTableReceivedDateCol );

	CreateIndexL( KSortingTableName, KSortingTablePriorityIndex,       KSortingTablePriorityCol,       KSortingTableReceivedDateCol );

	CreateIndexL( KSortingTableName, KSortingTableFlagStatusIndex,     KSortingTableFlagStatusCol,     KSortingTableReceivedDateCol );

	CreateIndexL( KSortingTableName, KSortingTableSizeIndex,           KSortingTableSizeCol,           KSortingTableReceivedDateCol );

	CreateIndexL( KSortingTableName, KSortingTableAttachmentFlagIndex, KSortingTableAttachmentFlagCol, KSortingTableReceivedDateCol );

	OpenTableL();

	__LOG_EXIT

	}

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

// FUNCTION: AddMessageL

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

void CContainerStoreSortingTable::AddMessageL( TContainerId             aMessageId, 

											   TContainerId             aFolderId, 

											   TContainerId             aMailboxId, 

                                               RMsgStoreSortableFields& aSortableFields )

	{

	__LOG_ENTER_SUPPRESS( "AddMessageL" )

	__LOG_WRITE8_FORMAT3_DEBUG3( "msgId=%x, folderId=%x, mailBoxId=%x", aMessageId, aFolderId, aMailboxId )

	iTable.LastL();

	InsertRowLC();

	iTable.SetColL( iMessageIdColNum,    aMessageId );

	iTable.SetColL( iFolderIdColNum,     aFolderId );

	iTable.SetColL( iMailBoxIdColNum,    aMailboxId );

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

	//write the rest of the fields

	WriteFieldsL( aSortableFields );

	PutRowUpdatesL();

    //Notify the observer

    iObserver.MessageUpdate( aMessageId, 

    						 aFolderId, 

    						 EMsgStoreAdd, 

    						 iFieldsChanged, 

                             aSortableFields.iFrom, 

                             aSortableFields.iTo, 

                             aSortableFields.iSubject, 

                             aSortableFields.iReceivedDate );

	}

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

// FUNCTION: DeleteMessageL

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

void CContainerStoreSortingTable::DeleteMessageL( TContainerId aMessageId )

	{

	__LOG_ENTER_SUPPRESS( "DeleteMessageL" )

	__LOG_WRITE8_FORMAT1_DEBUG3( "msgId=%x", aMessageId )

    SeekL( aMessageId );

    iTable.GetL();

    TContainerId folderId = iTable.ColUint32( iFolderIdColNum );

    iTable.DeleteL();

    //Notify the observer

    iObserver.MessageUpdate( aMessageId, folderId, EMsgStoreDelete );

	}

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

// FUNCTION: DeleteMessagesByFolderIdL

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

void CContainerStoreSortingTable::DeleteMessagesByFolderIdL( TContainerId aFolderId )

	{

	__LOG_ENTER_SUPPRESS( "DeleteMessagesByFolderIdL" )

	}

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

// FUNCTION: DeleteMessagesByMailBoxIdL

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

void CContainerStoreSortingTable::DeleteMessagesByMailBoxIdL( TContainerId aMailBoxId )

    {

    __LOG_ENTER_SUPPRESS( "DeleteMessagesByMailBoxIdL" )

    __LOG_WRITE8_FORMAT1_DEBUG3( "aMailBoxId=%x", aMailBoxId )

    }

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

// FUNCTION: UpdateMessageL

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

void CContainerStoreSortingTable::UpdateMessageL( TContainerId aMessageId, 

                                                  RMsgStoreSortableFields& aSortableFields )

	{

	__LOG_ENTER_SUPPRESS( "UpdateMessageL" )

	__LOG_WRITE8_FORMAT4_DEBUG3( "msgId=%x, flags=%x, ssize=%d csize=%d", aMessageId, 

                                                                aSortableFields.iFlags, 

                                                                aSortableFields.iSizeOnServer,

                                                                aSortableFields.iSizeOnClient )

	SeekL( aMessageId );

    iTable.GetL();

    TContainerId folderId = iTable.ColUint32( iFolderIdColNum );

	PrepareRowForUpdateLC();

	WriteFieldsL( aSortableFields, EFalse );

	PutRowUpdatesL();

    if ( iFieldsChanged > 0 )

        {

        iObserver.MessageUpdate( aMessageId, 

        						 folderId, 

        						 EMsgStoreUpdateProperties, 

        						 iFieldsChanged,

                                 aSortableFields.iFrom, 

                                 aSortableFields.iTo, 

                                 aSortableFields.iSubject, 

                                 aSortableFields.iReceivedDate );

        }

	}

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

// FUNCTION: UpdateMessageFolderL

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

void CContainerStoreSortingTable::UpdateMessageFolderL( TContainerId aMessageId, TContainerId aNewFolderId )

	{

	__LOG_ENTER_SUPPRESS( "UpdateMessageFolderL" )

	__LOG_WRITE8_FORMAT2_DEBUG3( "msgId=%x, aNewFolder=%x", aMessageId, aNewFolderId )

	SeekL( aMessageId );

    iTable.GetL();

    TContainerId oldFolderId = iTable.ColUint32( iFolderIdColNum );

    if ( oldFolderId != aNewFolderId )

        {

    	PrepareRowForUpdateLC();

    	iTable.SetColL( iFolderIdColNum, aNewFolderId );

    	PutRowUpdatesL();

        //send a notification for delete from old folder 

        iObserver.MessageUpdate( aMessageId, oldFolderId, EMsgStoreDelete );

        //send a notification for new message to the new folder

        RBuf from;

        CleanupClosePushL( from );

        ReadStringFieldL( iTable, iFromColNum, from );

        RBuf to;

        CleanupClosePushL( to );

        ReadStringFieldL( iTable, iToColNum, to );

        RBuf subject;

        CleanupClosePushL( subject );

        ReadStringFieldL( iTable, iSubjectColNum, subject );

        TInt64 date = iTable.ColInt64( iReceivedDateColNum );

        iObserver.MessageUpdate( aMessageId, aNewFolderId, EMsgStoreAdd, 0, from, to, subject, date );

        CleanupStack::PopAndDestroy( &subject );

        CleanupStack::PopAndDestroy( &to );

        CleanupStack::PopAndDestroy( &from );

        }    

	}

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

// FUNCTION: SortL

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

CMsgStoreSortResultRowSet* CContainerStoreSortingTable::SortL( const TMsgStoreSortCriteria& aSortCriteria,  TBool aInMemorySort  )

	{

	__LOG_ENTER_SUPPRESS( "SortL" )

	CMsgStoreSortResultRowSet* result = NULL;

    if ( aSortCriteria.iSortBy == EMsgStoreSortBySender ||

         aSortCriteria.iSortBy == EMsgStoreSortByRecipient     ||   

         aSortCriteria.iSortBy == EMsgStoreSortBySubject )

        {

        result = SortByStringFieldL( aSortCriteria );

        }

    else if ( aInMemorySort )

    	{

    	result = InMemorySortL( aSortCriteria );

    	}

    else

        {

    	TBuf<KQuerryBufSize> queryString;

    	queryString.Copy( KSelect );

        queryString.Append( KStar );

    	queryString.Append( KFrom );

    	queryString.Append( KSortingTableName );

    	queryString.Append( KWhere );

    	queryString.Append( KSortingTableFolderIdCol );

    	queryString.Append( KEquals );

    	queryString.AppendNum( aSortCriteria.iFolderId );

    	queryString.Append( KOrderBy );

    	switch( aSortCriteria.iSortBy )

    		{

    		case EMsgStoreSortByReceivedDate:

    			queryString.Append( KSortingTableReceivedDateCol );

    			break;

    		case EMsgStoreSortByPriority:

    			queryString.Append( KSortingTablePriorityCol );

    			break;

    		case EMsgStoreSortByFlagStatus:

    			queryString.Append( KSortingTableFlagStatusCol );

    			break;

    		case EMsgStoreSortByUnRead:

    			queryString.Append( KSortingTableReadUnreadCol );

    			break;

    		case EMsgStoreSortBySize:

    			queryString.Append( KSortingTableSizeCol );

    			break;

    		case EMsgStoreSortByAttachment:

    			queryString.Append( KSortingTableAttachmentFlagCol );

    			break;

    		default:

    			User::Leave( KErrNotSupported );

    			break;

    		}

    	//add the sort order

    	AppendSortOrder( queryString, aSortCriteria.iSortOrder );

    	//add the secondary sort field if primary is not received date

    	if ( aSortCriteria.iSortBy != EMsgStoreSortByReceivedDate )

    		{

    		queryString.Append( KComma );

    		queryString.Append( KSortingTableReceivedDateCol );

    		AppendSortOrder( queryString, aSortCriteria.iSecondarySortOrder );

    		}

    	__LOG_WRITE_FORMAT1_INFO( "query=%S", &queryString );

    	result = CMsgStoreSortResultRowSet::NewL( aSortCriteria, 

    	                                          iMessageIdColNum,

    	                                          iReceivedDateColNum,

    	                                          iReadUnreadColNum,

    	                                          iPriotiryColNum,

    	                                          iFlagStatusColNum,

    	                                          iSizeColNum,

    	                                          iAttachmentFlagColNum );

    	CleanupStack::PushL( result );

        iUtils.PopulateViewL( result->DbView(), queryString );

        __LOG_WRITE_FORMAT1_INFO( "rowCounts=%d", result->DbView().CountL() );

        CleanupStack::Pop( result );

        }

        return result;

	}

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

// FUNCTION: SortByStringFieldL

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

CMsgStoreStringSortResultRowSet* CContainerStoreSortingTable::SortByStringFieldL( const TMsgStoreSortCriteria& aSortCriteria  )

    {

    __LOG_ENTER_SUPPRESS( "SortByStringFieldL" )

    CMsgStoreStringSortResultRowSet* result = CMsgStoreStringSortResultRowSet::NewL( aSortCriteria, *this );

    CleanupStack::PushL( result );

    TBuf<KQuerryBufSize> queryString;

    queryString.Copy( KSelect );

    queryString.Append( KStar );

    queryString.Append( KFrom );

    queryString.Append( KSortingTableName );

    queryString.Append( KWhere );

    queryString.Append( KSortingTableFolderIdCol );

    queryString.Append( KEquals );

    queryString.AppendNum( aSortCriteria.iFolderId );

    iUtils.PopulateViewL( result->DbView(), queryString );

    ReEvaluateStringViewL( *result, aSortCriteria.iSortBy );

    result->SortL();

    CleanupStack::Pop( result );

    return result;

    }

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

// FUNCTION: InMemorySortL

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

CMsgStoreInMemorySortRowSet* CContainerStoreSortingTable::InMemorySortL( const TMsgStoreSortCriteria& aSortCriteria  )

    {

    __LOG_ENTER_SUPPRESS( "InMemorySortL" )

    CMsgStoreInMemorySortRowSet* result = CMsgStoreInMemorySortRowSet::NewL( aSortCriteria, *this );

    CleanupStack::PushL( result );