/*

* Copyright (c) 2007 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 file implements classes TMsgContainer, Search, Search, Search. 

*

*/

#include "emailtrace.h"

#include "ipsplgheaders.h"

// To skip deleted folder

_LIT( KIpsPlgDeleted, "Deleted" );

// ======== CLASS TSEARCHPARAMS ======== 

// ======== MEMBER FUNCTIONS ======== 

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

// CIpsPlgSearch::TSearchParams::operator==()

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

//

TBool CIpsPlgSearch::TSearchParams::operator==( 

    const TSearchParams& aParams ) const

    {

    FUNC_LOG;

    // This variable indicates if the search is same as previous search or

    // not. If the search is new, previous data can be reused.

    TBool isNew = EFalse;

    // Search strings must have an exact match

    TInt newCnt = aParams.iSearchStrings->Count();

    TInt oldCnt = iSearchStrings ? iSearchStrings->Count() : KErrNotFound;

    if ( newCnt == oldCnt )

        {

        while ( !isNew && --newCnt >= 0 )

            {

            while ( !isNew && --oldCnt >= 0 )

                {

                // Even if one of the items fails, the search is different.

                if ( ( *aParams.iSearchStrings )[newCnt].Compare( 

                    ( *iSearchStrings )[oldCnt] ) )

                    {

                    isNew = ETrue;

                    }

                }

            }

        }

    else

        {

        // This search has different 

        isNew = ETrue;

        }

    // Search strings are the same than in previous round. If search

    // folders are added, but not removed, then search can continue

    // from last location.

    if ( !isNew )

        {

        isNew = EFalse;

        newCnt = aParams.iFolderIds.Count();

        oldCnt = iFolderIds.Count();

        // If folder count has been added, look for added folders.

        // If there is folder removed, search has to be started again.

        if ( newCnt >= oldCnt )

            {

            TInt hits = 0;

            TBool found = EFalse;

            // All of the old folders must be found from the new folders.

            for ( TInt old = 0; old < oldCnt; old++ )

                {

                found = EFalse;

                for ( TInt item = 0; !found && item < newCnt; item++ )

                    {

                    found = iFolderIds[old] == aParams.iFolderIds[item];

                    hits += found;

                    }

                }    

            isNew = hits != oldCnt;                                        

            }                                

        }

    // Test is about: "is the new search the same as previous?" 

    // so if the result of the above analyze is "new search", in that 

    // case we must return the answer: "no, search is not the same".

    // Confusing huh?

    return !isNew;

    }

// ======== CLASS TMSGCONTAINER ======== 

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

// CIpsPlgSearch::TMsgContainer::TMsgContainer()

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

//

CIpsPlgSearch::TMsgContainer::TMsgContainer( 

    const TMsvId& aId, 

    const TFSMailSortCriteria& aCriteria,

    CMsvSession& aMsvSession )

    :

    iId( aId ),

    iCriteria( aCriteria ),

    iMsvSession( aMsvSession )

    {

    FUNC_LOG;

    }

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

// CIpsPlgSearch::TMsgContainer::TMsgContainer()

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

//

TBool CIpsPlgSearch::TMsgContainer::operator>( 

    const TMsgContainer& aMsgContainer ) const

    {

    FUNC_LOG;

    TBool result = EFalse;

    switch ( iCriteria.iField )

        {

    default:        

    case EFSMailDontCare:

        break;

    case EFSMailSortByDate:

        result = Entry( iId ).iDate > Entry( aMsgContainer.Id() ).iDate;

        break;

    case EFSMailSortBySender:

        {

        HBufC* leftSender = NULL;

        HBufC* rightSender = NULL;

        GetSenderStringsCC( 

            iId, 

            aMsgContainer.Id(),  

            leftSender, 

            rightSender );

        result = *leftSender > *rightSender;

        CleanupStack::PopAndDestroy( 2, leftSender ); 

        }

        break;

    case EFSMailSortBySubject:

        {

        HBufC* leftSubject = NULL;

        HBufC* rightSubject = NULL;

        GetSubjectStringsCC( 

            iId, 

            aMsgContainer.Id(), 

            leftSubject, 

            rightSubject );

        result = *leftSubject > *rightSubject;

        CleanupStack::PopAndDestroy( 2, leftSubject ); 

        }

        break;

    case EFSMailSortByPriority:

        result = Entry( iId ).Priority() > Entry( aMsgContainer.Id() ).Priority();        

        break;

    case EFSMailSortByFlagStatus:

        result = Entry( iId ).New() > Entry( aMsgContainer.Id() ).New();

        break;

    case EFSMailSortByUnread:

        result = Entry( iId ).Unread() > Entry( aMsgContainer.Id() ).Unread();

        break;

    case EFSMailSortBySize:

        result = Entry( iId ).iSize > Entry( aMsgContainer.Id() ).iSize;

        break;

    case EFSMailSortByAttachment:

        result = Entry( iId ).iDate > Entry( aMsgContainer.Id() ).iDate;        

        break;

        }

    return result;        

    }

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

