/*
* Copyright (c) 2005-2008 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: CMMCScBkupFileListCollection implementation
*
*
*/

#include "CMMCScBkupFileListCollection.h"

#include <bldvariant.hrh>
#include <pathinfo.h>

// User includes
#include "MMCScBkupLogger.h"
#include "CMMCScBkupDataOwnerInfo.h"
#ifdef RD_FILE_MANAGER_BACKUP
#include <driveinfo.h>
#include "BkupEngine.hrh"
#include "pathconfiguration.hrh"
#endif 

// Constants
const TInt KMMCScBkupDataOwnerGranularity = 50;




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

// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::CMMCScBkupFileListCollection()
// 
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupFileListCollection::CMMCScBkupFileListCollection( TBitFlags aCategory, 
    RFs& aFsSession )
    :iEntries(KMMCScBkupDataOwnerGranularity), 
    iCategory( aCategory ),
    iFsSession( aFsSession )
    {
    }

// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::~CMMCScBkupFileListCollection()
// 
// Destructor.
// ---------------------------------------------------------------------------
CMMCScBkupFileListCollection::~CMMCScBkupFileListCollection()
    {
    Reset();
    iEntries.Close();
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::ConstructL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupFileListCollection::ConstructL()
    {
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::NewL()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupFileListCollection* CMMCScBkupFileListCollection::NewL( TBitFlags aCategory,
    RFs& aFsSession )
    {
    CMMCScBkupFileListCollection* self = new(ELeave) CMMCScBkupFileListCollection( aCategory, aFsSession );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::AppendL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupFileListCollection::AppendL( const RArray<TEntry>& aArray, RArray< const CMMCScBkupFileInfo* >& aAddedItems, TSecureId aAssociatedSID )
    {
    const TInt count = aArray.Count();

    __LOG2("CMMCScBkupFileListCollection::AppendL() - Number of files %d to check for category %x", count, Category().Value() );
    
    for(TInt i=0; i<count; i++)
        {
        const TEntry& entry = aArray[i];
#ifdef RD_FILE_MANAGER_BACKUP
        TBool skipFile = EFalse;

        if(Category().Value() != EBUCatUserFiles && Category().Value() != EBUCatAllInOne)
            {
            // Check whether public file in system user data folder. If it is and not part of
            // user file category, then discard file from collection
            const TDesC& path = PathInfo::PhoneMemoryRootPath();
            TInt error = entry.iName.FindF(path);
            if(error != KErrNotFound)
                {
                __LOG1("CMMCScBkupFileListCollection::AppendL() - Skipping file %S", &entry.iName );
                skipFile = ETrue;
                }
            }
        else if(Category().Value() == EBUCatUserFiles)
            {
            // Check also if public file is from mass-storage. If yes and user-files category in
            // question, prevent file getting backed up, because otherwise it is probable 2 GB 
            // get exceeded and we cannot save larger than 2 GB archive. Allow public files being 
            // backed up in other categories.
            TUint drvStatus( 0 );
            TInt drive( KErrNotFound );
            
            if( RFs::CharToDrive( entry.iName[0], drive ) != KErrNone )
                {
                drive = KErrNotFound;
                }
            
            TInt err = DriveInfo::GetDriveStatus(iFsSession, drive, drvStatus );
            
            if ( err == KErrNone && ( drvStatus & DriveInfo::EDriveInternal ) &&
                 ( drvStatus & DriveInfo::EDriveExternallyMountable ) )
                {
                __LOG1("CMMCScBkupFileListCollection::AppendL() - Skipping file %S due it in mass storage", &entry.iName );
                skipFile = ETrue;
                }
            }

        if(!skipFile)
#endif // RD_FILE_MANAGER_BACKUP
            {
            // Check whether the file is already present before adding it (avoid duplicate 
            // public files)
            CMMCScBkupFileInfo* fileInfo = CMMCScBkupFileInfo::NewLC( entry, aAssociatedSID );

            TLinearOrder<CMMCScBkupFileInfo> comparer( CMMCScBkupFileInfo::OrderByFileName );
            const TInt indexIfFound = iEntries.FindInOrder( fileInfo, comparer );
            if  (indexIfFound < 0)
                {
                // Item wasn't found - insert it in sorted order
                AppendL( fileInfo );
                CleanupStack::Pop( fileInfo );
                
                __LOG1("CMMCScBkupFileListCollection::AppendL() - Adding file %S", &fileInfo->FileName() );

                // Add a copy to our return array.
                aAddedItems.AppendL( fileInfo );
                }
            else
                {
                // Duplicate, discard
                __LOG1("CMMCScBkupFileListCollection::AppendL() - Duplicate file %S", &fileInfo->FileName() );
                CleanupStack::PopAndDestroy( fileInfo );
                }
            }
        }
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::AppendL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupFileListCollection::AppendL( CMMCScBkupFileInfo* aFileInfo )
    {
    TLinearOrder<CMMCScBkupFileInfo> comparer( CMMCScBkupFileInfo::OrderByFileName );
    iEntries.InsertInOrderL( aFileInfo, comparer );
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::Count()
// 
// 
// ---------------------------------------------------------------------------
TInt CMMCScBkupFileListCollection::Count() const
    {
    return iEntries.Count();
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::Entry()
// 
// 
// ---------------------------------------------------------------------------
const CMMCScBkupFileInfo& CMMCScBkupFileListCollection::Entry(TInt aIndex) const
    {
    const CMMCScBkupFileInfo& entry = *iEntries[aIndex];
    return entry;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::Remove()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupFileListCollection::Remove( TInt aIndex )
    {
    CMMCScBkupFileInfo* entry = iEntries[aIndex];
    delete entry;
    iEntries.Remove(aIndex);
    }


// ---------------------------------------------------------------------------
// CMMCScBkupFileListCollection::Reset()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupFileListCollection::Reset()
    {
    iEntries.ResetAndDestroy();
    }