/*

* 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 remote files

*

*/

#include <s32mem.h>

#include "rsfwfiletable.h"

#include "rsfwfileentry.h"

#include "rsfwfileengine.h"

#include "rsfwvolumetable.h"

#include "rsfwvolume.h"

#include "rsfwrfeserver.h"

#include "rsfwwaitnotemanager.h"

#include "mdebug.h"

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

// CRsfwFileTable::NewL

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

//   

CRsfwFileTable* CRsfwFileTable::NewL(CRsfwVolume* aVolume, TFileName& aCachePath)

    {

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

    DEBUGSTRING(("CRsfwFileTable: in NewL 0x%x", self));

    CleanupStack::PushL(self);

    self->ConstructL(aVolume, aCachePath);

    CleanupStack::Pop(self);

    return self;

    }

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

// CRsfwFileTable::ConstructL

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

//   

void CRsfwFileTable::ConstructL(CRsfwVolume* aVolume, TFileName& aCachePath)

    {

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

    // The root will be number 1

    iNodeId = 1;

    iVolume = aVolume;

    iRootFep = NULL;

    iCachePath.Copy(aCachePath);

    iPermanence = iVolume->iMountInfo.iMountStatus.iPermanence;

    iMetaDataFilePath.Copy(aCachePath);

    iMetaDataFilePath.Append(KMetaDataFileName);

    iMetaDataEvents.Reset();

    SetupCacheL();

    }

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

// CRsfwFileTable::~CRsfwFileTable

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

//   

CRsfwFileTable::~CRsfwFileTable()

    {

    if (iRootFep)

        {

        // Delete the whole tree recursively

        delete iRootFep;

        iRootFep = NULL;

        }

    // Discard events

    iMetaDataEvents.Close();

    iMetaDataSlots.Close();

    if (iMetaDataStore) 

        {

        delete iMetaDataStore;

        }

    }

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

// CRsfwFileTable::AddL

// this function associates aFep with this file table but does no

// yet set to any other node's child (or root node), that must be done sepately

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

//   

void CRsfwFileTable::AddL(CRsfwFileEntry* aFep)

    {    

    // Just assign a unique id

    TFid newFid;

    newFid.iVolumeId = iVolume->iMountInfo.iMountStatus.iVolumeId;

    newFid.iNodeId = iNodeId;

    aFep->SetFid(newFid);

    aFep->iFileTable = this;

    iNodeId++;

    if (!iRootFep)

        {

        iRootFep = aFep;

        }

    // add item to metadata LRU list, 

    // only add childless directories and non-cached files

    if ( (aFep->Type() == KNodeTypeFile && aFep->iCachedSize == 0) 

         || (aFep->Type() == KNodeTypeDir && aFep->Kids()->Count() == 0)

         || (aFep->Type() == KNodeTypeUnknown) )

        {

        iVolume->iVolumeTable->AddToMetadataLRUPriorityListL(aFep, ECachePriorityNormal);        

        }

    // Note that the first added entry will always be the root

    HandleMetaDataEvent(KNotifyNodeAdded, aFep);

    }

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

// CRsfwFileTable::Remove

// removed this fileentry and disconnects from the parent

// does not delete the kid file/directory entries

// in practise this means that if deleting a directory, all its entries must be deleted

// recursively first

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

//   

void CRsfwFileTable::RemoveL(CRsfwFileEntry* aFep)

    {

    DEBUGSTRING(("CRsfwFileTable::RemoveL"));

    // remove item from metadata LRU list

    iVolume->iVolumeTable->RemoveFromMetadataLRUPriorityList(aFep);        

    if (aFep == iCurrentParent)

        {

        iCurrentParent = NULL;

        }

    if (iPermanence)

        {

        aFep->RemoveCacheFile();

        HandleMetaDataEvent(KNotifyNodeRemoved, aFep);

        }

    // remove this file entry from its parent node    

    if (aFep->iParent)  

        {

        aFep->iParent->RemoveKidL(aFep);

        }

    }

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

// CRsfwFileTable::Lookup

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

//   

CRsfwFileEntry* CRsfwFileTable::Lookup(const TFid& aFid)

    {

    if (!iRootFep)

        {

        return NULL;

        }

    if (iRootFep->Fid().iNodeId == aFid.iNodeId)

        {

        return iRootFep;

        }

    // Try to optimize by starting from the latest parent

    CRsfwFileEntry* fep = NULL;

    if (iCurrentParent)

        {

        fep = iCurrentParent->Lookup(aFid);

        }

    if (!fep)

        {

        fep = iRootFep->Lookup(aFid);

        }

    if (fep)

        {

        iCurrentParent = fep->Parent();

        }

    return fep;

    }

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

