/*

* Copyright (c) 2010 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 most recently used address table implementation.

*

*/

// ========

// INCLUDES

// ========

#include "ContainerStoreMRUAddressTable.h"

#include "ContainerStoreDefs.h"

#include "ContainerStoreUtils.h"

#include "MessageStoreClientServer.h"

#include "ContainerStoreEncryption.h"

#include "ContainerStoreGeneralTable.h"

#include "ContainerStoreAccountTable.h"

// =========

// CONSTANTS

// =========

_LIT( KSelectStar,     "SELECT *"         );

_LIT( KFrom,            " FROM "          );

_LIT( KWhere,          " WHERE "          );

_LIT( KEquals,         " = "              );

_LIT( KDelete,         "DELETE"           );

// =======

// CLASSES

// =======

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

// CLASS: CMruAddress

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

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

// METHOD IMPLEMENTATIONS

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

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

// FUNCTION: NewL

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

CMruAddress* CMruAddress::NewL( TUint aMruNum, const TDesC& aEmailAddress, const TDesC& aDisplayName )

    {

    CMruAddress* self = new(ELeave) CMruAddress( aMruNum );

    CleanupStack::PushL( self );

    self->ConstructL( aEmailAddress, aDisplayName );

    CleanupStack::Pop( self );

    return self;

    }

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

// FUNCTION: CMruAddress

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

CMruAddress::CMruAddress( TUint aMruNum )

: iMruNum( aMruNum )

    {

    }

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

// FUNCTION: ConstructL

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

void CMruAddress::ConstructL( const TDesC& aEmailAddress, const TDesC& aDisplayName )

    {

    iEmailAddress.CreateL( aEmailAddress );

    iDisplayName.CreateL( aDisplayName );

    }

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

// FUNCTION: ~CMruAddress

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

CMruAddress::~CMruAddress()

    {

    iDisplayName.Close();

    iEmailAddress.Close();

    }

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

// FUNCTION: SortByAddress

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

TInt CMruAddress::SortByAddress(const CMruAddress& aFirst, const CMruAddress& aSecond)

    {

    TInt rc = aFirst.iEmailAddress.CompareF( aSecond.iEmailAddress );

    if ( rc == 0 )

        {

        rc = aFirst.iDisplayName.CompareF( aSecond.iDisplayName );

        }

    return rc;

    }

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

// FUNCTION: SortByMruDesc

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

TInt CMruAddress::SortByMruDesc( const CMruAddress& aFirst, const CMruAddress& aSecond )

    {

    return aSecond.iMruNum < aFirst.iMruNum ? -1 : ( aSecond.iMruNum == aFirst.iMruNum ) ? 0 : 1;

    }

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

// CLASS: CMruAddressList

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

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

// FUNCTION: CMruAddressList

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

CMruAddressList::CMruAddressList( TContainerId aMailboxId )

: iMailboxId( aMailboxId )

    {

    }

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

// FUNCTION: ~CMruAddressList

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

CMruAddressList::~CMruAddressList()

    {

    iSortedByAddressArray.Reset();

    iSortedByMruArray.ResetAndDestroy();

    }

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

// FUNCTION: FindAddress

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

CMruAddress* CMruAddressList::FindAddress( CMruAddress* aMruAddress )

    {

    CMruAddress* result = NULL;

    //check if the address already exists

    TInt index = iSortedByAddressArray.FindInOrder( aMruAddress, &CMruAddress::SortByAddress );

    if ( index >= 0 )

        {

        result = iSortedByAddressArray[index];

        }

    return result;

    }

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

// FUNCTION: PromoteAddressL

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

void CMruAddressList::PromoteAddressL( CMruAddress* aMruAddress, TUint aNewMruNum )

    {

    //check if the address already exists

    TInt ndxAddr = iSortedByAddressArray.FindInOrder( aMruAddress, &CMruAddress::SortByAddress );

    if ( ndxAddr >= 0 )

        {

        CMruAddress* toBePromoted = iSortedByAddressArray[ndxAddr];

        //already exists, get the index to the MruArray too.

        TInt ndxMru = iSortedByMruArray.FindInOrder( toBePromoted, &CMruAddress::SortByMruDesc );

        if ( ndxMru < 0 )

            {

            User::Leave( KErrCorrupt );

            }

        //get the one that needs to be promoted and remove it from its current position

        iSortedByAddressArray.Remove( ndxAddr );

        iSortedByMruArray.Remove( ndxMru );

        //add the promoted back with new MruNum

        AddAddress( toBePromoted, aNewMruNum );

        }

    else

        {

        User::Leave( KErrNotFound );

        }

    }

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

