/*
* 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 file lookup
*
*/


#include "rsfwlookupstatemachine.h"
#include "rsfwfileentry.h"
#include "rsfwfiletable.h"
#include "rsfwinterface.h"
#include "rsfwfileengine.h"
#include "mdebug.h"
#include "rsfwdirentattr.h"
#include "rsfwvolumetable.h"

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::CRsfwLookupStateMachine
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::CRsfwLookupStateMachine()
    {
    iKidCreated = ETrue;
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::~CRsfwLookupStateMachine
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::~CRsfwLookupStateMachine()
    {
    delete iDirEntAttr;
    if (iPath)
    	{
    	delete iPath;
    	}
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::CompleteRequestL
// ----------------------------------------------------------------------------
//
CRsfwRfeStateMachine::TState* CRsfwLookupStateMachine::CompleteRequestL(TInt aError)
    {
    TRfeLookupOutArgs* outArgs = static_cast<TRfeLookupOutArgs*>(iOutArgs);
    if (aError == KUpdateNotRequired)
        {   // discard
        aError = KErrNone;
        }

    if (!aError)
        {
        outArgs->iFid = iKidFep->Fid();
        }
    CompleteAndDestroyState()->SetErrorCode(aError);
    return CompleteAndDestroyState();
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::TState* CRsfwLookupStateMachine::CompleteL()
    {
    // from CRsfwFileEngine::UpdateFileAttributes/UpdateDirAttributes
#ifdef _DEBUG
    if (iDirEntAttr)
        {
        DEBUGSTRING(("Kid attributes: attr=0x%x, size=%d, time=",
                     iDirEntAttr->Att(),
                     iDirEntAttr->Size()));
        DEBUGTIME((iDirEntAttr->Modified()));
        }
#endif

    if (iKidCreated)
        {
        /* from CRsfwFileEngine::DoLookupL */
        // Create a file entry for this kid
        if (!Volumes()->EnsureMetadataCanBeAddedL(Node()))
            {
            User::Leave(KErrNoMemory);
            }
        iKidFep = CRsfwFileEntry::NewL(iKidName, Node());
        if (iDirEntAttr->Att() & KEntryAttDir)
            {
            iKidFep->SetType(KNodeTypeDir);
            }
        else
            {
            iKidFep->SetType(KNodeTypeFile);
            }

        iKidFep->SetAttributesL(*iDirEntAttr, ETrue);

        // Remember that we have this kid
        FileEngine()->iFileTable->AddL(iKidFep);
        Node()->AddKid(*iKidFep);
        // If we really find a new kid that we were not aware of
        // we must set the parent as locally dirty
        // (this should not happen too often)
        Node()->SetLocallyDirty();
        }

    // We now have a valid kid entry
    return CompleteRequestL(KErrNone);
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::TUpdateKidAttributesTryFirstTypeState
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::
TUpdateKidAttributesTryFirstTypeState::
TUpdateKidAttributesTryFirstTypeState(CRsfwLookupStateMachine* aParent)
    : iOperation(aParent)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::EnterL()
    {
    DEBUGSTRING(("CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::EnterL"));
    TRfeLookupInArgs* inArgs =
        static_cast<TRfeLookupInArgs*>(iOperation->iInArgs);
    TRfeLookupOutArgs* outArgs =
        static_cast<TRfeLookupOutArgs*>(iOperation->iOutArgs);
    iOperation->iNodeType = inArgs->iNodeType;
    iOperation->iKidName.Set(inArgs->iName);

    TInt err = KErrNone;
    iOperation->iKidFep = NULL;

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

    DEBUGSTRING16(("looking up '%S' in fid=%d",
                   &(iOperation->iKidName),
                   iOperation->Node()->Fid().iNodeId));

    // We'd better be looking up in a directory
    if (iOperation->Node()->Type() != KNodeTypeDir)
        {
        User::Leave(KErrNotFound);
        }

    // Try to get the entry from the parent directory
    iOperation->iKidFep =
        iOperation->Node()->FindKidByName(iOperation->iKidName);
    if (!iOperation->iKidFep)
        {
        DEBUGSTRING(("no such kid!"));
        // Didn't find it
        // if the parent directory's cache entry is still valid
        // we return "not found"
        if ((iOperation->FileEngine()->UseCachedAttributes(*iOperation->Node())) &&
         	(iOperation->FileEngine()->UseCachedData(*iOperation->Node())))
        	{
			User::Leave(KErrNotFound);
        	}

        iOperation->iPath =
            iOperation->FileEngine()->FullNameL(*iOperation->Node());
        if (iOperation->iNodeType == KNodeTypeUnknown)
            {
            iOperation->FileEngine()->
                UpdateAttributesL(*iOperation->iPath,
                                  iOperation->iKidName,
                                  iOperation->iDirEntAttr,
                                  KNodeTypeFile,
                                  iOperation);
            }
        else
            {
            iOperation->FileEngine()->
                UpdateAttributesL(*iOperation->iPath,
                                  iOperation->iKidName,
                                  iOperation->iDirEntAttr,
                                  iOperation->iNodeType,
                                  iOperation);
            }

        if (err)
            {
            // communication to the server failed,
            //e.g. we are in disconnected mode
            User::Leave(err);
            }
        }
    else
        {
        // We now have a valid kid entry
        outArgs->iFid = iOperation->iKidFep->Fid();
        iOperation->HandleRemoteAccessResponse(0, KUpdateNotRequired);
        }
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::TState*
CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::CompleteL()
    {
    DEBUGSTRING(("CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::CompleteL"));
    return iOperation->CompleteL();
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::ErrorL
// If we were looking for a file return KErrNotFound
// if for directory KErrPathNotFound.
// File Server seems to always call Entry() (-->lookup()) before other file
// operations so as long as we return the right variant of "not found"
// error here other places do not matter.
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::TState*
CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::ErrorL(TInt aCode)
    {
    DEBUGSTRING(("CRsfwLookupStateMachine::TUpdateKidAttributesTryFirstTypeState::ErrorL %d", aCode));
    if (aCode == KUpdateNotRequired)
        {
        iOperation->iKidCreated = EFalse;
        return iOperation->CompleteL();
        }
    else if (iOperation->iNodeType == KNodeTypeUnknown)
        {
        return new CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState(
            iOperation);
        }
    else if ((aCode != KErrNotFound) && (aCode != KErrPathNotFound))
   	 	{
    	return iOperation->CompleteRequestL(aCode);
    	}
    else if (iOperation->iNodeType == KNodeTypeDir)
        {
        return iOperation->CompleteRequestL(KErrPathNotFound);
        }
    else
        {
        return iOperation->CompleteRequestL(KErrNotFound);
        }
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::TUpdateKidAttributesTrySecondTypeState
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::
TUpdateKidAttributesTrySecondTypeState::
TUpdateKidAttributesTrySecondTypeState(CRsfwLookupStateMachine* aParent)
    : iOperation(aParent)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::EnterL()
    {
    DEBUGSTRING(("CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::EnterL"));
    // We only come here if nodetype is unknown and
    // we already tried to lookup as a file
    iOperation->FileEngine()->UpdateAttributesL(*iOperation->iPath,
                                                iOperation->iKidName,
                                                iOperation->iDirEntAttr,
                                                KNodeTypeDir, iOperation);
    }

// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::TState*
CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::CompleteL()
    {
    DEBUGSTRING(("CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::CompleteL"));   
    // from CRsfwFileEngine::UpdateFileAttributes/UpdateDirAttributes
    return iOperation->CompleteL();
    }


// ----------------------------------------------------------------------------
// CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::ErrorL
// If we were looking for a file return KErrNotFound,
// if for directory KErrPathNotFound.
// File Server seems to always call Entry() (-->lookup()) before other file
// operations so as long as we return the right variant of "not found"
// error here other places do not matter.
// ----------------------------------------------------------------------------
//
CRsfwLookupStateMachine::TState*
CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::ErrorL(TInt aCode)
    {
    DEBUGSTRING(("CRsfwLookupStateMachine::TUpdateKidAttributesTrySecondTypeState::ErrorL %d", aCode));    
    // from CRsfwFileEngine::Lookup()
    // No such kid

    // cache the last failed lookup results
   	iOperation->FileEngine()->SetFailedLookup(*iOperation->iPath,
   											iOperation->iKidName);

    if (iOperation->iNodeType == KNodeTypeDir)
        {
        return iOperation->CompleteRequestL(KErrPathNotFound);
        }
    else
        {
        return iOperation->CompleteRequestL(KErrNotFound);
        }
    }