/*

* Copyright (c) 2009 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:

*     Zhiqiang Yang <zhiqiang.yang@nokia.com>

* 

* Description:

*     The source file of the file manager utilities

*/

#include "fmutils.h"

#include "fms60utils.h"

#include "fmcommon.h"

#include <QRegExp>

#include <coemain.h>

#include <driveinfo.h>

#include <e32property.h>

#include <coreapplicationuisdomainpskeys.h>

#include <f32file.h>

#include <apgcli.h>

#include <pathinfo.h>

#include <XQConversions>

#include <QStringList>

#include <QFileInfoList>

#include <QDir>

#include <QFile>

#include <xqaiwrequest.h>

#include <xqappmgr.h>

#include <shareuidialog.h>

#define BURCONFIGFILE  "z:/private/2002BCC0/burconfig.xml"

QString FmUtils::getDriveNameFromPath( const QString &path )

{

    if( path.length() <3 ) {

        return QString();

    }

    return path.left( 3 );

}

FmDriverInfo FmUtils::queryDriverInfo( const QString &driverName )

{

	CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

	TVolumeInfo volumeInfo;

	TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

	fs.Volume( volumeInfo, drive );

    QString volumeName( (QChar*)( volumeInfo.iName.Des().Ptr() ), volumeInfo.iName.Length() );

	return FmDriverInfo( volumeInfo.iSize, volumeInfo.iFree, driverName, volumeName );

}

QString FmUtils::formatStorageSize( quint64 size )

{

	if ( size < 1000 ) {

		return QString::number( size ) + " B";

	} else if ( size < 1000 * 1000 ) {

		return QString::number( size / 1024.0, 'f', 2 ) + " KB";

	} else if ( size < 1000 * 1000 * 1000 ) {

		return QString::number( size / (1024.0 * 1024.0), 'f', 1 ) + " MB";

	} else {

	    return QString::number( size / ( 1024.0 * 1024.0 * 1024.0 ), 'f', 1 ) + " GB";	    

	}

}

quint32 FmUtils::getDriverState( const QString &driverName )

{    

    quint32 state( 0 );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

	TVolumeInfo volumeInfo;

	TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

	int err = fs.Volume( volumeInfo, drive );

	//handle error code

	if( err != KErrNone ) {

            state |= FmDriverInfo::EDriveNotPresent;

	}

	if ( err == KErrLocked ) {

            state |= FmDriverInfo::EDriveLocked;

	}

    TDriveInfo driveInfo = volumeInfo.iDrive;

    quint32 drvStatus( 0 );

    DriveInfo::GetDriveStatus( fs, drive, drvStatus );

    QString logString = driverName +':'+ QString::number( drvStatus);

    FmLogger::log(logString);

    if ( ( drvStatus & DriveInfo::EDriveInternal ) &&

         ( drvStatus & DriveInfo::EDriveExternallyMountable ) ){

        // Handle mass storage bits here

        state |= FmDriverInfo::EDriveMassStorage | FmDriverInfo::EDriveRemovable;

    }

    if ( drvStatus & DriveInfo::EDriveRom ){

        state |= FmDriverInfo::EDriveRom;  

    }

    if ( drvStatus & DriveInfo::EDriveRam ){

        state |= FmDriverInfo::EDriveRam;  

    }

    if ( driveInfo.iMediaAtt & KMediaAttFormattable ){

        state |= FmDriverInfo::EDriveFormattable;

    }

    if ( driveInfo.iMediaAtt & KMediaAttWriteProtected ){

        state |= FmDriverInfo::EDriveWriteProtected;

    }

    if ( driveInfo.iMediaAtt & KMediaAttHasPassword ){

        state |= FmDriverInfo::EDrivePasswordProtected;

    }    

    if ( driveInfo.iMediaAtt & KMediaAttLocked ){

        state |= FmDriverInfo::EDriveLocked;

    }

    if ( driveInfo.iDriveAtt & KDriveAttRemovable ){

        state |= FmDriverInfo::EDriveRemovable;

        if ( drvStatus & DriveInfo::EDriveSwEjectable ){

            state |= FmDriverInfo::EDriveEjectable;

        }

    }

    if( driveInfo.iType == EMediaNotPresent ){

        state |= FmDriverInfo::EDriveNotPresent;    

    }

    return state;

}

int FmUtils::removeDrivePwd( const QString &driverName,  const QString &Pwd )