// CRsfwFileTable::DumpL

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

// 

#ifdef _DEBUG

void CRsfwFileTable::DumpL(TBool aAll)

    {

    if (iRootFep)

        {

        iRootFep->PrintL(0, ETrue, aAll);

        }

    }

#else

void CRsfwFileTable::DumpL(TBool /* aAll */)

    {

    }

#endif //DEBUG

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

// CRsfwFileTable::SetPermanenceL

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

// 

void CRsfwFileTable::SetPermanenceL(TBool aPermanence)

    {

    if (iPermanence != aPermanence)

        {

        iPermanence = aPermanence;

        if (!iPermanence)

            {

            delete iMetaDataStore;

            iMetaDataStore = NULL;

            }

        SetupCacheL();

        }

    }

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

// CRsfwFileTable::HandleMetaDataEvent

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

// 

void CRsfwFileTable::HandleMetaDataEvent(TInt aEvent, CRsfwFileEntry* aFep)

    {

    if (iMetaDataSaveState == EMetaDataSaveFailed)

        {

        // No use

        return;

        }

    switch (aEvent)

        {

    case KNotifyNodeAdded:

        {

        // There should not be any previous additions

        AddEvent(aEvent, aFep);

        }

        break;

    case KNotifyNodeModified:

        {

        // There may appear spurious modifications

        // to removed entries (like cache state set to false).

        // We filter them out.

        if (!NodeEvent(aFep->Fid().iNodeId))

            {

            AddEvent(aEvent, aFep);

            }

        }

        break;

    case KNotifyNodeRemoved:

        {

        TMetaDataEvent* oldEvent = NodeEvent(aFep->Fid().iNodeId);

        if (oldEvent)

            {

            if (oldEvent->iEvent == KNotifyNodeAdded)

                {

                // just remove a previous "added"

                RemoveEvent(oldEvent->iNodeId);

                AddEvent(aEvent, aFep);

                }

            else

                {

                // Just replace "modified" (or duplicate "deleted")

                // with "deleted"

                oldEvent->iEvent = KNotifyNodeRemoved;

                }

            }

        else

            {

            AddEvent(aEvent, aFep);

            }

        }

        break;

    default:

        break;

        }

    }

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

// CRsfwFileTable::LoadMetaDataL

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

// 

CRsfwFileEntry* CRsfwFileTable::LoadMetaDataL()

    {

    // When this function is called the root node

    // must already be created in the file table

    iMetaDataStore->CompactL();

    iMetaDataStore->ResetL(EFalse);

    RPointerArray<CRsfwFileEntry> feps;

    CleanupClosePushL(feps);

    TBool done = EFalse;

    while (!done)

        {

        CRsfwFileEntry* fep;

        TMetaDataSlot slot;

        TRAPD(err, LoadNodeL(fep, slot.iSlotId));

        if (err == KErrNone)

            {

            if (fep != NULL) 

                {

                feps.Append(fep);

                slot.iNodeId = fep->Fid().iNodeId;

                iMetaDataSlots.Append(slot);

                if (!fep->iParentNodeId)

                    {

                    // This must be the root

                    DEBUGSTRING(("Root found at slot %d",

                             iMetaDataSlots.Count() - 1));

                    iRootFep = fep;

                    }

                }

            }

        else

            {

            // All or nothing ...

            DEBUGSTRING(("LoadNode returned with err = %d", err));

            if (err != KErrEof)

                {

                User::Leave(err);

                }

            done = ETrue;

            }

        }

    // Now we have the restored the file entries

    TInt i;

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

        {

        CRsfwFileEntry* fep = feps[i];

        // Determine the next free node id

        if (fep->Fid().iNodeId >= iNodeId)

            {

            iNodeId = fep->Fid().iNodeId + 1;

            }

        if (fep->iParentNodeId == 0)

            {

            // This is the root node

            fep->SetParent(NULL);

            }

        else if (fep->iParentNodeId == 1)

            {

            // The parent is the root node

            fep->SetParent(iRootFep);

            iRootFep->iKids.Append(fep);

            }

        else

            {

            TInt j;

            // This is O(n**2)

            for (j = 0; j < feps.Count(); j++)

                {

                if (j != i)

                    {

                    // Find the parent for the node

                    CRsfwFileEntry* parent = feps[j];

                    if (fep->iParentNodeId == parent->Fid().iNodeId)

                        {

                        // Set up the two-way linkage

                        fep->SetParent(parent);

                        parent->iKids.Append(fep);

                        break;

                        }

                    }

                }

            }

        }

    // Final fixes

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

        {

        CRsfwFileEntry* fep = feps[i];

        // Fix volume ids and such ...

        TFid fid;

        fid = fep->Fid();

        fid.iVolumeId = iVolume->iMountInfo.iMountStatus.iVolumeId;

        fep->SetFid(fid);

        fep->iFileTable = this;

        // Add to LRU list (only cached files)

        if ( fep->Type() == KNodeTypeFile && fep->IsCached() 

            && (!iVolume->iVolumeTable->iUseExternalizedLRUList))

            {

            iVolume->iVolumeTable->AddToLRUPriorityListL(fep, ECachePriorityNormal);

            }

        // add item to metadata LRU list, 

        // only add childless directories and non-cached files

        if ( (fep->Type() == KNodeTypeFile && fep->iCachedSize == 0) 

             || (fep->Type() == KNodeTypeDir && fep->Kids()->Count() == 0) )

            {

            iVolume->iVolumeTable->AddToMetadataLRUPriorityListL(fep, ECachePriorityNormal);        

            }

        // Check consistency

        if ((fep != iRootFep) && (!fep->Parent()))

            {

            // Should never happen

            DEBUGSTRING16(("LodaMetaDataL() - parent missing for '%S'",

                           fep->Name()));

            }

        }

    // Now we don't need the file entry pointer array any more

    CleanupStack::PopAndDestroy(&feps); // feps

    return iRootFep;

    }

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

