/*
* 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:  Delete a file or directory
*
*/


#include "rsfwdeletestatemachine.h"
#include "rsfwfileentry.h"
#include "rsfwfiletable.h"
#include "rsfwinterface.h"
#include "rsfwfileengine.h"
#include "mdebug.h"
#include "rsfwdirent.h"


// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::CRsfwDeleteStateMachine
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::CRsfwDeleteStateMachine(TUint aNodeType)
    : iNodeType(aNodeType)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::~CRsfwDeleteStateMachine
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::~CRsfwDeleteStateMachine()
    {
    iDirEnts.ResetAndDestroy();
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::CompleteRequestL
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState* CRsfwDeleteStateMachine::CompleteRequestL(TInt aError)
    {
    if (iKidPath)
        {
        delete iKidPath;
        iKidPath = NULL;
        }

    // If the return code was KErrInUse, the directory we were about to delete
    // was not empty, and we couldn't delete it. In this case it has anyway
    //been added to the cache (as a side effect),
    // so we don't want to delete the fep.
    if (aError != KErrInUse && iKidCreated)
        {
        delete iKidFep;
        iKidFep = NULL;
        }

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

// Check if exists


// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::TCheckIfCanBeDeleted
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::
TCheckIfCanBeDeleted::TCheckIfCanBeDeleted(CRsfwDeleteStateMachine* aParent)
    : iOperation(aParent)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::EnterL()
    {
    // Kidname is in the same place in remove and rmdir structures,,,
    TRfeRemoveInArgs* inArgs =
        static_cast<TRfeRemoveInArgs*>(iOperation->iInArgs);
    TPtrC kidName(inArgs->iName);

    // the parent from which we are removing
    if (!iOperation->Node())
        {
        User::Leave(KErrNotFound);
        }

    DEBUGSTRING16(("removing entry '%S' from fid %d",
                   &kidName,
                   iOperation->Node()->Fid().iNodeId));

    // Do we know about the kid yet?
    iOperation->iKidFep = iOperation->Node()->FindKidByName(kidName);
    if (!iOperation->iKidFep)
        {
        // Create a temporary file entry for the target
        iOperation->iKidFep = CRsfwFileEntry::NewL(kidName, iOperation->Node());
        iOperation->iKidCreated = ETrue;
        }

    // Ensure the type matches with the operation (RmDir() or Delete())
    if ((iOperation->iKidFep->Type() != KNodeTypeUnknown) &&
        (iOperation->iKidFep->Type() != iOperation->iNodeType))
        {
        DEBUGSTRING(("object type does not match the parameter type!"));
        User::Leave(KErrArgument);
        }

    // if the type is unknown, set it from the operation parameter
    if (iOperation->iKidFep->Type() == KNodeTypeUnknown)
        {
        iOperation->iKidFep->SetType(iOperation->iNodeType);
        }

    // If it is a directory, check that it is empty
    if (!iOperation->FileEngine()->Disconnected() &&
        iOperation->iNodeType == KNodeTypeDir)
        {
        TInt zero = 0;
        iOperation->FileEngine()->
            FetchAndCacheL(*iOperation->iKidFep,
                           0,
                           &zero,
                           &iOperation->iDirEnts,
                           iOperation);
        }
    else
        {
        iOperation->HandleRemoteAccessResponse(0, KErrNone);
        }
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::TState*
CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::CompleteL()
    {
    if ((iOperation->iNodeType == KNodeTypeDir) &&
        ((iOperation->iDirEnts).Count() > 0))
        {
        // Attach the directory itself if it was unknown
        if (iOperation->iKidCreated)
            {
            iOperation->FileEngine()->iFileTable->AddL(iOperation->iKidFep);
            iOperation->Node()->AddKid(*iOperation->iKidFep);
            }
            
        // if the directory is not empty we cannot delete it
        // however, let's add its entries to the cache
        iOperation->FileEngine()->AddToCacheL(
            *iOperation->iKidFep,
            &iOperation->iDirEnts,
            iOperation->FileEngine(),
            0);

        return iOperation->CompleteRequestL(KErrInUse);
        }
    else
        {
        return new CRsfwDeleteStateMachine::TDeleteNodeState(iOperation);
        }
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::ErrorL
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::TState*
CRsfwDeleteStateMachine::TCheckIfCanBeDeleted::ErrorL(TInt aCode)
    {
    DEBUGSTRING(("kid didn't exist!"));
    return iOperation->CompleteRequestL(aCode);
    }

// Remove directory

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TDeleteNodeState::TDeleteNodeState
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::
TDeleteNodeState::TDeleteNodeState(CRsfwDeleteStateMachine* aParent)
    : iOperation(aParent)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TDeleteNodeState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwDeleteStateMachine::TDeleteNodeState::EnterL()
    {
    // Get the path for the actual remove
    iOperation->iKidPath =
        iOperation->FileEngine()->FullNameL(*iOperation->iKidFep);
    if (!iOperation->FileEngine()->Disconnected())
        {
        if (iOperation->iNodeType == KNodeTypeDir)
            {
            iOperation->
                FileEngine()->
                RemoteAccessL()->DeleteDirectoryL(*iOperation->iKidPath,
                                                  iOperation);
            }
        else // KNodeTypFile
            {
            iOperation->
                FileEngine()->
                RemoteAccessL()->DeleteFileL(*iOperation->iKidPath,
                                             iOperation);
            }
        }
    else
        {
        // Disconnected
        iOperation->HandleRemoteAccessResponse(0, KErrNone);
        }
    }

// ----------------------------------------------------------------------------
// CRsfwDeleteStateMachine::TDeleteNodeState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwDeleteStateMachine::TState* CRsfwDeleteStateMachine::TDeleteNodeState::CompleteL()
    {
    if (!iOperation->FileEngine()->Disconnected())
        {
        // If the target was already known, remove and destroy it
        if (!iOperation->iKidCreated)
            {
            iOperation->FileEngine()->iFileTable->RemoveL(iOperation->iKidFep);
            delete iOperation->iKidFep;
            iOperation->iKidFep = NULL;
            }
        }

    iOperation->Node()->SetLocallyDirty();
    return iOperation->CompleteRequestL(KErrNone);
    }

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