/*
* Copyright (c) 2005-2006 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:  State machine for renaming files
*
*/


#include "rsfwrenamefilestatemachine.h"
#include "rsfwfileentry.h"
#include "rsfwfiletable.h"
#include "rsfwfileengine.h"
#include "rsfwlockmanager.h"
#include "mdebug.h"


// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::CRsfwRenameFileStateMachine
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::CRsfwRenameFileStateMachine()
    {
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::~CRsfwRenameFileStateMachine
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::~CRsfwRenameFileStateMachine() 
    {
    delete iLockToken;
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::CompleteRequestL
// ----------------------------------------------------------------------------
// 
CRsfwRfeStateMachine::TState*
CRsfwRenameFileStateMachine::CompleteRequestL(TInt aError) 
    {
    if (iSrcKidCreated)
        {
        if (aError)
            {
            delete iSrcKidFep;
            iSrcKidFep = NULL;
            }
        }
    if (iDstKidCreated)
        {
        delete iDstKidFep;
        iDstKidFep = NULL;
        }

    // it may happen that the new name is equal to iLastFailedLookup value
    FileEngine()->ResetFailedLookup();

    CompleteAndDestroyState()->SetErrorCode(aError);
    return CompleteAndDestroyState();
    }



// Rename the file

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TRenameFileState::TRenameFileState
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::
TRenameFileState::TRenameFileState(CRsfwRenameFileStateMachine* aParent)
    : iOperation(aParent)
    {   
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TRenameFileState::EnterL
// ----------------------------------------------------------------------------
// 
void CRsfwRenameFileStateMachine::TRenameFileState::EnterL() 
    {
    // rename or replace
    TRfeRenameInArgs* inArgs =
        static_cast<TRfeRenameInArgs*>(iOperation->iInArgs);
    iOperation->iOverWrite = inArgs->iOverWrite;
        
    TFid* dstParentFidp = &(inArgs->iDstFid);
    TPtrC16 srcKidName(inArgs->iSrcName);
    iOperation->iDstKidName.Set(inArgs->iDstName);
    
    // Get the parent from which we are removing
    if (!iOperation->Node())
        {
        User::Leave(KErrNotFound);
        }

    // Get the parent to which we are removing
    iOperation->iDstParentFep =
        iOperation->FileEngine()->iFileTable->Lookup(*dstParentFidp);
    if (!iOperation->iDstParentFep)
        {
        User::Leave(KErrNotFound);
        }

    // Do we know the target kid yet?
    iOperation->iDstKidFep =
        iOperation->iDstParentFep->FindKidByName(iOperation->iDstKidName);
    if (!iOperation->iDstKidFep)
        {
        // Create a temporary file entry for building the full path
        iOperation->iDstKidFep =
            CRsfwFileEntry::NewL(iOperation->iDstKidName,
                             iOperation->iDstParentFep);
        iOperation->iDstKidCreated = ETrue;
        }

    // Do we know the source kid yet?
    iOperation->iSrcKidFep = iOperation->Node()->FindKidByName(srcKidName);
    if (!iOperation->iSrcKidFep)
        {
        iOperation->iSrcKidFep = CRsfwFileEntry::NewL(srcKidName,
                                                  iOperation->Node());
        iOperation->iSrcKidCreated = ETrue;
        }
   
    if (!iOperation->FileEngine()->Disconnected())
        {
        // Do the rename
        HBufC* srcKidPath =
            iOperation->FileEngine()->FullNameLC(*iOperation->iSrcKidFep);
        if ((*iOperation->iSrcKidFep).Type() == KNodeTypeDir)
            { // if source is a directory, make sure the name ends with a slash
            if ((*srcKidPath)[(srcKidPath->Length() - 1)] != '/')
                {
                TPtr srcKidAppend = srcKidPath->Des();         
                srcKidAppend.Append('/');   
                }   
            }
        
        HBufC* dstKidPath =
            iOperation->FileEngine()->FullNameLC(*iOperation->iDstKidFep);
        if ((*iOperation->iDstKidFep).Type() == KNodeTypeDir)
            { // if source is a directory, make sure the name ends with a slash
            if ((*dstKidPath)[(dstKidPath->Length() -1)] != '/')
                {
                TPtr dstKidAppend = dstKidPath->Des();         
                dstKidAppend.Append('/');   
                }   
            }
        iOperation->
            FileEngine()->
            RemoteAccessL()->RenameL(*srcKidPath,
                                     *dstKidPath,
                                     iOperation->iOverWrite,
                                     iOperation);         
        CleanupStack::PopAndDestroy(2, srcKidPath); // dstKidPath, srcKidPath
        }
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TRenameFileState::CompleteL
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::TState*
CRsfwRenameFileStateMachine::TRenameFileState::CompleteL()
    {
    if (!iOperation->iSrcKidCreated)
        {
        // If we didn't create the srcKidFep,
        // we must remove it from parent's list
        iOperation->Node()->RemoveKidL(iOperation->iSrcKidFep);
        }
    else
        {
        // Enter source into the file table
        iOperation->Node()->iFileTable->AddL(iOperation->iSrcKidFep);
        }

    if (!iOperation->iDstKidCreated)
        {
        // If we didn't create the dstKidFep, we must remove and destroy it
        // unless the node has a removed marking set
        // (should not happen, except for removed nodes)
        iOperation->FileEngine()->iFileTable->RemoveL(iOperation->iDstKidFep);
        delete iOperation->iDstKidFep;
        iOperation->iDstKidFep = NULL;
        }

    // Change srcKidFep's name,
    // and insert the fep into the dstParentFep directory
    iOperation->iSrcKidFep->RenameL(iOperation->iDstKidName);
    iOperation->iDstParentFep->AddKid(*iOperation->iSrcKidFep);

    // Refresh both parent directories
    iOperation->Node()->SetLocallyDirty();
    if (iOperation->Node() != iOperation->iDstParentFep)
        {
        iOperation->Node()->SetLocallyDirty();
        }

    return new CRsfwRenameFileStateMachine::TAcquireLockState(iOperation);
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TRenameFileState::ErrorL
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::TState*
CRsfwRenameFileStateMachine::TRenameFileState::ErrorL(TInt aCode)
    { 
    DEBUGSTRING(("remote rename failed"));
    return iOperation->CompleteRequestL(aCode);         
    }
   
// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TAcquireLockState::TAcquireLockState
// ----------------------------------------------------------------------------
//  
CRsfwRenameFileStateMachine::
TAcquireLockState::TAcquireLockState(CRsfwRenameFileStateMachine* aParent)
    {
    iOperation = aParent;  
    iRequestedLock = EFalse;  
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TAcquireLockState::EnterL
// ----------------------------------------------------------------------------
// 
void CRsfwRenameFileStateMachine::TAcquireLockState::EnterL() 
    {
    if (!iOperation->FileEngine()->WriteDisconnected())
        {
        // Now we have updated everything necessary in iSrcKidFep
        // possibly lock timer is ticking with etc.
        // However, at least WebDAV does not lock the new file in move,
        // so if the old file was locked we need to tell
        // the access protocol plug-in that it must lock the new file.
        if (iOperation->iSrcKidFep->IsLocked())
            {
            iOperation->iSrcKidFep->iLockTimer->Cancel();
            iOperation->FileEngine()->LockManager()->
                ObtainLockL(iOperation->iSrcKidFep,
                            EFileWrite,
                            iOperation->iLockToken,
                            iOperation);
            iRequestedLock = ETrue;
            }
        else 
            {
            iOperation->HandleRemoteAccessResponse(0, KErrNone);
            }
        }
    else 
        {
        iOperation->HandleRemoteAccessResponse(0, KErrNone);       
        }
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TAcquireLockState::CompleteL
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::TState*
CRsfwRenameFileStateMachine::TAcquireLockState::CompleteL()
    {
    if (iRequestedLock) 
        {
        iOperation->
            iSrcKidFep->SetLockedL(iOperation->FileEngine()->LockManager(),
                                   iOperation->iLockToken);
        iOperation->iLockToken = NULL;
        }
    return iOperation->CompleteRequestL(KErrNone); 
    }

// ----------------------------------------------------------------------------
// CRsfwRenameFileStateMachine::TAcquireLockState::ErrorL
// ----------------------------------------------------------------------------
// 
CRsfwRenameFileStateMachine::TState*
CRsfwRenameFileStateMachine::TAcquireLockState::ErrorL(TInt aCode)
    {       
    return iOperation->CompleteRequestL(aCode);   
    }