// FUNCTION: AddAddress

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

void CMruAddressList::AddAddress( CMruAddress* aMruAddress )

    {

    iSortedByAddressArray.InsertInOrder( aMruAddress, &CMruAddress::SortByAddress );

    iSortedByMruArray.InsertInOrder( aMruAddress, &CMruAddress::SortByMruDesc );

    }

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

// FUNCTION: AddAddress

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

void CMruAddressList::AddAddress( CMruAddress* aMruAddress, TUint aNewMruNum )

    {

    aMruAddress->SetMruNum( aNewMruNum );

    AddAddress( aMruAddress );

    }

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

// FUNCTION: GetL

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

CMruAddress* CMruAddressList::GetL( TInt aIndex )

    {

    if ( aIndex >= iSortedByMruArray.Count() )

        {

        User::Leave( KErrArgument );

        }

    return iSortedByMruArray[aIndex];

    }

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

// FUNCTION: RemoveL

//           This method only removes an object from the array, it does not 

//           detroy the object

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

void CMruAddressList::RemoveL( TInt aIndex )

    {

    if ( aIndex >= iSortedByMruArray.Count() )

        {

        User::Leave( KErrArgument );

        }

    CMruAddress* toBeRemoved = iSortedByMruArray[aIndex];

    TInt ndxAddr = iSortedByAddressArray.FindInOrder( toBeRemoved, &CMruAddress::SortByAddress );

    if ( ndxAddr < 0 )

        {

        User::Leave( KErrCorrupt );

        }

    iSortedByMruArray.Remove( aIndex );

    iSortedByAddressArray.Remove( ndxAddr );

    }

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

// CLASS: CContainerStoreMruAddressTable

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

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

// METHOD IMPLEMENTATIONS

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

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

// FUNCTION: OpenL

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

CContainerStoreMruAddressTable* CContainerStoreMruAddressTable::OpenL( CContainerStoreUtils&        aUtils, 

																       CContainerStoreEncryption&   aEncryption,

                                                                       CContainerStoreGeneralTable& aGeneralTable,

                                                                       CContainerStoreAccountTable& aAccountTable )

	{

    CContainerStoreMruAddressTable* self = new(ELeave) CContainerStoreMruAddressTable( aUtils, aEncryption, aGeneralTable, aAccountTable );

	CleanupStack::PushL( self );

	self->OpenTableL();

	CleanupStack::Pop( self );

	return self;

	} // end OpenL

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

// FUNCTION: CreateL

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

CContainerStoreMruAddressTable* CContainerStoreMruAddressTable::CreateL( CContainerStoreUtils&        aUtils, 

                                                                         CContainerStoreEncryption&   aEncryption,

                                                                         CContainerStoreGeneralTable& aGeneralTable,

                                                                         CContainerStoreAccountTable& aAccountTable )

	{

    CContainerStoreMruAddressTable* self = new(ELeave) CContainerStoreMruAddressTable( aUtils, aEncryption, aGeneralTable, aAccountTable );

	CleanupStack::PushL( self );

	self->CreateTableL();

	CleanupStack::Pop( self );

	return self;

	} // end CreateL

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

// FUNCTION: Constructor

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

CContainerStoreMruAddressTable::CContainerStoreMruAddressTable( CContainerStoreUtils&        aUtils, 

														        CContainerStoreEncryption&   aEncryption,

                                                                CContainerStoreGeneralTable& aGeneralTable,

                                                                CContainerStoreAccountTable& aAccountTable ) :

    CContainerStoreTable( aUtils ), iEncryption(aEncryption), iGeneralTable( aGeneralTable ), iAccountTable( aAccountTable )

	{

	__LOG_CONSTRUCT( "msg", "CContainerStoreMruAddressTable" )

	__LOG_CLOSE_BETWEEN_WRITES

	} // end constructor

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