// CIpsPlgSearch::TMsgContainer::TMsgContainer()

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

//

TBool CIpsPlgSearch::TMsgContainer::operator>=( 

    const TMsgContainer& aMsgContainer ) const

    {

    FUNC_LOG;

    TBool result = EFalse;

    switch ( iCriteria.iField )

        {

    default:        

    case EFSMailDontCare:

        break;

    case EFSMailSortByDate:

        result = Entry( iId ).iDate >= Entry( aMsgContainer.Id() ).iDate;

        break;

    case EFSMailSortBySender:

        {

        HBufC* leftSender = NULL;

        HBufC* rightSender = NULL;

        GetSenderStringsCC( 

            iId, 

            aMsgContainer.Id(),  

            leftSender, 

            rightSender );

        result = *leftSender >= *rightSender;

        CleanupStack::PopAndDestroy( 2, leftSender ); 

        }

        break;

    case EFSMailSortBySubject:

        {

        HBufC* leftSubject = NULL;

        HBufC* rightSubject = NULL;

        GetSubjectStringsCC( 

            iId, 

            aMsgContainer.Id(), 

            leftSubject, 

            rightSubject );

        result = *leftSubject >= *rightSubject;

        CleanupStack::PopAndDestroy( 2, leftSubject ); 

        }

        break;

    case EFSMailSortByPriority:

        result = Entry( iId ).Priority() >= Entry( aMsgContainer.Id() ).Priority();        

        break;

    case EFSMailSortByFlagStatus:

        result = Entry( iId ).New() >= Entry( aMsgContainer.Id() ).New();

        break;

    case EFSMailSortByUnread:

        result = Entry( iId ).Unread() >= Entry( aMsgContainer.Id() ).Unread();

        break;

    case EFSMailSortBySize:

        result = Entry( iId ).iSize >= Entry( aMsgContainer.Id() ).iSize;

        break;

    case EFSMailSortByAttachment:

        result = Entry( iId ).iDate >= Entry( aMsgContainer.Id() ).iDate;        

        break;

        }

    return result;        

    }

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

// CIpsPlgSearch::TMsgContainer::TMsgContainer()

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

//

TBool CIpsPlgSearch::TMsgContainer::operator<=( 

    const TMsgContainer& aMsgContainer ) const

    {

    FUNC_LOG;

    TBool result = EFalse;

    switch ( iCriteria.iField )

        {

    default:        

    case EFSMailDontCare:

        break;

    case EFSMailSortByDate:

        result = Entry( iId ).iDate <= Entry( aMsgContainer.Id() ).iDate;

        break;

    case EFSMailSortBySender:

        {

        HBufC* leftSender = NULL;

        HBufC* rightSender = NULL;

        GetSenderStringsCC( 

            iId, 

            aMsgContainer.Id(),  

            leftSender, 

            rightSender );

        result = *leftSender <= *rightSender;

        CleanupStack::PopAndDestroy( 2, leftSender ); 

        }

        break;

    case EFSMailSortBySubject:

        {

        HBufC* leftSubject = NULL;

        HBufC* rightSubject = NULL;

        GetSubjectStringsCC( 

            iId, 

            aMsgContainer.Id(), 

            leftSubject, 

            rightSubject );

        result = *leftSubject <= *rightSubject;

        CleanupStack::PopAndDestroy( 2, leftSubject ); 

        }

        break;

    case EFSMailSortByPriority:

        result = Entry( iId ).Priority() <= Entry( aMsgContainer.Id() ).Priority();        

        break;

    case EFSMailSortByFlagStatus:

        result = Entry( iId ).New() <= Entry( aMsgContainer.Id() ).New();

        break;

    case EFSMailSortByUnread:

        result = Entry( iId ).Unread() <= Entry( aMsgContainer.Id() ).Unread();

        break;

    case EFSMailSortBySize:

        result = Entry( iId ).iSize <= Entry( aMsgContainer.Id() ).iSize;

        break;

    case EFSMailSortByAttachment:

        result = Entry( iId ).iDate <= Entry( aMsgContainer.Id() ).iDate;        

        break;

        }

    return result;        

    }

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

// CIpsPlgSearch::TMsgContainer::GetSenderStringsCC()

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

//

