/*

* 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:  Searches items matching with given string in given file system

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <f32file.h>

#include <bautils.h>

#include "CGflmFileFinder.h"

#include "CGflmFileFinderItem.h"

#include "CGflmDriveItem.h"

#include "CGflmDriveResolver.h"

#include "CGflmItemLocalizer.h"

#include "MGflmItemFilter.h"

#include "GflmUtils.h"

// CONSTANTS

const TInt KWildCardSpace = 2;

_LIT( KWildCard, "*" );

const TInt KSearchResultsGranularity = 32;

// ============================= LOCAL FUNCTIONS ===============================

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

// MakeWildStringL

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

//

static HBufC* MakeWildStringL( const TDesC& aString )

    {

    if ( GflmUtils::HasWildCard( aString ) )

        {

        return aString.AllocL();

        }

    HBufC* ret = HBufC::NewL( aString.Length() + KWildCardSpace );

    TPtr ptr( ret->Des() );

    ptr.Copy( KWildCard );

    ptr.Append( aString );

    ptr.Append( KWildCard );

    return ret;

    }

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

// MakeWildPathL

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

//

#if 0

static HBufC* MakeWildPathL( const TDesC& aFolder, const TDesC& aString )

    {

    const TInt KBackslashSpace = 1;

    if ( !GflmUtils::HasWildCard( aString ) )

        {

        return aFolder.AllocL();

        }

    HBufC* ret = HBufC::NewL(

        aFolder.Length() + aString.Length() + KBackslashSpace );

    TPtr ptr( ret->Des() );

    ptr.Copy( aFolder );

    GflmUtils::EnsureFinalBackslash( ptr );

    ptr.Append( aString );

    return ret;

    }

#endif // 0

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

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

// CGflmFileFinder::CGflmFileFinder

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

//

CGflmFileFinder::CGflmFileFinder(

            RFs& aFss,

            CGflmItemLocalizer& aLocalizer,

            CGflmDriveResolver& aResolver,

            const TBool& aCancelIndicator ) :

        iFss( aFss ),

        iItemLocalizer( aLocalizer ),

        iDriveResolver( aResolver ),

        iCancelIndicator( aCancelIndicator ),

        iSearchResults( KSearchResultsGranularity )

    {

    }

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

// CGflmFileFinder::NewL

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

//

CGflmFileFinder* CGflmFileFinder::NewL(

        RFs& aFss,

        CGflmItemLocalizer& aLocalizer,

        CGflmDriveResolver& aResolver,

        const TBool& aCancelIndicator )

    {

    CGflmFileFinder* self = new( ELeave ) CGflmFileFinder( 

        aFss, aLocalizer, aResolver, aCancelIndicator );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CGflmFileFinder::ConstructL

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

//

void CGflmFileFinder::ConstructL()

    {

    iSortCollationMethod = *Mem::CollationMethodByIndex( 0 );

    iSortCollationMethod.iFlags |=

        TCollationMethod::EIgnoreNone | TCollationMethod::EFoldCase;

    }

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

// CGflmFileFinder::~CGflmFileFinder

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

// 

CGflmFileFinder::~CGflmFileFinder()

    {

    delete iSearchFolder;

    delete iSearchFolderWild;

    delete iSearchString;

    delete iSearchStringWild;

    iSearchResults.ResetAndDestroy();

    iSearchResults.Close();

    }

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

// CGflmFileFinder::SetSearchFolderL

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

// 

void CGflmFileFinder::SetSearchFolderL( const TDesC& aSearchFolder )

    {

    delete iSearchFolderWild;

    iSearchFolderWild = NULL;

    delete iSearchFolder;

    iSearchFolder = NULL;

    iSearchFolder = aSearchFolder.AllocL();

    }

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

// CGflmFileFinder::SetSearchStringL

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

// 

void CGflmFileFinder::SetSearchStringL( const TDesC& aSearchString )

    {

    delete iSearchFolderWild;

    iSearchFolderWild = NULL;

    delete iSearchString;

    iSearchString = NULL;

    iSearchString = aSearchString.AllocL();

    delete iSearchStringWild;

    iSearchStringWild = NULL;

    iSearchStringWild = MakeWildStringL( aSearchString );

    }

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

// CGflmFileFinder::RefreshL

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

// 

void CGflmFileFinder::RefreshL(

        MGflmItemFilter* aFilter,

        TGflmSortMethod aSortMethod,

        TGflmRefreshMode aRefreshMode )

    {

    FUNC_LOG

    INFO_LOG2(

        "CGflmItemGroupImpl::RefreshL-aRefreshMode=%d, aSortMethod=%d",

        aRefreshMode, aSortMethod )

    if ( aRefreshMode == ERefreshItems )

        {

        TRAPD( err, DoSearchL( aFilter ) );

        // If error just log it and show already found items

        if ( err != KErrNone )

            {

            ERROR_LOG1( "CGflmFileFinder::RefreshL-err=%d", err )

            }

        }

    if ( aSortMethod == EByMatch )

        {

        iSearchResults.Sort( CGflmFileFinderItem::CompareByMatch );

        }

    else

        {

        iSearchResults.Sort( CGflmGroupItem::GetSortL( aSortMethod ) );

        }

    }

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

// CGflmFileFinder::DoSearchL

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

// 

void CGflmFileFinder::DoSearchL( MGflmItemFilter* aFilter )

    {

    FUNC_LOG

    iSearchResults.ResetAndDestroy();

    // Ensure that search data is defined

    if ( !iSearchFolder || !iSearchString || !iSearchStringWild )

        {

        return;

        }

    // Ensure that search drive exists

    CGflmDriveItem* drvItem = iDriveResolver.DriveFromPath( *iSearchFolder );

    if ( !drvItem )

        {

        return;

        }

    if ( !iSearchFolderWild )

        {

#if 0

        if ( iDriveResolver.IsRemoteDrive( *iSearchFolder ) )

            {

            // Some remote drives are case sensitive with wild cards. 

            // Therefore, wild cards cannot be used for remote drives, 

            // because then it is not possible to do case 

            // insensitive comparison like it is done for local drives. 

            iSearchFolderWild = iSearchFolder->AllocL();

            }

        else

            {

            // Do search using the folder with wild string for better performance.

            // It is faster to let file server do the wild matching instead of 

            // reading all subitems under search folder to be matched here.

            // Prepare search folder with wild search string

            iSearchFolderWild = MakeWildPathL(

                *iSearchFolder, *iSearchStringWild );

            }

#else

        // Because of problems with localized folder names, 

        // wild card folder string cannot be given to file server since 

        // file server is not aware of localized names. 

        // This search operation is slower because all items are transferred 

        // here for comparison. 

        iSearchFolderWild = iSearchFolder->AllocL();

#endif

        }

    INFO_LOG1( "CGflmFileFinder::DoSearchL-CDirScan::NewLC-%S",

        iSearchFolderWild )

    CDirScan* dirScan = CDirScan::NewLC( iFss );

    INFO_LOG( "CGflmFileFinder::DoSearchL-CDirScan::SetScanDataL" )

    dirScan->SetScanDataL( *iSearchFolderWild, KEntryAttDir, ESortNone );

    INFO_LOG( "CGflmFileFinder::DoSearchL-CDirScan::NextL" )

    CDir* dir = NULL;

    dirScan->NextL( dir );

    while( dir )

        {

        CleanupStack::PushL( dir );

        if ( iCancelIndicator )

            {

            User::Leave( KErrCancel );

            }

        TPtrC basePath( dirScan->FullPath() );

        INFO_LOG1( "CGflmFileFinder::DoSearchL-Search-%S", &basePath )

        TInt count( dir->Count() );

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

            {

            if ( iCancelIndicator )

                {

                User::Leave( KErrCancel );

                }

            const TEntry& entry( ( *dir )[ i ] );

            TPtrC name( entry.iName );

            TBool isLocalized( EFalse );

            TBool isDir( entry.IsDir() );

            if( isDir )

                {

                // Handle localized name

                GflmUtils::GetFullPath( basePath, entry, iFullPath );

                TPtrC localizedName(

                    iItemLocalizer.LocalizeFromWorkThread( iFullPath ) );

                if ( localizedName.Length() )

                    {

                    name.Set( localizedName );

                    isLocalized = ETrue;

                    }

                }

            // Append matching items

            if( name.MatchC( *iSearchStringWild ) != KErrNotFound )

                {

                CGflmFileFinderItem* finderItem = CGflmFileFinderItem::NewLC(

                    entry, basePath );

                if ( isLocalized )

                    {

                    finderItem->SetLocalizedNameL( name );

                    }

                // Filter out unwanted items

                if ( !aFilter ||

                     ( aFilter && aFilter->FilterItemL(

                        finderItem,

                        isDir ? CGflmGroupItem::EDirectory : CGflmGroupItem::EFile,

                        drvItem ) ) )

                    {

                    finderItem->PrepareSort( *iSearchString );

                    finderItem->SetGroup( this );

                    iSearchResults.AppendL( finderItem );

                    CleanupStack::Pop( finderItem );

                    }

                else

                    {

                    CleanupStack::PopAndDestroy( finderItem );

                    }

                }

            }

        CleanupStack::PopAndDestroy( dir );

        INFO_LOG( "CGflmFileFinder::DoSearchL-CDirScan::NextL" )

        dirScan->NextL( dir );

        }

    CleanupStack::PopAndDestroy( dirScan );

    }

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

// CGflmFileFinder::ItemCount

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

// 

TInt CGflmFileFinder::ItemCount() const

    {

    return iSearchResults.Count();

    }

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

// CGflmFileFinder::Item

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

// 

CGflmGroupItem* CGflmFileFinder::Item( TInt aIndex )

    {

    return iSearchResults[ aIndex ];

    }

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

// CGflmFileFinder::Id

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

// 

TInt CGflmFileFinder::Id() const

    {

    return KErrNotFound;

    }

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

// CGflmFileFinder::AddSourceL

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

// 

void CGflmFileFinder::AddSourceL( const TDesC& /*aDirectory*/ )

    {

    }

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

// CGflmFileFinder::ResetSources

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

// 

void CGflmFileFinder::ResetSources()

    {

    }

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

// CGflmFileFinder::AddActionItemL

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

// 

void CGflmFileFinder::AddActionItemL( TInt /*aId*/, const TDesC& /*aCaption*/ )

    {

    }

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

// CGflmFileFinder::SetInclusion

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

// 

void CGflmFileFinder::SetInclusion( TUint /*aInclusion*/ )

    {

    }

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

// CGflmFileFinder::CollationMethod

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

// 

const TCollationMethod* CGflmFileFinder::CollationMethod()

    {

    return &iSortCollationMethod;

    }

// End of File