/*
* Copyright (c) 2007-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:  
*  Version     : %version:  9 % << Don't touch! Updated by Synergy at check-out.
*
*/

#include <sysutil.h> 
#include "hnxmlsuitefilesreg.h"
#include "hnglobals.h"
#include "hnconvutils.h"
#include "menudebug.h"
#include "hnhelper.inl"

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

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CHnXmlSuiteFilesReg::SynchronizeL( RFs & aFs, const TDesC &aSuiteName )
	{
	CHnXmlSuiteFilesReg* self = new (ELeave) CHnXmlSuiteFilesReg( aFs );
	CleanupStack::PushL(self);
	self->ConstructL( aSuiteName );
	TBool ret = self->SynchronizeSuiteFilesL();
	CleanupStack::PopAndDestroy( self );
	return ret;
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnXmlSuiteFilesReg::~CHnXmlSuiteFilesReg()
	{
	iSuiteName.Close();
	DestroySuiteFilesMaps();
	delete iFileMan;
	}
   
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
CHnXmlSuiteFilesReg::CHnXmlSuiteFilesReg( RFs & aFs ) : iFs(aFs),
	iSuiteFiles(&TDesC16Hash, &TDesC16Ident)
	{

	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//   
HBufC* CHnXmlSuiteFilesReg::GetSuiteInstallPathL()
	{
	TBuf<KMaxPath> installPath;	
	User::LeaveIfError( iFs.PrivatePath(installPath) );
	TChar drive;
	TBuf<1> driveLetter;
	iFs.DriveToChar( EDriveC, drive );
	installPath.Insert(0, KColon );
	driveLetter.Append( drive );
	installPath.Insert(0, driveLetter );
	installPath.Append(KEntriesSuffix);
	installPath.Append( iSuiteName );
	installPath.Append( Kbackslash );
	return installPath.AllocL();
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnXmlSuiteFilesReg::ConstructL( const TDesC &aSuiteName )
	{
	iSuiteName.CreateL( aSuiteName );
	iFileMan = CFileMan::NewL(iFs);
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnXmlSuiteFilesReg::DestroySuiteFilesMaps()
	{
	DestroyMapValue( iSuiteFiles );
	iSuiteFiles.Close();
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
HBufC* CHnXmlSuiteFilesReg::GetSuiteImportDirL( TInt aDriveNumber ) const
	{
	TBuf<KMaxPath> outputDir; 
			
	TChar driveLetter;
    User::LeaveIfError( iFs.DriveToChar( aDriveNumber, driveLetter ) );  
    
    TBuf< KSingleChar > driveLetterConst;
    driveLetterConst.Append( driveLetter );
      
    User::LeaveIfError( iFs.PrivatePath( outputDir ) );

    outputDir.Insert( 0, driveLetterConst );
    outputDir.Insert( 1, KColon );
    outputDir.Append( KSuitesDir );
    outputDir.Append( iSuiteName );
    outputDir.Append( Kbackslash );
    
    return outputDir.AllocL();
	}


// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnXmlSuiteFilesReg::SearchDrivesForSuiteFilesL()
    {
    DestroySuiteFilesMaps();
    
    TDriveList driveList;
    User::LeaveIfError( iFs.DriveList( driveList ) );
    TFixedArray< TInt, KMaxDrives > driveSearchOrder( KDriveSearchOrder, KMaxDrives );
    
    for(TInt iterator(0); iterator < driveSearchOrder.Count(); iterator++ )
    	{ 
        if ( driveList[ driveSearchOrder[ iterator ] ] )
            {
            RBuf filePath( GetSuiteImportDirL( driveSearchOrder[ iterator ] ) );
            CleanupClosePushL( filePath );
            SearchDirForSuiteFilesL(filePath);
            CleanupStack::PopAndDestroy( &filePath );
            }
    	} 
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnXmlSuiteFilesReg::SearchDirForSuiteFilesL( const TDesC& aSuitePath )
    {
    CDir* fileList = NULL;
    if (!iFs.GetDir( aSuitePath, KEntryAttMaskSupported, ESortByName, fileList ))
	    {
	    CleanupStack::PushL( fileList );
        for( TInt i( 0 ); i < fileList->Count(); i++ ) 
            {  
            if (! (*fileList)[i].IsDir() )
        	    {
        	    AddSuiteFileToMapL( aSuitePath, (*fileList)[i] );
        	    }
            }
        CleanupStack::PopAndDestroy( fileList );
        }
    }

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
void CHnXmlSuiteFilesReg::AddSuiteFileToMapL( const TDesC& aDir, const TEntry& aFile )
	{
    THnFileInfo fileInfo = { aFile.iName, aDir, aFile.iModified, aFile.iSize };
	fileInfo.iFilePath.Append( aFile.iName );
		
	THnFileInfo** existingFileInfo = iSuiteFiles.Find( &aFile.iName );
	
    TInt newFileDrive( KErrNotFound );
    iFs.CharToDrive( fileInfo.iFilePath[0], newFileDrive );
    
    TBool newerThanExisting( EFalse );
	TInt existingFileDrive( KErrNotFound );
	if ( existingFileInfo )
		{
		iFs.CharToDrive( (*existingFileInfo)->iFilePath[0], existingFileDrive);
        newerThanExisting =
                (*existingFileInfo)->iLastModified < fileInfo.iLastModified &&
                newFileDrive != EDriveZ;
		}
	
    if ( !existingFileInfo || newerThanExisting || existingFileDrive == EDriveZ )
        {
        if( existingFileInfo )
            {
            iSuiteFiles.Remove( &aFile.iName );
            }
        THnFileInfo* fileInfoPointer = new (ELeave) THnFileInfo( fileInfo );
        iSuiteFiles.InsertL( &fileInfo.iFileName, fileInfoPointer );
        }
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TInt CHnXmlSuiteFilesReg::CalculateCurrentSuiteSizeL()
	{
	RBuf suiteInstallDir( GetSuiteInstallPathL() );
	CleanupClosePushL( suiteInstallDir );
	CDir* suiteFileList;                  
	iFs.GetDir( suiteInstallDir, KEntryAttMaskSupported, ESortByName, suiteFileList);
	CleanupStack::PushL(suiteFileList);

	TInt suiteSize(0); 
	for( TInt i(0); suiteFileList && i< suiteFileList->Count(); i++ )  
		{
		suiteSize+= (*suiteFileList)[i].iSize;
		}
	CleanupStack::PopAndDestroy( suiteFileList );
	CleanupStack::PopAndDestroy( &suiteInstallDir );
	return suiteSize;
	}

// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TInt CHnXmlSuiteFilesReg::CalculateSynchronizationSuiteSize()
	{
	TInt retSize( 0 );
	
	THashMapIter< const TDesC*, THnFileInfo* > iter( iSuiteFiles );
	
	while ( iter.NextKey() )
		{
		const THnFileInfo& fileInfo =  **(iter.CurrentValue());
		retSize += fileInfo.iSize;
		}
	
	return retSize;
	}
// ---------------------------------------------------------------------------
// 
// ---------------------------------------------------------------------------
//
TBool CHnXmlSuiteFilesReg::SynchronizeSuiteFilesL()
	{
	TBool ret( EFalse );
	SearchDrivesForSuiteFilesL();

	TInt spaceNeeded = CalculateSynchronizationSuiteSize() -
		CalculateCurrentSuiteSizeL();
	
	RBuf suiteInstallationDir( GetSuiteInstallPathL() );
	CleanupClosePushL( suiteInstallationDir );
	iFileMan->RmDir( suiteInstallationDir );
	if( iSuiteFiles.Count() && ( spaceNeeded < 0 || !SysUtil::DiskSpaceBelowCriticalLevelL(
	        &iFs, spaceNeeded , EDriveC ) ) )
        {
        THashMapIter< const TDesC*, THnFileInfo* > iter( iSuiteFiles );
        iFs.MkDirAll( suiteInstallationDir );
        while( iter.NextKey() )
            {
            const THnFileInfo& fileInfo =  **(iter.CurrentValue());
            TBuf<KMaxPath> filePath( suiteInstallationDir );
            filePath.Append( fileInfo.iFileName );
            if( filePath.Compare( fileInfo.iFilePath ) )
                {
                if( BaflUtils::FileExists( iFs, filePath ) )
                    {
                    iFs.SetAtt( filePath, NULL, KEntryAttReadOnly );
                    iFs.Delete( filePath );
                    }
                iFileMan->Copy(
                        fileInfo.iFilePath,
                        filePath, CFileMan::EOverWrite );
                ret = ETrue;
                }
            }
        }
	CleanupStack::PopAndDestroy( &suiteInstallationDir );
	return ret;
	}