// FUNCTION: Destructor

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

CContainerStoreMruAddressTable::~CContainerStoreMruAddressTable()

	{

    iAddressLists.ResetAndDestroy();

	iUtils.CloseTable( iTable );

    iEncryptedBuffer.Close();

	__LOG_DESTRUCT	

	} // end destructor

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

// FUNCTION: OpenTableL

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

void CContainerStoreMruAddressTable::OpenTableL()

	{

	__LOG_ENTER( "OpenTableL" )

	iUtils.OpenTableL( iTable, KMruAddressTableName );

	// Get the column numbers for the containers table.

	CDbColSet* colSet = iTable.ColSetL();

	CleanupStack::PushL( colSet );

    iMruNumColNum        = colSet->ColNo( KMruAddressTableMruNumCol );

    iMailboxIdColNum     = colSet->ColNo( KMruAddressTableMailBoxIdCol );

    iDisplayNameColNum   = colSet->ColNo( KMruAddressTableDisplayNameCol );

    iEmailAddressColNum  = colSet->ColNo( KMruAddressTableEmailAddressCol );

	iIsEncryptedColNum   = colSet->ColNo( KMruAddressTableIsEncryptedCol );

	CleanupStack::PopAndDestroy( colSet );

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

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

	__LOG_EXIT	

	} // end OpenTableL

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

// FUNCTION: CreateTableL

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

void CContainerStoreMruAddressTable::CreateTableL()

	{

	__LOG_ENTER( "CreateTableL" )

	// Create table columns

	CDbColSet* colSet = CDbColSet::NewLC();

	TDbCol rowIdCol( KMruAddressTableMruNumCol, EDbColUint32 );

	colSet->AddL( rowIdCol );	

    TDbCol mailBoxIdCol( KMruAddressTableMailBoxIdCol, EDbColUint32 );

    colSet->AddL( mailBoxIdCol );   

	TDbCol displayNameCol( KMruAddressTableDisplayNameCol, EDbColLongBinary );

	colSet->AddL( displayNameCol );	

    TDbCol emailAddressCol( KMruAddressTableEmailAddressCol, EDbColLongBinary );

    colSet->AddL( emailAddressCol ); 

	TDbCol isEncryptedCol( KMruAddressTableIsEncryptedCol, EDbColUint8 );

	colSet->AddL( isEncryptedCol );	

	// Create table.

	iUtils.CreateTableL( KMruAddressTableName, *colSet );

	CleanupStack::PopAndDestroy( colSet );

	//create indexes on RowId and MailBox ID columns

    CreateIndexL( KMruAddressTableName, KMruAddressTableMruNumIndex,    KMruAddressTableMruNumCol );

    CreateIndexL( KMruAddressTableName, KMruAddressTableMailboxIdIndex, KMruAddressTableMailBoxIdCol );

	OpenTableL();

	__LOG_EXIT

	} // end CreateTableL

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

// FUNCTION: SetMruAddressListL

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

void CContainerStoreMruAddressTable::SetMruAddressListL( TContainerId                aMailboxId, 

                                                         RPointerArray<CMruAddress>& aMruAddressArray ) 

	{

    __LOG_ENTER_SUPPRESS( "SetMruAddressListL" )

    __LOG_WRITE8_FORMAT1_INFO( "mailbox=%x", aMailboxId )

    InitializeIfNeededL();

	CMruAddressList& addressList = AddressListByMailboxIdL( aMailboxId );

    iUtils.BeginDatabaseTransactionLC();

	//Need to add the addresses in the reverse order 

    //so that the first element in the input array has the highest MRU number

    TInt count = aMruAddressArray.Count();

    for ( TInt i = count - 1 ; i >= 0 ; i-- )

        {

        CMruAddress* curAddr = aMruAddressArray[i];

        SetMruAddressL( addressList, curAddr );

        //remove the address from the array because it maybe added to the list already

        aMruAddressArray.Remove(i);

        //After returning from SetMruAddressL, the curAddr can be either

        // NULL - if the address is new and the object has been added to the MRU list, or

        // Unchanged if the address already exists, and the existing object was "promoted"

        // to the top of the MRU list

        // In either case, we can delete the pointer

        delete curAddr;

        }

    //Persist the iCurMruNumber to General Table

    iGeneralTable.SetCurMruNumberL( iCurMruNumber );

    iUtils.CommitDatabaseTransactionL();

	}

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