void CIpsPlgSearch::TMsgContainer::GetSenderStringsCC( 

    const TMsvId aLeft, 

    const TMsvId aRight,

    HBufC*& aLeftSender,

    HBufC*& aRightSender ) const

    {

    FUNC_LOG;

    TMsvEntry entry = Entry( aLeft );

    aLeftSender = entry.iDetails.Alloc();

    TRAP_IGNORE( CleanupStack::PushL( aLeftSender ) );

    entry = Entry( aRight );

    aRightSender = entry.iDetails.Alloc();

    TRAP_IGNORE( CleanupStack::PushL( aRightSender ) );

    }

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

// CIpsPlgSearch::TMsgContainer::GetSubjectStringsCC()

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

//

void CIpsPlgSearch::TMsgContainer::GetSubjectStringsCC( 

    const TMsvId aLeft, 

    const TMsvId aRight,

    HBufC*& aLeftSubject,

    HBufC*& aRightSubject ) const

    {

    FUNC_LOG;

    TMsvEntry entry = Entry( aLeft );

    aLeftSubject = entry.iDescription.Alloc();

    TRAP_IGNORE( CleanupStack::PushL( aLeftSubject ) );

    entry = Entry( aRight );

    aRightSubject = entry.iDescription.Alloc();

    TRAP_IGNORE( CleanupStack::PushL( aRightSubject ) );

    }

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

// CIpsPlgSearch::TMsgContainer::TMsgContainer()

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

//

CIpsPlgSearch::TMsgContainer& CIpsPlgSearch::TMsgContainer::operator=( 

    const TMsgContainer& aMsgContainer )

    {

    FUNC_LOG;

    iId = aMsgContainer.Id();

    return *this;

    }

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

// CIpsPlgSearch::TMsgContainer::Entry()

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

//

TMsvEntry CIpsPlgSearch::TMsgContainer::Entry( const TMsvId aId ) const

    {

    FUNC_LOG;

    return CIpsPlgSearch::TMsgContainer::Entry( iMsvSession, aId );

    }

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

// CIpsPlgSearch::TMsgContainer::Entry()

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

//

TMsvEntry CIpsPlgSearch::TMsgContainer::Entry( 

    CMsvSession& aMsvSession, 

    const TMsvId aId )

    {

    FUNC_LOG;

    TMsvId service;

    TMsvEntry entry;

    aMsvSession.GetEntry( aId, service, entry );

    return entry;

    }

// ======== CLASS CIPSPLGSEARCH ========     

// ======== CONSTRUCTORS & DESTRUCTOR ========

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

// CIpsPlgSearch::NewL()

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

//

CIpsPlgSearch* CIpsPlgSearch::NewL(

    CMsvSession& aMsvSession,

    CIpsPlgSosBasePlugin& aPlugin )

    {

    FUNC_LOG;

    CIpsPlgSearch* self = CIpsPlgSearch::NewLC( aMsvSession, aPlugin );

    CleanupStack::Pop( self );

    return self;

    }

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

// CIpsPlgSearch::NewLC()

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

//

CIpsPlgSearch* CIpsPlgSearch::NewLC(

    CMsvSession& aMsvSession,

    CIpsPlgSosBasePlugin& aPlugin )

    {

    FUNC_LOG;

    CIpsPlgSearch* self = new( ELeave ) CIpsPlgSearch( aMsvSession, aPlugin );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CIpsPlgSearch::~CIpsPlgSearch()

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

//

CIpsPlgSearch::~CIpsPlgSearch()

    {

    FUNC_LOG;

    // Any running search operations must be cancelled before deletion.

    if ( iOperation )

        {

        iOperation->Cancel();

        }

    delete iOperation;

    iOperation = NULL;

    iObserver = NULL;

    delete iActiveEntry;

    iActiveEntry = NULL;

    delete iMapper;

    iMapper = NULL;

    iCache.Reset();

    iEmailMessages.Reset();

    }

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

// CIpsPlgSearch::CIpsPlgSearch()

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

//

CIpsPlgSearch::CIpsPlgSearch(

    CMsvSession& aMsvSession,

    CIpsPlgSosBasePlugin& aPlugin )

    :

    iMsvSession( aMsvSession ),

    iActiveEntry( NULL ),

    iOperation( NULL ),

    iObserver( NULL ),

    iPlugin( aPlugin ),

    iMapper( NULL )

    {

    FUNC_LOG;

    }

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

// CIpsPlgSearch::ConstructL()

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

//

void CIpsPlgSearch::ConstructL()

    {

    FUNC_LOG;

    iMapper = CIpsPlgMsgMapper::NewL( iMsvSession, iPlugin );

    iActiveEntry = iMsvSession.GetEntryL( KMsvLocalServiceIndexEntryId );

    }

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

// CIpsPlgSearch::Cancel()

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

//

void CIpsPlgSearch::Cancel()

    {

    FUNC_LOG;

    // Cancel the operation before deleting.

    if ( iOperation )

        {

        iOperation->Cancel();

        }