/*

* Copyright (c) 2003-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:  metadata struct for a remote file entry

*

*/

#include <bautils.h>

#include "rsfwfileentry.h"

#include "rsfwfiletable.h"

#include "rsfwconfig.h"

#include "rsfwvolumetable.h"

#include "rsfwvolume.h"

#include "rsfwrfeserver.h"

#include "rsfwlockmanager.h"

#include "mdebug.h"

#include "rsfwdirentattr.h"

// ----------------------------------------------------------------------------

// CRsfwFileEntry::NewLC

// ----------------------------------------------------------------------------

//

CRsfwFileEntry* CRsfwFileEntry::NewLC(const TDesC& aName, CRsfwFileEntry* aParent)

    {

    CRsfwFileEntry* self = new (ELeave) CRsfwFileEntry();

    CleanupStack::PushL(self);

    self->ConstructL(aName, aParent);

    return self;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::NewL

// ----------------------------------------------------------------------------

//

CRsfwFileEntry* CRsfwFileEntry::NewL(const TDesC& aName, CRsfwFileEntry* aParent)

    {

    CRsfwFileEntry* self = NewLC(aName, aParent);

    CleanupStack::Pop(self);

    return self;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::NewL

// ----------------------------------------------------------------------------

//

CRsfwFileEntry* CRsfwFileEntry::NewL(RReadStream& aStream)

    {

    CRsfwFileEntry* self = new (ELeave) CRsfwFileEntry();

    CleanupStack::PushL(self);

    self->ConstructL(aStream);

    CleanupStack::Pop(self);

    return self;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::ConstructL

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::ConstructL(const TDesC& aName, CRsfwFileEntry* aParent)

    {

    iType = KNodeTypeUnknown;

    iParent = aParent;

    iName = aName.AllocL();

    iAtt = KEntryAttRemote;

    iCachePriority = ECachePriorityNormal;

    SetLockTimeout();

    // Note that we don't yet attach the kid to its parent

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::ConstructL

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::ConstructL(RReadStream& aStream)

    {

    // aStream >> *this;

    this->InternalizeL(aStream);

    SetLockTimeout();

    // Note that we don't yet attach the kid to its parent

    }

void CRsfwFileEntry::SetLockTimeout() 

    {

    // When creating a file entry, the lock timeout is set to default

    // even when internalizing from stream.

    // We do not assume any locks that would survive server restarts

    TInt timeout;

    TInt err = CRsfwRfeServer::Env()->iRsfwConfig->Get(RsfwConfigKeys::KLockTimeout,

                                                       timeout);

    if (!err)

        {

        iLockTimeout = (TUint)timeout;

        }

    else

        {

        iLockTimeout = KDefaultLockTimeout;

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::~CRsfwFileEntry

// ----------------------------------------------------------------------------

//

CRsfwFileEntry::~CRsfwFileEntry()

    {

    if (iFlags & KNodeHasValidLock)

        {

        if (iLockManager)

            {

            iLockManager->RemoveLockedEntry(this);

            }

        }

    delete iName;

    delete iMimeType;

    delete iOpaqueFileId;

    delete iLockToken;

    if (!iFileTable || !iFileTable->Permanence())

        {

        RemoveCacheFile();

        }

    if ( iFileTable )

        {

        iFileTable->Volume()->iVolumeTable->RemoveFromMetadataLRUPriorityList(this);        

        }

    delete iLockTimer;

    // delete kids

    TInt i;

    for(i = 0; i < iKids.Count(); i++)

        {

        delete iKids[i];

        }

    iKids.Close();

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::FindKidByName

// ----------------------------------------------------------------------------

//

CRsfwFileEntry* CRsfwFileEntry::FindKidByName(const TDesC& aName)

    {

     DEBUGSTRING(("CRsfwFileEntry::FindKidByName"));

    // finds a kid from a parent directory

    TInt i;

    for (i = 0; i < iKids.Count(); i++)

        {

        CRsfwFileEntry* kid = iKids[i];

        if (kid->iName->Compare(aName) == 0)

            {

            return iKids[i];

            }

        }

    DEBUGSTRING(("...kid not found!"));   

    return NULL;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::RenameL

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::RenameL(const TDesC& aName)

    {

    delete iName;

    iName = NULL;

    iName = aName.AllocL();

    ReportEvent(KNotifyNodeModified);

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::AddKid

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::AddKid(CRsfwFileEntry& aFe)

    {

    // if this is the first kid to be added then probably

    // we have to remove the entry from metadata LRU list

    if ( iKids.Count() == 0 )

        {

        iFileTable->Volume()->iVolumeTable->RemoveFromMetadataLRUPriorityList(this);

        }

    iKids.Append(&aFe);

    // (This assignment is sometimes redundant)

    aFe.SetParent(this);

    ReportEvent(KNotifyNodeModified);

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::RemoveKidL

// ----------------------------------------------------------------------------

//

TInt CRsfwFileEntry::RemoveKidL(CRsfwFileEntry* aFep)

    {

    TInt i;

    for (i = 0; i < iKids.Count(); i++)

        {

        if (iKids[i] == aFep)

            {

            ReportEvent(KNotifyNodeModified);

            iKids.Remove(i);

            // if we've just removed the last kid of the entry

            // we can add the entry to metadata LRU list

            if ( iKids.Count() == 0 )

                {

                iFileTable->Volume()->iVolumeTable->AddToMetadataLRUPriorityListL(this, ECachePriorityNormal);

                }

            return KErrNone;

            }

        }

    DEBUGSTRING(("remove kid %d not found in %d",

                 aFep->Fid().iNodeId,

                 Fid().iNodeId));

    return KErrNotFound;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::KidsCount

// ----------------------------------------------------------------------------

//

TInt CRsfwFileEntry::KidsCount()

    {

    return iKids.Count();

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::UnmarkKids

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::UnmarkKids()

    {

    TInt i;

    for (i = 0; i < iKids.Count(); i++)

        {

        iKids[i]->Unmark();

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::DropUnmarkedKidsL

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::DropUnmarkedKidsL()

    {

    TInt i = 0;

    while (i < iKids.Count())

        {

        if (!iKids[i]->IsMarked())

            {

            iKids[i]->DropLD();

            }

        else

            {

            i++;

            }

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::DropLD

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::DropLD()

    {

    DEBUGSTRING(("CRsfwFileEntry::DropLD"));

    TInt i = 0;

    while (i < iKids.Count())

        {

        iKids[i]->DropLD();

        }

    iFileTable->RemoveL(this);

    delete this;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::GetAttributes

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::GetAttributes(TDirEntAttr& aAttr) const

    {

    aAttr.iAtt = Att();

    aAttr.iSize = Size();

    aAttr.iModified = Modified();

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::GetAttributesL

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::GetAttributesL(CRsfwDirEntAttr& aAttr) const

    {

    aAttr.SetAtt(Att());

    aAttr.SetSize(Size());

    aAttr.SetModified(Modified());

    if (iOpaqueFileId)

        {

        aAttr.SetETagL(*OpaqueFileId());

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::SetAttributesL

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::SetAttributesL(CRsfwDirEntAttr& aAttr,

                                    TBool aAllMetaData)

    {

    SetAtt(aAttr.Att());

    if (aAllMetaData) 

        {

        SetSize(aAttr.Size());

        SetModified(aAttr.Modified());

        if (aAttr.MimeType())

            {

            SetMimeTypeL(*aAttr.MimeType());

            }

        if (aAttr.ETag())

            {

            SetOpaqueFileIdL(*aAttr.ETag());

            }

        SetUid(aAttr.Uid());

        SetAttribValidationTime();

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::CacheFileName

// ----------------------------------------------------------------------------

//

TDesC* CRsfwFileEntry::CacheFileName()

    {

    DEBUGSTRING(("CRsfwFileEntry::CacheFileName"));

    if (iCacheName.Length())

        {

        return &iCacheName;

        }

    return NULL;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::SetCacheFileName

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::SetCacheFileName(TDesC* aFn)

    {

    DEBUGSTRING16(("SetCacheFileName for file %S", Name()));

    if (aFn)

        {

        iCacheName = *aFn;

        ReportEvent(KNotifyNodeModified);

        }

    else

        {

        if (iCacheName.Length())

            {

            if (IsCached())

                {

                // Remove the cache list entry...

                iFileTable->

                    Volume()->

                    iVolumeTable->RemoveFromLRUPriorityList(this);

                }

            // This is a request to discard the container

            RFs fs = CRsfwRfeServer::Env()->iFs;

            TInt err = fs.Delete(iCacheName);

            if (err != KErrNone)

                {

                DEBUGSTRING(("Cannot purge cache file (err=%d)", err));

                }

            iCacheName.Zero();

            // Reset locally dirty in case this is a directory.

            // "locally dirty" means that the container

            // doesn't have the "cached"/"protected" indicator bits up to date

            // (these indicators refer to files contained in the directory).

            iFlags &= ~KNodeLocallyDirty;

            ReportEvent(KNotifyNodeModified);

            }

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::IsCached

// ----------------------------------------------------------------------------

//

TBool CRsfwFileEntry::IsCached() const

    {

   DEBUGSTRING(("CRsfwFileEntry::IsCached, iAtt = %d, iFlags = %d", iAtt, iFlags));

    if (((iAtt & KEntryAttRemote) == 0) ||

        (iFlags & KNodePartlyCached))

        {

         DEBUGSTRING(("returning ETrue"));

        // File is either fully or partly cached

        return ETrue;

        }

    DEBUGSTRING(("returning EFalse"));

    return EFalse;

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::IsFullyCached

// ----------------------------------------------------------------------------

//

TBool CRsfwFileEntry::IsFullyCached() const

    {

    DEBUGSTRING(("CRsfwFileEntry::IsFullyCached"));

    DEBUGSTRING(("iCachedSize = %d, iSize = %d", iCachedSize, iSize));

    if (Type() == KNodeTypeDir)

        {

        return IsCached();

        }

    else

        {

        if (iCachedSize == iSize)

            {

            return IsCached();

            }

        else

            {

            return EFalse;

            }

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::SetCached

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::SetCached(TBool aCached)

    {

    DEBUGSTRING(("CRsfwFileEntry::SetCached"));

    TUint oldAtt = iAtt;

    if (aCached)

        {

        if (Type() == KNodeTypeDir)

            {

            // set to fully cached

            DEBUGSTRING(("set directory to fully cached"));

            iAtt &= ~KEntryAttRemote;

            iFlags &= ~KNodePartlyCached;

            }

        else

            {

            if (iCachedSize == iSize)

                {

                // set file to fully cached

                DEBUGSTRING(("set file to fully cached"));

                iAtt &= ~KEntryAttRemote;

                iFlags &= ~KNodePartlyCached;

                }

            else

                {

                // Set file to partly cached

                DEBUGSTRING(("set file to partly cached"));

                iAtt |= KEntryAttRemote;

                iFlags |= KNodePartlyCached;

                }

            }

        }

    else

        {

        // set to "fully" remote

        DEBUGSTRING(("set to fully remote"));

        iFlags &= ~KNodePartlyCached;

        iAtt |= KEntryAttRemote;

        iUseCachedData = EFalse;

        iCachedSize = 0;

        }

    if (iAtt != oldAtt)

        {

        ReportEvent(KNotifyNodeModified);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::SetCachedSize

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::SetCachedSize(TInt aFetchedSize)

    {

    TInt oldCachedSize = iCachedSize;

    iCachedSize = aFetchedSize;

    if (iCachedSize != oldCachedSize)

        {

        ReportEvent(KNotifyNodeModified);

        }

    }

// ----------------------------------------------------------------------------

// CRsfwFileEntry::RemoveCacheFile

// ----------------------------------------------------------------------------

//

void CRsfwFileEntry::RemoveCacheFile()

    {

   DEBUGSTRING(("CRsfwFileEntry::RemoveCacheFile"));

    if (IsCached() && iFileTable)

        {

        // Remove the cache list entry...

        iFileTable->Volume()->iVolumeTable->RemoveFromLRUPriorityList(this);

        }

    if (iCacheName.Length())

        {

        RFs fs = CRsfwRfeServer::Env()->iFs;

        TInt err = fs.Delete(iCacheName);

        if ((err != KErrNone) && (err != KErrNotFound))

            {

            DEBUGSTRING(("Cannot delete cache file (err=%d)", err));

            }

        iCacheName.Zero();