/*
* 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 closing a file
*
*/

#include <apgcli.h>

#include "rsfwclosestatemachine.h"
#include "rsfwfileentry.h"
#include "rsfwfiletable.h"
#include "rsfwvolumetable.h"
#include "rsfwvolume.h"
#include "rsfwfileengine.h"
#include "rsfwrfeserver.h"
#include "rsfwwaitnotemanager.h"
#include "rsfwlockmanager.h"
#include "mdebug.h"


// CRsfwCloseStateMachine

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::CRsfwCloseStateMachine
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::CRsfwCloseStateMachine()
    {
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::~CRsfwCloseStateMachine
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::~CRsfwCloseStateMachine()
    {
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::CompleteRequestL
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::TState* CRsfwCloseStateMachine::CompleteRequestL(TInt aError)
    {
    DEBUGSTRING(("CRsfwCloseStateMachine::CompleteRequestL::ErrorL %d", aError));

    // decrease count of files opened for writing
    Node()->iFileTable->UpdateOpenFileCount(-1);
 
    if (iFlags != ECloseLastFlushFailed) 
        {
        // file was closed successfully (not saved locally and deleted from filetable)
        DEBUGSTRING(("file was closed successfully (not saved locally and deleted from filetable)"));
        
        // If we just wrote the file to the server set attributes from the cache
        // file's attributes.
        if (Node()->CacheFileName() && Node()->IsOpenedForWriting())
                {
                Node()->SetCached(ETrue);
                FileEngine()->SetupAttributes(*Node());
                }
           
        // Add new cached and closed file to LRU cache managemet list.
        if ((Node()->Type() == KNodeTypeFile) &&
            (Node()->iCachedSize >0))
            {
            Volumes()->AddToLRUPriorityListL(Node(), Node()->CachePriority());
            }
    
        // If no content is in the cache then add closed file to the metadata LRU list.
        if ((Node()->Type() == KNodeTypeFile) &&
            (Node()->iCachedSize == 0))
            {
            Volumes()->AddToMetadataLRUPriorityListL(Node(), Node()->CachePriority());
            }  

        // uncommitted modifications have been resolved
        Node()->SetOpenedForWriting(EFalse);
        }
     else 
        {
        // remove the file from filetable as it was saved locally as a result of error
        // (either ECloseLastFlushFailed was set or we attempted to write the data and
        // there was error)
        Node()->iFileTable->RemoveL(Node());
        delete Node();
        }

    CompleteAndDestroyState()->SetErrorCode(aError);
    // remove the wait note
    DeleteWaitNoteL(ETrue);
    return CompleteAndDestroyState();
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::ErrorOnStateEntry
// ----------------------------------------------------------------------------
// 
CRsfwCloseStateMachine::TState* CRsfwCloseStateMachine::ErrorOnStateEntry(TInt aError) 
    {
    DEBUGSTRING16(("CRsfwCloseStateMachine::ErrorOnStateEntry %d", aError));

    if (aError == KErrNotFound) 
        {
        // the node was not found, do not try to clos it
        return CRsfwRfeStateMachine::ErrorOnStateEntry(aError);
        }
    else 
        {    
        // don't show 'save as' note if transfer was cancelled explicitily by the user
        if (iFlags == ECloseLastFlushFailed && !Node()->IsCancelled()) 
            {
            // modified file, last flush failed so let user to save the file locally
            return new CRsfwCloseStateMachine::TSaveLocallyState(this);
            }
        else 
            {
            // in any case, we mark this file as closed
            CRsfwCloseStateMachine::TState* nextstate = NULL;
            TRAP_IGNORE(nextstate = CompleteRequestL(KErrNone));
            return nextstate;
            }
        }

    }

// Release lock

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TReleaseLockState::TReleaseLockState
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::
TReleaseLockState::TReleaseLockState(CRsfwCloseStateMachine* aParent)
    : iOperation(aParent)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TReleaseLockState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwCloseStateMachine::TReleaseLockState::EnterL()
    {
    DEBUGSTRING(("CRsfwCloseStateMachine::TReleaseLockState::EnterL"));
    
    if (!iOperation->Node())
        {
        User::Leave(KErrNotFound);
        }

    DEBUGSTRING16(("closing fid %d (%S)", 
                        iOperation->Node()->Fid().iNodeId,
                        iOperation->Node()->Name()));
                    

    if (iOperation->Node()->Type() != KNodeTypeFile)
        {
        // Sanity
        DEBUGSTRING(("closing something else than a file!!!"));
        User::Leave(KErrArgument);
        }

    TRfeCloseInArgs* inArgs =
        static_cast<TRfeCloseInArgs*>(iOperation->iInArgs);
        
   DEBUGSTRING(("flags %d", inArgs->iFlags));  
   
   iOperation->iFlags = inArgs->iFlags;  
    
   if (iOperation->Node()->IsLocked())
        {
        // always attempt to unlock the file if it was locked
        iOperation->FileEngine()->LockManager()->ReleaseLockL(iOperation->Node(),
                                                          iOperation);
        }
    else
        {
        // no need to release the lock
        iOperation->HandleRemoteAccessResponse(0, KErrNone);
        } 
    
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TReleaseLockState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::TState* CRsfwCloseStateMachine::TReleaseLockState::CompleteL()
    {
    DEBUGSTRING(("CRsfwCloseStateMachine::TReleaseLockState::CompleteL"));
    iOperation->Node()->RemoveLocked();
    
    // don't show 'save as' note if transfer was cancelled explicitily by the user
    if (iOperation->iFlags == ECloseLastFlushFailed && !iOperation->Node()->IsCancelled()) 
        {
        // modified file, last flush failed so let user to save the file locally
        return new CRsfwCloseStateMachine::TSaveLocallyState(iOperation);
        }
    else 
        {
        return iOperation->CompleteRequestL(KErrNone);
        }
   
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TReleaseLockState::ErrorL
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::TState*
CRsfwCloseStateMachine::TReleaseLockState::ErrorL(TInt /* aCode */)
    {
    DEBUGSTRING(("CRsfwCloseStateMachine::TReleaseLockState::ErrorL"));
    // Probably not really an error as  according to the RFC locks 
    // can disappear anytime anyway, lets just run the logic in CompleteL
    return CompleteL();
    }


// save as

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TSaveLocallyState::TSaveLocallyState
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::
TSaveLocallyState::TSaveLocallyState(CRsfwCloseStateMachine* aParent)
   : iOperation(aParent)
    {
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TSaveLocallyState::EnterL
// ----------------------------------------------------------------------------
//
void CRsfwCloseStateMachine::TSaveLocallyState::EnterL()
    {
    DEBUGSTRING(("CRsfwCloseStateMachine::TSaveLocallyState::EnterL"));
    TEntry fEntry;
    CRsfwRfeServer::Env()->iFs.Entry((*(iOperation->Node()->CacheFileName())), fEntry);
    iFileSizeString.Num(fEntry.iSize);
    TPtrC cacheDriveLetter = iOperation->Node()->CacheFileName()->Left(1);
    
    iSaveToRequest.iMethod = TRsfwNotPluginRequest::ESaveToDlg;
    iSaveToRequest.iDriveName = iOperation->Node()->iFileTable->Volume()->MountInfo()
    									->iMountConfig.iName;
    									
    iSaveToRequest.iFileName = *(iOperation->Node()->Name());  
    iSaveToRequest.iCacheDrive = cacheDriveLetter;
    iSaveToRequest.iFileSize = iFileSizeString;
    
    				
    iOperation->Volumes()->WaitNoteManager()->SetSaveToDialogRequestL(iSaveToRequest);
    
    iOperation->Volumes()->WaitNoteManager()
            ->StartWaitNoteL(ERemoteSaveToLocal, iOperation);  
    }
   

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TSaveLocallyState::CompleteL
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::TState* CRsfwCloseStateMachine::TSaveLocallyState::CompleteL()
    {  
    DEBUGSTRING(("CRsfwCloseStateMachine::TSaveLocallyState::CompleteL"));
    TInt err;
     
    // move the file from cache to the new location
    HBufC* newName = HBufC::NewMaxLC(KMaxPath);
    TPtr pathPtr = newName->Des();
    pathPtr = iSaveToRequest.iFileName;
    CFileMan* fman = CFileMan::NewL(CRsfwRfeServer::Env()->iFs);
    // we assume that this is local-to-local move, and can be synch. call
    err = fman->Move((*(iOperation->Node()->CacheFileName())), 
                   pathPtr, CFileMan::EOverWrite);
    delete fman;
    if (err == KErrNone) 
        {
        iOperation->Volumes()->WaitNoteManager()->ShowFileSavedToDialogL(pathPtr);
        }
    else 
        {
        iOperation->Volumes()->WaitNoteManager()->ShowFailedSaveNoteL();
        }
      
    CleanupStack::PopAndDestroy(newName);     
          
    return iOperation->CompleteRequestL(KErrNone);
    }

// ----------------------------------------------------------------------------
// CRsfwCloseStateMachine::TSaveLocallyState::ErrorL
// ----------------------------------------------------------------------------
//
CRsfwCloseStateMachine::TState*
CRsfwCloseStateMachine::TSaveLocallyState::ErrorL(TInt aCode)
    {
    DEBUGSTRING(("CRsfwCloseStateMachine::TSaveLocallyState::ErrorL %d", aCode));
    return iOperation->CompleteRequestL(KErrNone);
    }