/*

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

*

*/

// INCLUDE FILES

#include "FBFileUtils.h"

#include "FBFileOps.h"

#include "engine.h"

#include "FB.hrh"

#include <filebrowser.rsg>

#include <textresolver.h> 

#include <eikprogi.h>

#include <e32svr.h>

#include <eikfutil.h>

#include <apparc.h>

#include <apaid.h>

#include <apaidpartner.h>

#include <eikenv.h>

#include <bautils.h>

#include <gulicon.h>

#include <babackup.h> 

//#include <aknmemorycardui.mbg>

#include <sendui.h>

#include <CMessageData.h>

#include <ezgzip.h>

#include <e32hal.h>

#include <pathinfo.h>

#include <apgcli.h>

#include <apmstd.h>

#include <apgtask.h>

#include <apacmdln.h>

#include <DocumentHandler.h>

#include <msvapi.h>

#include <msvids.h>

#include <msvstd.h>

#include <msvstore.h>

#include <mmsvattachmentmanager.h>

#include <cmsvattachment.h>

#include <hash.h>

//#include <sbeclient.h>

#include <e32property.h>

#if (!defined __SERIES60_30__ && !defined __SERIES60_31__) 

#include <driveinfo.h>

#endif // !defined __SERIES60_30__ && !defined __SERIES60_31__

#ifndef __SERIES60_30__

//  #include <akniconconfig.h>

#endif

//_LIT(KGZipExt, ".gz");

_LIT8(KFileNewLine, "\r\n");

const TInt KForcedFormatTimeout = 1000000;

// copied from coreapplicationuisdomainpskeys.h

const TUid KPSUidCoreApplicationUIs = { 0x101F8767 };

const TUint32 KCoreAppUIsMmcRemovedWithoutEject = 0x00000109;

enum TCoreAppUIsMmcRemovedWithoutEject

    {

    ECoreAppUIsEjectCommandUsedUninitialized = 0,

    ECoreAppUIsEjectCommandNotUsed,

    ECoreAppUIsEjectCommandUsed,

    ECoreAppUIsEjectCommandUsedToDrive // Low 16-bits contain this value and high 16-bits TDriveNumber to eject

    };

const TInt KDriveLetterStringLength = 3; // e.g. C:\

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