{

    QString logString = "Drive name:" + driverName;

    FmLogger::log( logString );

    logString = "Password:" + Pwd;

    FmLogger::log( logString );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    HBufC* password16 = XQConversions::qStringToS60Desc( Pwd );

    TMediaPassword password;   

    TPtr ptrPassword16( password16->Des() );  

    FmS60Utils::ConvertCharsToPwd( ptrPassword16, password );

    int err( fs.ClearPassword( drive, password ) );

    logString = "Drive:" + QString::number( drive );

    FmLogger::log( logString );

    logString = "Clear password error:" + QString::number( err );

    FmLogger::log( logString );

    return err;

}

int FmUtils::unlockDrive( const QString &driverName,  const QString &Pwd )

{

    QString logString = "Drive name:" + driverName;

    FmLogger::log( logString );

    logString = "Password:" + Pwd;

    FmLogger::log( logString );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    HBufC* password16 = XQConversions::qStringToS60Desc( Pwd );

    TMediaPassword password;   

    TPtr ptrPassword16( password16->Des() );  

    FmS60Utils::ConvertCharsToPwd( ptrPassword16, password );

    int err( fs.UnlockDrive( drive, password, ETrue) );

    logString = "Drive:" + QString::number( drive );

    FmLogger::log( logString );

    logString = "Unlock drive error:" + QString::number( err );

    FmLogger::log( logString );

    return err;

}

int FmUtils::setDrivePwd( const QString &driverName, const QString &oldPwd, const QString &newPwd)

{

    QString logString = "Drive name:" + driverName;

    FmLogger::log( logString );

    logString = "Old password:" + oldPwd;

    FmLogger::log( logString );

    logString = "New password:" + newPwd;

    FmLogger::log( logString );

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    HBufC* newPassword16 = XQConversions::qStringToS60Desc( newPwd);

    HBufC* oldPassword16 = XQConversions::qStringToS60Desc( oldPwd );

    TMediaPassword oldPassword;

    TMediaPassword newPassword;

    TPtr ptrNewPassword16( newPassword16->Des() );

    TPtr ptrOldPassword16( oldPassword16->Des() );

    FmS60Utils::ConvertCharsToPwd( ptrNewPassword16, newPassword );

    FmS60Utils::ConvertCharsToPwd( ptrOldPassword16, oldPassword );

    //oldPassword.FillZ(oldPassword.MaxLength());

    //oldPassword.Zero();

    //newPassword.Copy(_L8("A"));

    int err( fs.LockDrive( drive, oldPassword, newPassword, ETrue ) );

    logString = "Drive:" + QString::number( drive );

    FmLogger::log( logString );

    logString = "Password set error:" + QString::number( err );

    FmLogger::log( logString );

    return err;

}

void FmUtils::emptyPwd( QString &pwd )

{

    TPtr des ( ( XQConversions::qStringToS60Desc( pwd ) )->Des() );

    des.FillZ( des.MaxLength() );

    des.Zero();

    pwd = XQConversions::s60DescToQString( des );

}

int FmUtils::renameDrive( const QString &driverName, const QString &newVolumeName)

{

    CCoeEnv *env = CCoeEnv::Static();

	RFs& fs = env->FsSession();

    TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    TPtr newName ( ( XQConversions::qStringToS60Desc( newVolumeName ) )->Des() );

    int err( fs.SetVolumeLabel( newName, drive ));

    QString logString = "Rename error:" + QString::number( err );

    FmLogger::log( logString );

    return err;

}

int FmUtils::ejectDrive( const QString &driverName )

{

    CCoeEnv *env = CCoeEnv::Static();

    RFs& fs = env->FsSession();

    TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    const int KDriveShift = 16;

    TFileName fileSystemName;

    TInt err = fs.FileSystemName( fileSystemName, drive );

    RProperty::Set(

        KPSUidCoreApplicationUIs,

        KCoreAppUIsMmcRemovedWithoutEject,

        ECoreAppUIsEjectCommandUsedToDrive | ( drive << KDriveShift )

        );

    err = fs.DismountFileSystem( fileSystemName, drive );

    if (err == KErrNone){

        // remount the file system

        err = fs.MountFileSystem( fileSystemName, drive );

        if (err == KErrInUse){

            // try to remount after a while if locked

            User::After(1000000);

            err = fs.MountFileSystem( fileSystemName, drive );

        }                

    }

    return err;

}

int FmUtils::formatDrive( const QString &driverName )

