/*
* 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 class CIpsSetUiFolderListArray.
*
*/



#include "emailtrace.h"
#include <miuthdr.h>
#include <msvapi.h>
#include <msvuids.h>

#include "ipssetuifoldersubscription.h"
#include "ipssetutilsconsts.h"

#include "ipssetuifolderlistarray.h"

// how the indentation is done 
_LIT( KIndentString, ".." ); 
const TInt KIndentStringLength = 2;  // KIndentString().Length();
#define KMaxIndentLevel 3

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::NewL
// ----------------------------------------------------------------------------
//
CIpsSetUiFolderListArray* CIpsSetUiFolderListArray::NewL(
    CMsvSession& aMsvSession,
    TMsvId aMailboxId )
    {
    FUNC_LOG;
    CIpsSetUiFolderListArray* self=new (ELeave) CIpsSetUiFolderListArray(
        aMsvSession, aMailboxId );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::~CIpsSetUiFolderListArray()
// ----------------------------------------------------------------------------
//
CIpsSetUiFolderListArray::~CIpsSetUiFolderListArray()
    {
    FUNC_LOG;
    iArrayBuf.ResetAndDestroy();
    delete iText;
    delete iEntry;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::ConstructL
// ----------------------------------------------------------------------------
//
void CIpsSetUiFolderListArray::ConstructL()
    {
    FUNC_LOG;
    RefreshFolderListArrayL();

    iText = HBufC::NewL( KIpsSetUiMaxSettingsTextLength );
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::CIpsSetUiFolderListArray
// ----------------------------------------------------------------------------
//
CIpsSetUiFolderListArray::CIpsSetUiFolderListArray(
    CMsvSession& aMsvSession,
    TMsvId aMailboxId)
    :
    iSession( aMsvSession ),
    iMailboxId( aMailboxId )
    {
    FUNC_LOG;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::MdcaPoint
// list item contains: icon_index separator item_text
// ----------------------------------------------------------------------------
//
TPtrC CIpsSetUiFolderListArray::MdcaPoint( TInt aIndex ) const
    {
    FUNC_LOG;
    //    const TMsvEmailEntry emailEntry( (*iEntry)[aIndex] );
    
// firstly switch to correct directory to search for folders
    TMsvId origFolder = iEntry->EntryId();
    TArrayFolderItem * const pArrayItem = iArrayBuf[aIndex]; // not owning
    TMsvId targetFolder = pArrayItem->Parent();
    // if item has subitem it follows immediately
    TBool itemHasChildFolders( ( aIndex < (iCount - 1) ) 
          && (iArrayBuf[aIndex+1]->Parent() == pArrayItem->Id() ) );
// return value init
    TPtr tempText = iText->Des();
    tempText.Zero();

    TInt result( KErrNone );
    if ( origFolder != targetFolder ) 
        {
        TRAP( result, iEntry->SetEntryL( targetFolder ) );
        }
    TMsvEmailEntry emailEntry;
    if ( KErrNone == result )
        {
        TRAP( result, emailEntry = iEntry->ChildDataL( pArrayItem->Id() ) );
        }

    if ( KErrNone != result )    
        {    // Handle error.
            // item index dir or item
            tempText.AppendNum( ( itemHasChildFolders 
                ? EIpsSetUiFolderSubfoldersUnsubbed 
                : EIpsSetUiFolderSingleUnsubbed ) );
            tempText.Append( KColumnListSeparator );
            // but name can't be find
            return tempText;
        }
//    const TMsvEmailEntry emailEntry( curentEntry );

    TInt iconIndex = 0;
    if ( itemHasChildFolders )
        {
        iconIndex = ( emailEntry.LocalSubscription() ?
            EIpsSetUiFolderSubfoldersSubbed : EIpsSetUiFolderSubfoldersUnsubbed );
        }
    else
        {
        iconIndex = ( emailEntry.LocalSubscription() ?
            EIpsSetUiFolderSingleSubbed : EIpsSetUiFolderSingleUnsubbed );
        }
    
    tempText.AppendNum( iconIndex );
    tempText.Append( KColumnListSeparator );

    // add indentation text of subfolders 2,4 or 6 dots 
    TInt i = ( ( pArrayItem->IndentLevel() >= KMaxIndentLevel ) 
            ? KMaxIndentLevel : pArrayItem->IndentLevel() );
    TInt siz ( KIpsSetUiMaxSettingsTextLength -  i * KIndentStringLength ); 
    for ( ; i > 0; i-- ) 
        {
        tempText.Append(KIndentString);
        }

    // add item text
    tempText.Append( emailEntry.iDetails.Left( siz ) );
    
    return tempText;
    
    }


// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::MdcaCount
// ----------------------------------------------------------------------------
//
TInt CIpsSetUiFolderListArray::MdcaCount() const
    {
    FUNC_LOG;
    return iCount;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::Id
// ----------------------------------------------------------------------------
//
TMsvId CIpsSetUiFolderListArray::Id( TInt aIndex )
    {
    FUNC_LOG;
//    return (*iEntry)[aIndex].Id();
    return iArrayBuf[aIndex]->Id();
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::ChangEIpsSetUiFolderL
// ----------------------------------------------------------------------------
//
void CIpsSetUiFolderListArray::ChangEIpsSetUiFolderL( TMsvId aFolderId )
    {
    FUNC_LOG;
    iEntry->SetEntryL( aFolderId );
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::ContextHasChildren
// ----------------------------------------------------------------------------
//
TBool CIpsSetUiFolderListArray::ContextHasChildren( TMsvId aId ) const
    {
    FUNC_LOG;
    return ContextHasChildFolders( aId );
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::ContextHasChildFolders
// ----------------------------------------------------------------------------
//
TBool CIpsSetUiFolderListArray::ContextHasChildFolders( TMsvId aId ) const
    {
    FUNC_LOG;
    TBool hasFolders = EFalse;
    TRAPD( error, hasFolders = DoContextHasChildFoldersL( aId ) );
    if ( error != KErrNone )
        {
        return EFalse;
        }
    return hasFolders;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::DoContextHasChildFoldersL
// ----------------------------------------------------------------------------
//
TBool CIpsSetUiFolderListArray::DoContextHasChildFoldersL( TMsvId aId ) const
    {
    FUNC_LOG;
    TMsvSelectionOrdering selectionOrdering(
        KMsvGroupByType, EMsvSortByDetails, ETrue );
    CMsvEntry* entry = CMsvEntry::NewL(iSession, aId, selectionOrdering);
    CleanupStack::PushL( entry );
    TBool retval ( ( entry->Count() > 0 ) && ( KUidMsvFolderEntry == (*entry)[0].iType ) ); 
    CleanupStack::PopAndDestroy( entry );
    return retval;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::GetContextChildrenL
// ----------------------------------------------------------------------------
//
CMsvEntrySelection* CIpsSetUiFolderListArray::GetContextChildrenL(
    TMsvId aId,
    CMsvEntry& aEntry ) const
    {
    FUNC_LOG;
    TMsvSelectionOrdering selectionOrdering(
        KMsvGroupByType, EMsvSortByDetails, ETrue );
    aEntry.SetEntryL( aId );
    aEntry.SetSortTypeL( selectionOrdering );
    CMsvEntrySelection* sel = aEntry.ChildrenWithTypeL( KUidMsvFolderEntry );
    CleanupStack::PushL( sel );

    TInt i;
    TInt cnt = sel->Count();

    for( i=0; i<cnt; i++ )
        {
        if( ContextHasChildren( sel->At(i) ) )
            {
            //Note! recursion
            CMsvEntrySelection* selection =
                GetContextChildrenL( sel->At(i), aEntry );
            CleanupStack::PushL( selection );
            TInt c = selection->Count();

            TInt j;
            for( j=0; j<c; j++ )
                {
                sel->AppendL( selection->At(j) );
                }
            CleanupStack::PopAndDestroy( selection );
            }
        }

    CleanupStack::Pop( sel );
    return sel;
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::FoldersUpdated
// ----------------------------------------------------------------------------
//
TBool CIpsSetUiFolderListArray::FoldersUpdated() const
    {
    FUNC_LOG;
    return ( iEntry->Count() > 0 ? ETrue : EFalse );
    }


// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::RefreshFolderListArrayL
// original function 
// ----------------------------------------------------------------------------

void CIpsSetUiFolderListArray::RefreshFolderListArrayL()
    {
    FUNC_LOG;
    if( iEntry )
        {
        delete iEntry;
        iEntry = NULL;
        }
    iCount = 0;
    
    iEntry = iSession.GetEntryL( iMailboxId );
    const TMsvSelectionOrdering originalOrdering=iEntry->SortType();
    TMsvSelectionOrdering newOrdering=originalOrdering;
    newOrdering.SetShowInvisibleEntries(ETrue);
    newOrdering.SetGroupByType(ETrue);
    newOrdering.SetSorting( EMsvSortByDetails );
    iEntry->SetSortTypeL(newOrdering);

    // code to fill in internal array
    TInt arrayIndex(0);
    TInt size = iArrayBuf.Count();
    iArrayBuf.ResetAndDestroy();
    if ( size > 8 )
        {
        iArrayBuf.ReserveL(size);
        } 
    RefreshFolderListArrayL(iMailboxId, arrayIndex, 0);
    iArrayBuf.Compress();
    iCount = iArrayBuf.Count();
    
    }

// ----------------------------------------------------------------------------
// CIpsSetUiFolderListArray::RefreshFolderListArrayL(
//      TMsvId aIdFolder, TInt & aArrayIndex, TInt aIndentLevel)
// recursion function to fill in / refresh iArrayBuf.
// ----------------------------------------------------------------------------
void CIpsSetUiFolderListArray::RefreshFolderListArrayL(
                       TMsvId aIdFolder, TInt & aArrayIndex, TInt aIndentLevel)
    {
    TMsvId origFolder = iEntry->EntryId();
    if ( origFolder != aIdFolder ) 
        iEntry->SetEntryL( aIdFolder );
    CMsvEntrySelection* sel = iEntry->ChildrenWithTypeL( KUidMsvFolderEntry );
    CleanupStack::PushL( sel );
    TInt count = sel->Count();
    for (TInt i = 0; i < count; i++)
        {
        const TMsvEmailEntry emailEntry( (*iEntry)[i] );
        TArrayFolderItem * item = new (ELeave) TArrayFolderItem( emailEntry.Id(), aIdFolder, aIndentLevel );
        CleanupStack::PushL( item );
        if ( iArrayBuf.Count() > aArrayIndex + 1 )
            {
            if ( iArrayBuf[aArrayIndex] ) 
                {
                delete iArrayBuf[aArrayIndex];
                }
            iArrayBuf[aArrayIndex] = item;
            }
        else
            {
            iArrayBuf.AppendL( item );
            }
//        iArrayBuf.Insert( item, aArrayIndex );
        aArrayIndex++;
        CleanupStack::Pop( item );
        // recursion is here
        RefreshFolderListArrayL(emailEntry.Id(), aArrayIndex, aIndentLevel + 1 );
        }
    CleanupStack::PopAndDestroy( sel );
    iEntry->SetEntryL( origFolder );
    }

// End of File