CFileBrowserFileUtils* CFileBrowserFileUtils::NewL(CEngine* aEngine)

	{

	CFileBrowserFileUtils* self = new(ELeave) CFileBrowserFileUtils(aEngine);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

CFileBrowserFileUtils::CFileBrowserFileUtils(CEngine* aEngine) : CActive(EPriorityStandard), iEngine(aEngine)

	{

	}

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

void CFileBrowserFileUtils::ConstructL()

	{

    User::LeaveIfError(iTimer.CreateLocal());

    User::LeaveIfError(iFs.Connect());

    User::LeaveIfError(iTz.Connect());

    iState = EIdle;

    iListingMode = ENormalEntries;

    iSortMode = EFileBrowserCmdViewSortByName;

    iOrderMode = EFileBrowserCmdViewOrderAscending;

    iCurrentPath = KNullDesC;

    iFileOps = CFileBrowserFileOps::NewL(iEngine);

    iDriveEntryList = new(ELeave) CDriveEntryList(8);

    iFileEntryList = new(ELeave) CFileEntryList(64);

    iFindFileEntryList = new(ELeave) CFileEntryList(64);

    iAppIconList = new(ELeave) CAppIconList(16);

    iClipBoardList = new(ELeave) CFileEntryList(64);

    iCurrentSelectionList = new(ELeave) CFileEntryList(64);

    iDocHandler = CDocumentHandler::NewL();

//    iDocHandler->SetExitObserver(this);

    // set defaults to the search settings

    iSearchAttributes.iSearchDir = KNullDesC;

    iSearchAttributes.iWildCards = _L("*.jpg");

    iSearchAttributes.iTextInFile = KNullDesC;

    iSearchAttributes.iMinSize = 0;

    iSearchAttributes.iMaxSize = 999999999;

    iSearchAttributes.iMinDate = TDateTime(1980, EJanuary,   0,0,0,0,0);

    iSearchAttributes.iMaxDate = TDateTime(2060, EDecember, 30,0,0,0,0);

    iSearchAttributes.iRecurse = ETrue;

    // init the command array

    iCommandArray = new(ELeave) CCommandArray(64);

    // get current path from settings

    if (iEngine->Settings().iRememberLastPath)

        {

        TFileName settingPath = iEngine->Settings().iLastPath;

        if (BaflUtils::PathExists(iFs, settingPath))

            iCurrentPath = settingPath;

        if (iCurrentPath != KNullDesC)

            GetDriveListL();

        }

    CActiveScheduler::Add(this);

    }

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

CFileBrowserFileUtils::~CFileBrowserFileUtils()

	{

	Cancel();

	// save current path from settings

    if (iEngine->Settings().iRememberLastPath)

        {

        iEngine->Settings().iLastPath = iCurrentPath;

        TRAP_IGNORE(iEngine->SaveSettingsL(EFalse));

        }

//    if (iWaitDialog)

//        TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); 

//     

//    if (iProgressDialog)

//        TRAP_IGNORE(iProgressDialog->ProcessFinishedL());

        delete iFileOps;

        delete iDocHandler;

//	if (iOpenFileService)

//	    delete iOpenFileService;

        delete iCurrentSelectionList;

        delete iClipBoardList;

        delete iAppIconList;

        delete iFindFileEntryList;

        delete iFileEntryList;

        delete iDriveEntryList;

        delete iFileMan;

        if (iCommandArray)

            {

            ResetCommandArray();

            delete iCommandArray;

            }

        iTz.Close();

        iFs.Close();

        iTimer.Close();

        }

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

void CFileBrowserFileUtils::DoCancel()

	{

    iTimer.Cancel();

	}

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

void CFileBrowserFileUtils::StartExecutingCommandsL(const TDesC& aLabel)

    {

    if (iCommandArray->Count() >= 2)

        {

        // init progress bar

//        iProgressDialog = new(ELeave) CAknProgressDialog((reinterpret_cast<CEikDialog**>(&iProgressDialog)), ETrue);

//        iProgressDialog->SetCallback(this);

//        iProgressDialog->PrepareLC(R_GENERAL_PROGRESS_NOTE);

//        iProgressDialog->SetCurrentLabelL( EAknCtNote, aLabel );

//        iProgressInfo = iProgressDialog->GetProgressInfoL();

//        iProgressInfo->SetFinalValue( CommandArrayCount() );

//        iProgressDialog->RunLD();

//        iProgressDialog->MakeVisible( ETrue );        

        iEngine->FileBrowserUI()->ShowProgressDialog(aLabel, 0, CommandArrayCount());

        isProgressDialog = ETrue;

        }

    else if (iCommandArray->Count() >= 1)

        {

        // init wait dialog

//        iWaitDialog = new(ELeave) CAknWaitDialog((reinterpret_cast<CEikDialog**>(&iWaitDialog)), ETrue);

//        iWaitDialog->SetCallback(this);

//        iWaitDialog->PrepareLC(R_GENERAL_WAIT_NOTE);

//        iWaitDialog->SetTextL( aLabel );

//        iWaitDialog->RunLD();

        iEngine->FileBrowserUI()->ShowWaitDialog(aLabel);

        isWaitDialog = ETrue;

        }

    else

        {

        // no commands, just do nothing

        return;

        }

    // start with the first operation

    iCurrentEntry = 0;

    iSucceededOperations = 0;

    iFailedOperations = 0;

    // starts executing commands

    ExecuteCommand();

    }

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

void CFileBrowserFileUtils::ExecuteCommand()

    {

    // make sure the engine isn't active, should never happen

    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("FileUtils:IsActive"), 333));

    // execute a command after a very short delay (25ms)

    if (isWaitDialog)

        {

        iEngine->FileBrowserUI()->ProcessEvents();

        }

    if (isProgressDialog)

        {

        TInt newValue = iCurrentEntry;

        iEngine->FileBrowserUI()->SetProgressValue(newValue);

        }

    iTimer.After(iStatus, 25);

    SetActive();

    }

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

