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


#include "rsfwopenbypathstatemachine.h"
#include "rsfwfileentry.h"
#include "rsfwfiletable.h"
#include "rsfwvolumetable.h"
#include "rsfwvolume.h"
#include "rsfwinterface.h"
#include "rsfwfileengine.h"
#include "rsfwlockmanager.h"
#include "mdebug.h"


// ----------------------------------------------------------------------------
// CRsfwOpenByPathStateMachine::CRsfwOpenByPathStateMachine
// ----------------------------------------------------------------------------
//
CRsfwOpenByPathStateMachine::CRsfwOpenByPathStateMachine()
    {
    }

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

// ----------------------------------------------------------------------------
// CRsfwOpenByPathStateMachine::CompleteRequestL
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState*
CRsfwOpenByPathStateMachine::CompleteRequestL(TInt aError)
    {
    DEBUGSTRING(("CRsfwOpenByPathStateMachine::CompleteRequestL %d", aError));
    TRfeOpenByPathOutArgs* outArgs =
        static_cast<TRfeOpenByPathOutArgs*>(iOutArgs);
    if(!aError)
        {
        if ((Node()->Type() == KNodeTypeFile) &&
            iRealOpen) 
            {
            // file opened successfully and was not already opened in create
            Node()->iFileTable->UpdateOpenFileCount(1);
            }
  
        outArgs->iPath.Copy(*iCacheName);
        iAttrp->iAtt = Node()->Att();
        iAttrp->iSize = Node()->Size();
        iAttrp->iModified = Node()->Modified();
        }

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

// ----------------------------------------------------------------------------
// CRsfwOpenByPathStateMachine::TRequestOpenModeState::TRequestOpenModeState
// ----------------------------------------------------------------------------
//
CRsfwOpenByPathStateMachine::TRequestOpenModeState::TRequestOpenModeState(
    CRsfwOpenByPathStateMachine* aParent)
    : iOperation(aParent)
    {
    iRequestedLock = EFalse;
    }

// ----------------------------------------------------------------------------
// CRsfwOpenByPathStateMachine::TRequestOpenModeState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwOpenByPathStateMachine::TRequestOpenModeState::EnterL()
    {
    
    DEBUGSTRING(("CRsfwOpenByPathStateMachine::TRequestOpenModeState::EnterL"));
    
    TRfeOpenByPathInArgs* inArgs =
        static_cast<TRfeOpenByPathInArgs*>(iOperation->iInArgs);
    TRfeOpenByPathOutArgs* outArgs =
        static_cast<TRfeOpenByPathOutArgs*>(iOperation->iOutArgs);
    iOperation->iRealOpen = inArgs->iTrueOpen;
    // Use inArgs->iFlags to pass desired locking information
    iOperation->iFlags = inArgs->iFlags;
    iOperation->iAttrp = &(outArgs->iAttr);

    if (!iOperation->Node())
        {
        User::Leave(KErrNotFound);
        }

    if (iOperation->Node()->Size() > iOperation->Volumes()->iMaxCacheSize)
        {
        DEBUGSTRING(("OPENBYPATH failed: file too large: file size %d, max cache size %d",
                     iOperation->Node()->Size(),
                     iOperation->Volumes()->iMaxCacheSize));
        User::Leave(KErrTooBig);
        }

    DEBUGSTRING(("opening fid %d with flags 0x%x",
                 iOperation->Node()->Fid().iNodeId,
                 iOperation->iFlags));

    if (!iOperation->FileEngine()->WriteDisconnected())
        {
        if (!(iOperation->Node()->IsLocked()) &&
            (iOperation->Node()->Type() != KNodeTypeDir) &&
            (iOperation->iFlags & EFileWrite))
            {
            DEBUGSTRING(("requesting lock"));
            // For the time being
            // if flag is 0 we are not interested in getting a lock
            iOperation->FileEngine()->LockManager()->ObtainLockL(
                iOperation->Node(),
                iOperation->iFlags,
                iOperation->iLockToken,
                iOperation);
            iRequestedLock = ETrue;
            }
        else
            {
            // IsLocked() || !(iOperation->iFlags & EFileWrite)
            iOperation->HandleRemoteAccessResponse(0, KErrNone);
            }
        }
    else
        {
        // if WriteDisconnected()
        iOperation->HandleRemoteAccessResponse(0, KErrNone);
        }
    }

// ----------------------------------------------------------------------------
// CRsfwOpenByPathStateMachine::TRequestOpenModeState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwOpenByPathStateMachine::TState*
CRsfwOpenByPathStateMachine::TRequestOpenModeState::CompleteL()
    {
     DEBUGSTRING(("CRsfwOpenByPathStateMachine::TRequestOpenModeState::CompleteL"));
    if (iRequestedLock)
        {
        //from CRsfwLockManager::ObtainLock()
#ifdef _DEBUG
        TPtrC p = iOperation->Node()->FullNameLC()->Des();
        DEBUGSTRING16(("ObtainLockL(): flags %d returned %d for file '%S'",
                       iOperation->iFlags,
                       KErrNone,
                       &p));
        CleanupStack::PopAndDestroy();
#endif // DEBUG
        iOperation->Node()->SetLockedL(
            iOperation->FileEngine()->LockManager(),
            iOperation->iLockToken);
        iOperation->iLockToken = NULL;
        }

    iOperation->iCacheName = iOperation->Node()->CacheFileName();

    // make sure that the relevant cache file is on place
    // (i.e. it has not been removed e.g. by other apps)
    iOperation->Node()->ValidateCacheFile();

    if (!iOperation->Node()->IsCached())
        {
        if (iOperation->FileEngine()->Disconnected())
            {
            if ((iOperation->Node()->Type() != KNodeTypeDir) &&
                !(iOperation->iFlags & EFileWrite))
                {
                // While disconnected,
                // write access of files returns "not found"
                return iOperation->CompleteRequestL(KErrNotFound);
                }
            }
        iOperation->FileEngine()->CreateContainerFileL(*(iOperation->Node()));
        iOperation->iCacheName = iOperation->Node()->CacheFileName();
        }
    else // is cached
        {
        if (iOperation->Node()->IsLocallyDirty())
            {
            // This is a directory which has at least one kid
            // that has been cached or flushed since the last opening
            // of the directory
            iOperation->FileEngine()->UpdateDirectoryContainerL(
                *(iOperation->Node()));
            }

        // If this is a cached file,
        // we must remove it from LRUlist as it is now open
        if (iOperation->iRealOpen)
            {
            iOperation->Node()->iFileTable->Volume()->iVolumeTable->
                RemoveFromLRUPriorityList(iOperation->Node());
            }
        }

    // if file or dir has just been opened, remove it from metadata LRU list
    iOperation->Node()->iFileTable->Volume()->iVolumeTable->
        RemoveFromMetadataLRUPriorityList(iOperation->Node());

    return iOperation->CompleteRequestL(KErrNone);
    }

// ----------------------------------------------------------------------------
// CRsfwOpenByPathStateMachine::TRequestOpenModeState::ErrorL
// fileEngine->RequestConnectionStateL() has returned with error
// ----------------------------------------------------------------------------
//
CRsfwOpenByPathStateMachine::TState*
CRsfwOpenByPathStateMachine::TRequestOpenModeState::ErrorL(TInt aCode)
    {
    DEBUGSTRING(("CRsfwOpenByPathStateMachine::TRequestOpenModeState::ErrorL %d", aCode));
    // from CRsfwFileEngine::DoOpenByPath()
    if (aCode == KErrNotSupported)
        {
        iRequestedLock = EFalse;
        // locks not supported is not an error state
        // instead we run the success state...
        return CompleteL();
        }

    //from CRsfwLockManager::ObtainLock()
#ifdef _DEBUG
    TPtrC p = iOperation->Node()->FullNameLC()->Des();
    DEBUGSTRING16(("ObtainLockL(): flags %d returned %d for file '%S'",
                   iOperation->iFlags,
                   aCode,
                   &p));
    CleanupStack::PopAndDestroy();
#endif

    return iOperation->CompleteRequestL(aCode);
    }