{

    RFormat format;

//    CCoeEnv *env = CCoeEnv::Static();

//	RFs& fs = env->FsSession();

    RFs fs;

    int err = fs.Connect();

    if( err != KErrNone ){

        return FmErrTypeFormatFailed;

    }

    TInt drive = 0;

	drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    TDriveName formatDriveName( TDriveUnit( drive ).Name() );

    int finalValue = 0;

    format.Close();

    err = format.Open(

        fs, formatDriveName, EFullFormat | ESpecialFormat, finalValue );

    QString logString = "Format open error:" + QString::number( err );

    FmLogger::log( logString );

    if( err == KErrLocked ){

        err = fs.ErasePassword( drive );

        logString = "ErasePassword error:" + QString::number( err );

        FmLogger::log( logString );

        if( err == KErrNone ){

            err = format.Open(

               fs, formatDriveName, EFullFormat, finalValue ); 

            logString = "Second format open error:" + QString::number( err );

            FmLogger::log( logString );

        }

    }

    if (err == KErrInUse){

        TBool reallyFormat = ETrue;

        if (reallyFormat)

            {

            err = format.Open(

                    fs, formatDriveName, EFullFormat | EForceFormat, finalValue );

            logString = "Reallyformat open error:" + QString::number( err );

            FmLogger::log( logString );

            }

    }

    TFullName fsName;

    if ( err == KErrNone )

        {

        err = fs.FileSystemName( fsName, drive  );

        logString = "FileSystemName error:" + QString::number( err );

        FmLogger::log( logString );

        if ( err == KErrNone && fsName.Length() > 0 )

            {

            // Prevent SysAp shutting down applications

            RProperty::Set(

                    KPSUidCoreApplicationUIs,

                    KCoreAppUIsMmcRemovedWithoutEject,

                    ECoreAppUIsEjectCommandUsed );

            logString = "Prevent SysAp shutting down applications" ;

            FmLogger::log( logString );

            }

        else

            {

            // Don't continue with format if there is no file system name

            // or file system name could not be obtained.

            err = KErrCancel;

            logString = "Format cancel:" + QString::number( err );

            FmLogger::log( logString );

            }

        }

    if( err == KErrNone &&  finalValue ){

        while ( finalValue ){        

            logString = "Format tracks:" + QString::number( finalValue );

            FmLogger::log( logString );

            err = format.Next( finalValue );

            if( err != KErrNone ){ 

                logString = "Format error:" + QString::number( err );

                FmLogger::log( logString );

                break; 

            }

        }

    }

    if( !finalValue || err != KErrNone ){

        format.Close();        

        fs.Close();

        createDefaultFolders( driverName );

    }

    return FmErrNone;

}

QString FmUtils::getFileType( const QString &filePath  )

{

    RApaLsSession apaSession;

    TDataType dataType;

    TUid appUid;

    TBuf<128> mimeTypeBuf;

    int err = apaSession.Connect();

    if ( err == KErrNone ){   

        err = apaSession.AppForDocument( XQConversions::qStringToS60Desc( filePath )->Des(), 

                                         appUid, dataType );

        if( err == KErrNone ){

            mimeTypeBuf.Copy(dataType.Des8());

        }  

    }

    apaSession.Close();

    return XQConversions::s60DescToQString( mimeTypeBuf );

}

quint64 FmUtils::getDriveDetailsResult( const QString &folderPath, const QString &extension )

{

    int err;

//    CCoeEnv *env = CCoeEnv::Static();

//    RFs& fs = env->FsSession();

    RFs fs;

    err = fs.Connect();

    QString string( folderPath );

    QRegExp regExp( "/" );

    string.replace( regExp, "\\" );

    if( string.right( 1 )!= "\\"){

        string.append( "\\" );

    }

    TPtrC desFolderPath( XQConversions::qStringToS60Desc( string )->Des() );

    TPtrC ptrExtension( XQConversions::qStringToS60Desc( extension )->Des() );

    CDir* results = 0;

    TParse parse;

    quint64 size = 0;

    const TInt pathlength = ptrExtension.Length() + desFolderPath.Length();

    if ( pathlength > KMaxFileName ){

        err = KErrNotFound;   

    }

    else{

        err = fs.Parse( ptrExtension, desFolderPath, parse );

        err = fs.GetDir( parse.FullName(), KEntryAttMaskSupported|KEntryAttAllowUid, 

            ESortNone, results );

        TDesC des = parse.FullName();

        if (err == KErrNotFound)

            {

            return 0;

            }

    }

    if ( results ){

        CleanupStack::PushL(results);

        // Go through all files in the list and tell subclass

        TFileName file;

        const TInt count = results->Count();

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

            const TEntry& entry = (*results)[i];

            file = desFolderPath;

            file += entry.iName;

            size += entry.iSize;          

        }

        CleanupStack::PopAndDestroy(results);

    }

    fs.Close();

    return size;  

}

bool FmUtils::isDriveC( const QString &driverName )

{

    TInt drive = 0;

    drive = driverName[0].toUpper().toAscii() - 'A' + EDriveA;

    if( drive == EDriveC ){

        return true;

    }

    else{

        return false;

    }

}

void FmUtils::createDefaultFolders( const QString &driverName )

{

    int err;