void CFileBrowserFileUtils::RunL()

    {

    TInt err(KErrNone);

    TInt currentCommand = iCommandArray->At(iCurrentEntry).iCommandId;

    // execute a command from the queue

    switch(currentCommand)

        {

        case EFileBrowserFileOpCommandAttribs:

            {

            CCommandParamsAttribs* params = static_cast<CCommandParamsAttribs*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Attribs(params->iSourceEntry, params->iSetMask, params->iClearMask, params->iTime, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandCopy:

            {

            CCommandParamsCopyOrMove* params = static_cast<CCommandParamsCopyOrMove*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandMove:

            {

            CCommandParamsCopyOrMove* params = static_cast<CCommandParamsCopyOrMove*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Copy(params->iSourceEntry, params->iTargetPath, params->iSwitch, ETrue);

            }

            break;

        case EFileBrowserFileOpCommandRename:

            {

            CCommandParamsRename* params = static_cast<CCommandParamsRename*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Rename(params->iSourceEntry, params->iTargetPath, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandDelete:

            {

            CCommandParamsDelete* params = static_cast<CCommandParamsDelete*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->Delete(params->iSourceEntry, params->iSwitch);

            }

            break;

        case EFileBrowserFileOpCommandDriveSnapShot:

            {

            CCommandParamsDriveSnapShot* params = static_cast<CCommandParamsDriveSnapShot*>(iCommandArray->At(iCurrentEntry).iParameters);

            err = iFileOps->DriveSnapShot(params->iSourceDriveLetter, params->iTargetDriveLetter);

            }

            break;

        default:

            User::Panic (_L("Unknown command"), 400);

            break;

        }

    if (err == KErrNone)

        {

        iSucceededOperations++;

        }

    else if ( err != KErrCancel )

        {

        iFailedOperations++;

        }

    iLastError = err;            

    // check for more commands in queue

    TRAP_IGNORE( CheckForMoreCommandsL() );

    }

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

TInt CFileBrowserFileUtils::RunError(TInt aError)

    {

    _LIT(KMessage, "Command error %d");

    TBuf<128> noteMsg;

    noteMsg.Format(KMessage, aError);

    iEngine->EikonEnv()->InfoMsg(noteMsg);

    TRAP_IGNORE( CheckForMoreCommandsL() );

    return KErrNone;

    }

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

void CFileBrowserFileUtils::CheckForMoreCommandsL()

    {

    //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL");

    // update the progress bar

//    if (iProgressInfo)

//        iProgressInfo->IncrementAndDraw(1);

	// check if we have more commands to be executed

	if (iCurrentEntry >= CommandArrayCount() - 1)

		{

        //LOGSTRING("Creator: CCreatorEngine::CheckForMoreCommandsL all done");

        // all done, free resources

        ResetCommandArray();

        // deactive secure backup if it was activated by a file command

        iFileOps->DeActivateSecureBackUpViaFileOp();

        // dismiss any wait/progress dialogs        

        if (isWaitDialog)

            {

            iEngine->FileBrowserUI()->CancelWaitDialog();

            isWaitDialog = EFalse;

            }

        if (isProgressDialog)

            {

            iEngine->FileBrowserUI()->CancelProgressDialog();

            isProgressDialog = EFalse;

            }

//        if (iWaitDialog)

//            {

//            TRAP_IGNORE(iWaitDialog->ProcessFinishedL()); 

//            iWaitDialog = NULL;

//            }

//        if (iProgressDialog)

//            {

//            TRAP_IGNORE(iProgressDialog->ProcessFinishedL());

//            iProgressDialog = NULL;

//            }

        // show result note

        if ( iSucceededOperations == 0 && iFailedOperations == 0 )

            {

            // single operation cancelled -> show nothing

            }

        else if (iSucceededOperations == 1 && iFailedOperations == 0)    

            {

            _LIT(KMessage, "Operation succeeded");

            iEngine->FileBrowserUI()->ShowConfirmationNote(KMessage);

            }

        else if (iSucceededOperations > 0 && iFailedOperations == 0)    

            {

            _LIT(KMessage, "%d operations succeeded");

            TBuf<128> noteMsg;

            noteMsg.Format(KMessage, iSucceededOperations);

            iEngine->FileBrowserUI()->ShowConfirmationNote(noteMsg);

            }

        else if (iSucceededOperations == 0 && iFailedOperations > 1)    

            {

            _LIT(KMessage, "%d operations failed");

            TBuf<128> noteMsg;

            noteMsg.Format(KMessage, iFailedOperations);

            iEngine->FileBrowserUI()->ShowErrorNote(noteMsg);

            }

        else if (iSucceededOperations > 0 && iFailedOperations > 0)    

            {

            _LIT(KMessage, "%d operations succeeded, %d failed");

            TBuf<128> noteMsg;

            noteMsg.Format(KMessage, iSucceededOperations, iFailedOperations);

            iEngine->FileBrowserUI()->ShowInformationNote(noteMsg, _L(""));

            }

        else    

            {

            CTextResolver* textResolver = CTextResolver::NewLC(*iEngine->EikonEnv());

            iEngine->FileBrowserUI()->ShowErrorNote(

                    textResolver->ResolveErrorString(iLastError, CTextResolver::ECtxNoCtxNoSeparator) );

            CleanupStack::PopAndDestroy();  //textResolver

            }

        RefreshViewL();

        iEngine->FileBrowserUI()->NotifyModelHasChanged();

            }

	else

            {

            // maintain requests

            iCurrentEntry++;

            //LOGSTRING2("Creator: CCreatorEngine::CheckForMoreCommandsL iCurrentEntry=%d", iCurrentEntry);

            ExecuteCommand();

            }

    }    

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

// This callback function is called when cancel button of the progress bar was pressed

void CFileBrowserFileUtils::DialogDismissedL(/*TInt aButtonId*/)

    {

//    iProgressDialog = NULL;

//    iProgressInfo = NULL;

//    iWaitDialog = NULL;

    // check if cancel button was pressed

//    if (aButtonId == EAknSoftkeyCancel)

//        {

        // cancel the active object, command executer 

        Cancel();

        iFileOps->CancelOp();

        ResetCommandArray();

        isProgressDialog = EFalse;

        iEngine->FileBrowserUI()->ShowInformationNote(_L("Cancelled"), _L(""));

//        }

    }

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

void CFileBrowserFileUtils::AppendToCommandArrayL(TInt aCommand, CCommandParamsBase* aParameters)

    {

    if (iCommandArray)

        iCommandArray->AppendL( TCommand(aCommand, aParameters) );

    else

        User::Leave(KErrNotReady);

    }

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

TInt CFileBrowserFileUtils::CommandArrayCount() const

    {

    TInt count(0);

    if (iCommandArray)

        count = iCommandArray->Count();

    return count;

    }

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

void CFileBrowserFileUtils::ResetCommandArray()

    {

    // delete params first

    for (TInt i=0; i<CommandArrayCount(); i++)

        {

        if ( iCommandArray->At(i).iParameters )

            {

            delete iCommandArray->At(i).iParameters;

            iCommandArray->At(i).iParameters = NULL;

            }

        }

    // reset the entries

    iCommandArray->Reset();

    }