// FUNCTION: SetMaxMruCountL

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

void CContainerStoreMruAddressTable::SetMaxMruCountL( TInt aMaxCount )

    {

    InitializeIfNeededL();

    iMaxMruCount = aMaxCount;

    iUtils.BeginDatabaseTransactionLC();

    for ( TInt i = 0 ; i < iAddressLists.Count() ; i++ )

        {

        CMruAddressList* list = iAddressLists[i];

        TInt count = list->Count();

        while ( count  > aMaxCount )

            {

            CMruAddress* address = list->GetL(count - 1);

            CleanupStack::PushL( address );

            //remove it from the list

            list->RemoveL( count - 1 );

            //delete it from the table

            DeleteAddressFromTableL( address->MruNum() );

            CleanupStack::PopAndDestroy( address );

            count = list->Count();

            }

        }

    iGeneralTable.SetMaxMruCountL( aMaxCount );

    iUtils.CommitDatabaseTransactionL();

    }

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

// FUNCTION: MruAddressListL

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

const RPointerArray<CMruAddress>& CContainerStoreMruAddressTable::MruAddressListL( TContainerId aMailboxId )

    {

    __LOG_ENTER_SUPPRESS( "SetMruAddressListL" );

    __LOG_WRITE8_FORMAT1_INFO( "mailbox=%x", aMailboxId );

    InitializeIfNeededL();

    CMruAddressList& addressList = AddressListByMailboxIdL( aMailboxId );

    return addressList.SortedByMruArray();

    }

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

// FUNCTION: AddMailBoxL

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

void CContainerStoreMruAddressTable::AddMailboxL( TContainerId aMailboxId )

    {

    __LOG_ENTER( "AddMailboxL" )

    TRAPD( err, AddressListByMailboxIdL( aMailboxId ) );

    if ( err != KErrNotFound )

        {

        User::Leave( KErrAlreadyExists );

        }

    CMruAddressList* list = new(ELeave) CMruAddressList( aMailboxId );

    iAddressLists.AppendL( list );

    __LOG_EXIT

    }

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

// FUNCTION: DeleteMailBoxL

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

void CContainerStoreMruAddressTable::DeleteMailboxL( TContainerId aMailboxId )

    {

    __LOG_ENTER( "DeleteMailboxL" )

    //delete from the lists in memory

    TBool found = EFalse;

    TInt count = iAddressLists.Count();

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

        {

        if ( iAddressLists[i]->MailboxId() == aMailboxId )

            {

            found = ETrue;

            CMruAddressList* list = iAddressLists[i];

            iAddressLists.Remove( i );

            delete list;

            break;

            }

        }

    if ( !found )

        {

        User::Leave( KErrNotFound );

        }

    //delete from the table

    const TUint bufSize = 100;

    TBuf<bufSize> sqlString;

    sqlString.Copy( KDelete );

    sqlString.Append( KFrom );

    sqlString.Append( KMruAddressTableName );

    sqlString.Append( KWhere );

    sqlString.Append( KMruAddressTableMailBoxIdCol );

    sqlString.Append( KEquals );

    sqlString.AppendNum( aMailboxId );

    __LOG_WRITE_FORMAT1_INFO("sqlString=%S", &sqlString );

    iUtils.Execute( sqlString );

    __LOG_EXIT

    }

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

// FUNCTION: SetMRUAddressL

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

void CContainerStoreMruAddressTable::SetMruAddressL( CMruAddressList& aAddressList, CMruAddress*& aMruAddress )

    {

    __LOG_ENTER_SUPPRESS( "SetMruAddressL" )

    __LOG_WRITE8_FORMAT2_INFO( "emailAddr=%S, dispName=%S", &aMruAddress->EmailAddress(), &aMruAddress->DisplayName() )

    ++iCurMruNumber;

    CMruAddress* existing = aAddressList.FindAddress( aMruAddress );

    if ( !existing  )

        {