/*

* Copyright (c) 2002 - 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:  implements all sorting related test cases

*

*/

#include <e32math.h>

#include <tz.h>

#include "SortTests.h"

const TInt32 KOwner1 = 1234;

_LIT(KAccount1, "My Account");

_LIT(KInbox,    "inbox");

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

CSortTests* CSortTests::NewL( CStifLogger* aLog )

    {

    CSortTests* self = new(ELeave) CSortTests( aLog );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// Constructor

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

CSortTests::CSortTests( CStifLogger* aLog ) : CAsyncTestCaseBase( aLog ) 

    {

    }

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

// Destructor

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

CSortTests::~CSortTests()

    {

    }

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

// 2nd phase constructor

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

void CSortTests::ConstructL()

    {

    CAsyncTestCaseBase::ConstructL();

    }

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

// ExecuteL : start executing the test case

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

TBool CSortTests::ExecuteL()

    {

    LogHeader( _L("Sort") );

    TInt msgCount = 200;

    iLog->Log( _L("  Create %d messages"), msgCount );

    DoCreateMessagesL( msgCount );

    //Open Account

    CMsgStoreAccount* account = CMsgStoreAccount::NewLC( KOwner1, KAccount1 );   //+1

    CMsgStoreMailBox* mailBox = iMsgStore->OpenAccountL( *account );

    CleanupStack::PushL( mailBox );                                              //+2

    TUint total, unread;

    mailBox->TotalMessageCountsL( total, unread );

    iLog->Log( _L("  Total msg=%u, unread=%u"), total, unread);

    RPointerArray<CMsgStoreFolder> folders;

    mailBox->FoldersL( mailBox->Id(), folders );

    TMsgStoreId inboxId = 0;

    for ( TInt ii = 0 ; ii < folders.Count() ; ii++ )

        {

        CMsgStoreFolder* folder = folders[ii];

        TUint index = 0;

        if ( folder->FindProperty( KMsgStorePropertyName, index ) )

            {

            if ( folder->PropertyValueDesL( index ) == KInbox )

                {

                //found inbox

                inboxId = folder->Id();

                break;

                }

            }

        }

    folders.ResetAndDestroy();

    if ( inboxId == 0 )

        {

        User::Leave( KErrNotFound );

        }

    RArray<RMsgStoreSortCriteria>              criteriaArray;

    RPointerArray<CMsgStoreSortResultIterator> iteratorArray;

    RArray<TMsgStoreId>                        curIdArray;

    RArray<TBool>                              hasMoreArray;

    RArray<TMsgStoreIteratorDirection>         checkDirectionArray;

    RArray<TInt>                               bucketSizeArray;

//    UpdateText( 2, _L("Start sorting") );

    RPointerArray<CMsgStorePropertyContainer> results;

    //test each sort by field

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

        {

        RMsgStoreSortCriteria criteria;

        criteria.iFolderId = inboxId;

        criteria.AddResultPropertyL( KMsgStorePropertyReceivedAt );

        criteria.AddResultPropertyL( KMsgStorePropertyFlags );

        criteria.AddResultPropertyL( KMsgStorePropertyMessageSizeOnServer );

        criteria.AddResultPropertyL( KMsgStorePropertyFrom );

        criteria.AddResultPropertyL( KMsgStorePropertyTo );

        criteria.AddResultPropertyL( KMsgStorePropertySubject );

        switch( i )

            {

            case 0:

                //sort by received date

                iLog->Log( _L("Case %d: Sort By: ReceivedData, Order: Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortByReceivedDate;

                criteria.iSortOrder = EMsgStoreSortDescending;

                break;

            case 1:

                //sort by EMsgStoreSortByPriority

                iLog->Log( _L("Case %d: Sort By: Priority, Order: Desc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortByPriority;

                criteria.iSortOrder = EMsgStoreSortDescending;          //primary   = DESC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending; //secondary = DESC 

                break;

            case 2:

                //sort by EMsgStoreSortByFlagStatus

                iLog->Log( _L("Case %d: Sort By: Flag, Order: Desc/Asc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortByFlagStatus;

                criteria.iSortOrder = EMsgStoreSortDescending;          //Primary   = DESC

                criteria.iSecondarySortOrder = EMsgStoreSortAscending;  //secondary = ASC

                break;

            case 3:

                //sort by EMsgStoreSortByUnRead

                iLog->Log( _L("Case %d: Sort By: Unread, Order: Asc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortByUnRead;

                criteria.iSortOrder = EMsgStoreSortAscending;           //Primary   = ASC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending;  //Secondary = DESC

                break;

            case 4:

                //sort by EMsgStoreSortByAttachment

                iLog->Log( _L("Case %d: Sort By: Attachment, Order: Asc/Asc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortByAttachment;

                criteria.iSortOrder = EMsgStoreSortAscending;            //Primary   = ASC

                criteria.iSecondarySortOrder = EMsgStoreSortAscending;  //Secondary = ASC

                break;

            case 5:

                //sort by EMsgStoreSortBySize

                iLog->Log( _L("Case %d: Sort By: Size, Order: Desc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortBySize;

                criteria.iSortOrder = EMsgStoreSortDescending;           //Primary   = DESC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending;  //Secondary = DESC

                break;

            case 6:

                //sort by EMsgStoreSortBySender

                iLog->Log( _L("Case %d: Sort By: Sender, Order: Desc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortBySender;

                criteria.iSortOrder = EMsgStoreSortDescending;           //Primary   = DESC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending;  //Secondary = DESC

                break;

            case 7:

                //sort by EMsgStoreSortByTo

                iLog->Log( _L("Case %d: Sort By: Recipient, Order: Desc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortByRecipient;

                criteria.iSortOrder = EMsgStoreSortDescending;           //Primary   = DESC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending;  //Secondary = DESC

                break;

            case 8:

                //sort by EMsgStoreSortBySubject

                iLog->Log( _L("Case %d: Sort By: Subject, Order: Asc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortBySubject;

                criteria.iSortOrder = EMsgStoreSortAscending;            //Primary   = ASC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending;  //Secondary = DESC

                break;

            case 9:

                //sort by EMsgStoreSortBySubject

                iLog->Log( _L("Case %d: Sort By: Subject, Order: Asc/Desc"), iCaseId++ );

                criteria.iSortBy   = EMsgStoreSortBySubject;

                criteria.iSortOrder = EMsgStoreSortAscending;            //Primary   = ASC

                criteria.iSecondarySortOrder = EMsgStoreSortDescending;  //Secondary = DESC

                break;

            default:

                break;

            }

        criteriaArray.Append( criteria );

        //set the direction

        TMsgStoreIteratorDirection direction = static_cast<TMsgStoreIteratorDirection>(i % 2);   //forward (next) or backward (previous)

        checkDirectionArray.Append( direction );

        //initialize currentId, if forward, start from the top, if backward, start from the bottom

        TMsgStoreId curId = ( direction == EMsgStoreIteratorForward ) ? KMsgStoreSortResultTop : KMsgStoreSortResultBottom ;

        curIdArray.Append( curId );

        //initialze hasMore to true

        hasMoreArray.Append(ETrue);

        CMsgStoreSortResultIterator* iterator = mailBox->SortL( criteria, (i % 2 ? ETrue : EFalse) ); 

        for( TInt jj = 0; jj < 10; jj++ )

            {                

            Yield( 25000 );

            }

        if ( i != 5 && i <= 8 )

            {

            iLog->Log( _L("Case %d: Test GroupCountL"), iCaseId++ );

            RArray<TUint> itemCounts;

            CleanupClosePushL( itemCounts );

            TInt count = iterator->GroupCountL( itemCounts );

            iLog->Log( _L("  GroupCount=%d"), count );

            CleanupStack::PopAndDestroy( &itemCounts );

            }

        TBool hasMore = EFalse;

        TInt  bucketSize = 20;

        //get the results

        do {

            results.ResetAndDestroy();

            TTime startTime;

            startTime.HomeTime();

            TInt startId = curIdArray[i];

            if ( checkDirectionArray[i] == EMsgStoreIteratorForward )

                {

                if ( i == 9 )

                    {

                    iLog->Log( _L("Case %d: Calling NextL(string)"), iCaseId++ );

                    hasMore = iterator->NextL( _L("nzz") , bucketSize, results );

                    }

                else

                    {

                    iLog->Log( _L("Case %d: Calling NextL"), iCaseId++ );

                    hasMore = iterator->NextL( curIdArray[i] , bucketSize, results );

                    }

                }

            else

                {

                if ( i == 9 )

                    {

                    iLog->Log( _L("Case %d: Calling PreviousL(string)"), iCaseId++ );

                    hasMore = iterator->PreviousL( _L("nzz") , bucketSize, results );

                    }

                else

                    {

                    iLog->Log( _L("Case %d: Calling PreviousL()"), iCaseId++ );

                    hasMore = iterator->PreviousL( curIdArray[i] , bucketSize, results );

                    }

                }

            iLog->Log( _L("  Comparing results") );

            curIdArray[i] = CompareSortResultsL( criteriaArray[i], checkDirectionArray[i], results );

            //TEST SkipAndNext() and SkupAndPrevioud

            if ( i >= 0 && i <= 8 )

                {

                RPointerArray<CMsgStorePropertyContainer> skipResults;

                startTime.HomeTime();

                TBool hasNextGroup = ETrue;

                if ( checkDirectionArray[i] == EMsgStoreIteratorForward )

                    {

                    iLog->Log( _L("Case %d: Testing SkipAndNextL()"), iCaseId++ );

                    hasNextGroup = iterator->SkipAndNextL( startId , bucketSize, skipResults );

                    }

                else

                    {

                    iLog->Log( _L("Case %d: Testing SkipAndPreviousL()"), iCaseId++ );

                    hasNextGroup = iterator->SkipAndPreviousL( startId, bucketSize, skipResults );

                    }

                iLog->Log( _L("  Skip returns %d"), hasNextGroup);

                iLog->Log( _L("  Comparing results") );

                CompareSortResultsL( criteriaArray[i], checkDirectionArray[i], skipResults );

                skipResults.ResetAndDestroy();

                }

            if ( bucketSize == 100 )

                {

                hasMore = EFalse;

                }

            else

                {

                bucketSize += 10;

                }

            //add a message while there are sorting sessions

            if ( bucketSize == 30 )

                {

                iLog->Log( _L("Case %d: Add messages while sort session is open"), iCaseId++ );

                CreateRandomMessagesL( mailBox, inboxId, 2, ETrue, ETrue);

                }

            else if ( bucketSize == 40 )

                {

                //delete iMatches[0]

                iLog->Log( _L("Case %d: Delete message while sort session is open"), iCaseId++ );

                mailBox->DeleteMessageL( iMatches[0], inboxId );

                }

            else if ( bucketSize == 50 )

                {

                iLog->Log( _L("Case %d: Update message while sort session is open"), iCaseId++ );

                CMsgStoreMessage* msg = mailBox->FetchMessageL( iMatches[1], inboxId );

                CleanupStack::PushL( msg );                                                    //+msg

                TTime time;

                time.HomeTime();

                TInt64 seed = time.Int64();

                TInt64 date = Math::Rand( seed );

                TTime randTime( date );

                msg->AddOrUpdatePropertyL( KMsgStorePropertyReceivedAt, randTime );

                TUint32 flags = Math::Rand( seed );

                msg->AddOrUpdatePropertyL( KMsgStorePropertyFlags, (TUint32) flags );

                TUint32 size = Math::Rand( seed );

                msg->AddOrUpdatePropertyL( KMsgStorePropertyMessageSizeOnServer, (TUint32) size );

                TBuf<30> subject;

                CreateRandomString( subject, 30, seed );

                msg->AddOrUpdatePropertyL( KMsgStorePropertySubject, subject );

                TBuf<6> fname, lname;

                CreateRandomString( fname, 6, seed );

                CreateRandomString( lname, 6, seed );

                RMsgStoreAddress address;

                address.iDisplayName.Create( 50 );

                address.iEmailAddress.Create( 50 );

                address.iDisplayName.Format( _L("%S %S"), &fname, &lname );

                address.iEmailAddress.Format( _L("%S.%S@%S"), &fname, &lname, &_L("nokia.com"));

                msg->AddOrUpdatePropertyL( KMsgStorePropertyFrom, address );

                address.iDisplayName.Append(_L("TO"));

                msg->AddOrUpdatePropertyL( KMsgStorePropertyTo, address );

                msg->StorePropertiesL();

                //iLog->Log( _L("  msgId=%x, flags=%x, size=%d, date=%Ld"), msg->Id(), flags, size, date );

                //iLog->Log( _L("  subject=%S"), &subject );

                address.Close();

                CleanupStack::PopAndDestroy( msg );

                }

            //update iMatches[1]

        } while ( hasMore );

        //testing IdsAndFlags

        iLog->Log( _L("Case %d: Testing IdsAndFlagsL()"), iCaseId++ );

        RArray<TMsgStoreIdAndFlag> idsAndFlags;

        iterator->IdsAndFlagsL( idsAndFlags );

        iLog->Log( _L("  IdsAndFlagsL returned %d objects"), idsAndFlags.Count() );        

        idsAndFlags.Reset();

        //testing get sorted MessageIds

        iLog->Log( _L("Case %d: Testing MessageIdsL()"), iCaseId++ );

        RArray<TMsgStoreId> ids;

        //start sorting

        iterator->MessageIdsL( ids );        

        iLog->Log( _L("  MessageIds returned %d objects"), ids.Count() );        

        ids.Reset();

        //testing IdsAndGroupCount

        iLog->Log( _L("Case %d: Testing IdsAndGroupCountL()"), iCaseId++ );

        RArray<TUint> itemCounts;

        CleanupClosePushL( itemCounts );

        iterator->IdsAndGroupCountL( ids, itemCounts );        

        iLog->Log( _L("  GroupCount=%d"), itemCounts.Count() );

        //if ( itemCounts.Count() > 0 )

        //    {

        //    TInt needNToBeMod8 = 8 - itemCounts.Count() % 8;

        //    if ( needNToBeMod8 != 8 )

        //        {

        //        for ( TInt i = 0 ; i < needNToBeMod8 ; i++ )

        //            {

        //            itemCounts.Append(0);

        //            }

        //        }

        //    

        //    for ( TInt i = 0 ; i < itemCounts.Count() ; i += 8 )

        //        {

        //        iLog->Log( _L("  counts: %d, %d, %d, %d, %d, %d, %d, %d"), 

        //                itemCounts[i], itemCounts[i+1], itemCounts[i+2], itemCounts[i+3],

        //                itemCounts[i+4], itemCounts[i+5], itemCounts[i+6], itemCounts[i+7] );

        //        }

        //    }            

        CleanupStack::PopAndDestroy( &itemCounts );

        iLog->Log( _L("  MessageIds returned %d objects"), ids.Count() );

        ids.Reset();

        iLog->Log( _L("Case %d: Testing IndexOfL()"), iCaseId++ );

        //add a message after the iterator has been created

        CreateRandomMessagesL( mailBox, inboxId, 1, ETrue, ETrue );

        TInt index = iterator->IndexOfL( iMatches[0] );

        iLog->Log( _L("  id=%08x, index=%d"), iMatches[0], index);        

        delete iterator;

        bucketSizeArray.Append( bucketSize );

        }  //end for

    results.ResetAndDestroy();

    iMatches.Reset();

    CMsgStoreAccount* account2 = CMsgStoreAccount::NewLC( 9999, _L("") );         //+3

    CMsgStoreMailBox* mailBox2;

    TRAPD(err, mailBox2 = iMsgStore->OpenAccountL( *account2 ) )

    if ( err != KErrNone )

        {

        mailBox2 = iMsgStore->CreateAccountL( *account2 );

        }

    CleanupStack::PushL( mailBox2 );                                             //+4

    CMsgStorePropertyContainer* prop2 = CMsgStorePropertyContainer::NewL();     

    CleanupStack::PushL( prop2 );                                                //+5

    TMsgStoreId folder2;

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

        {

        folder2 = mailBox2->CreateFolderL( mailBox2->Id(), *prop2 );

        CreateRandomMessagesL( mailBox2, folder2, 50 );

        criteriaArray[0].iFolderId = folder2;

        criteriaArray[criteriaArray.Count()-1].iFolderId = folder2;

        CMsgStoreSortResultIterator* iterator1 = mailBox2->SortL( criteriaArray[0] ); 

        CMsgStoreSortResultIterator* iterator2 = mailBox2->SortL( criteriaArray[criteriaArray.Count()-1] ); 

        iterator1->NextL( KMsgStoreSortResultTop, 20, results );

        CheckCondition( _L("traverse halfway"), results.Count() == 20 );

        results.ResetAndDestroy();

        //now we have two sort session, one traversed to half way, one not travesed yet

        if ( i == 0 )

            {

            iLog->Log( _L("Case %d: Testing delete folder while iterator is open"), iCaseId++ );

            //delete the 

            mailBox2->DeleteFolderL( folder2 );

            }

        else

            {

            //delete the 

            iLog->Log( _L("Case %d: Testing delete mailbox while iterator is open"), iCaseId++ );

            iMsgStore->DeleteAccountL( *account2 );

            }

        TBool hasMore = iterator1->NextL( KMsgStoreSortResultTop , 20, results );

        CheckCondition( _L("hasMore==EFalse"), !hasMore );

        CheckCondition( _L("no result"), results.Count() == 0 );

        hasMore = iterator2->NextL( _L("nzz") , 20, results );

        CheckCondition( _L("hasMore==EFalse"), !hasMore );

        CheckCondition( _L("no result"), results.Count() == 0 );

        delete iterator1;

        delete iterator2;

        }

    for ( int i = 0 ; i < criteriaArray.Count() ; i++ )

        {

        criteriaArray[i].Close();

        }

    criteriaArray.Close();

    iteratorArray.ResetAndDestroy();

    curIdArray.Close();

    hasMoreArray.Close();

    checkDirectionArray.Close();

    bucketSizeArray.Close();

    CleanupStack::PopAndDestroy( 5 );