// CRsfwFileTable::SaveMetaDataDelta

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

// 

TInt CRsfwFileTable::SaveMetaDataDelta()

    {

    DEBUGSTRING16(("CRsfwFileTable::SaveMetaDataDelta"));

    TRAPD(err, SaveMetaDataDeltaL());

    if (err != KErrNone)

        {

        DEBUGSTRING(("SaveMetaDataDeltaL() returns %d", err));

        // Stop recording meta data

        iMetaDataEvents.Reset();

        iMetaDataSaveState = EMetaDataSaveFailed;

        }

    return err;

    }

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

// CRsfwFileTable::SetupCacheL

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

// 

void CRsfwFileTable::SetupCacheL()

    {

    if (iPermanence)

        {

        iMetaDataStore = CRsfwMetaDataStore::NewL(iMetaDataFilePath); 

        DEBUGSTRING(("SetupCacheL()"));

        // The format of label is <drive_letter>:<uri>.

        TRsfwMountConfig mountConfig;

        TRAPD(err, iMetaDataStore->GetMountConfigL(mountConfig));

        if ((err != KErrNone) ||

            mountConfig.iUri.Compare(iVolume->iMountInfo.iMountConfig.iUri) !=

            0)

            {

            // The saved metadata is not current - delete all

            DEBUGSTRING(("Clearing Metadata ..."));

            delete iMetaDataStore;

            iMetaDataStore = NULL;

            ClearCacheL();

            // Start from scratch

            iMetaDataStore = CRsfwMetaDataStore::NewL(iMetaDataFilePath);

            iMetaDataStore->SetMountConfigL(iVolume->iMountInfo.iMountConfig);

            }

        }

    else

        {

        ClearCacheL();

        }

    }

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

// CRsfwFileTable::TotalCachedSize

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

// 

TInt CRsfwFileTable::TotalCachedSize() 

    {

    if (!iRootFep)

        {

        return 0;

        }

    return iRootFep->TotalCachedSize(); 

    }

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

// CRsfwFileTable::TotalEntryCount

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

// 

TInt CRsfwFileTable::TotalEntryCount() 

    {

    if (!iRootFep)

        {

        return 0;

        }

    return iRootFep->TotalEntryCount(); 

    }

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

// CRsfwFileTable::ClearCacheL

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

// 

void CRsfwFileTable::ClearCacheL()

    {

    DEBUGSTRING(("Clearing cache ..."));

    TFileName cachePath = iCachePath;

    _LIT(KWild, "*");

    cachePath.Append(KWild);

    CFileMan* fM = CFileMan::NewL(iFs);

    CleanupStack::PushL(fM);

    TInt err = fM->Delete(cachePath, CFileMan::ERecurse);

    CleanupStack::PopAndDestroy(fM); // fM

    if (err != KErrNone)

        {

        DEBUGSTRING16(("Cache cleaning of '%S' failed with err=%d",

                       &cachePath,

                       err));

        }

    }

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

// CRsfwFileTable::NodeEvent

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

//   

TMetaDataEvent* CRsfwFileTable::NodeEvent(TInt aNodeId)

    {

    // Search downwards (for efficiency)

    TInt count = iMetaDataEvents.Count();

    if (count)

        {

        TInt i;

        for (i = count - 1; i >= 0; i--)

            {

            if (iMetaDataEvents[i].iNodeId == aNodeId)

                {

                return &iMetaDataEvents[i];

                }

            }

        }