/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  Implementation of CHttpCacheLookupTable

*

*/

// INCLUDE FILES

#include "HttpCacheLookupTable.h"

#include "HttpCacheEntry.h"

#include "HttpCacheUtil.h"

#include "HttpCacheEvictionHandler.h"

#include "HttpCacheStreamHandler.h"

#include <e32cmn.h>

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// Golden ratio - arbitrary start value to avoid mapping all 0's to all 0's

// or anything like that.

const TUint KHashPHI = 0x9e3779b9U;

//

const TUint KHashStringLength = 16;

// kbyte

//

const TUint KHttpCacheLookupTableSize = 217;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

// ============================ MEMBER FUNCTIONS ===============================

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

// CHttpCacheLookupTable::CHttpCacheLookupTable

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CHttpCacheLookupTable::CHttpCacheLookupTable(

    CHttpCacheEvictionHandler& aEvictionHandler,

    CHttpCacheStreamHandler& aStreamHandler )

    : iEvictionHandler( &aEvictionHandler ),

      iStreamHandler( &aStreamHandler )

    {

    }

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

// CHttpCacheLookupTable::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CHttpCacheLookupTable::ConstructL()

    {

    iEntries = new( ELeave )CArrayPtrFlat<CHttpCacheEntry>( KHttpCacheLookupTableSize );

    for ( TInt i = 0; i < KHttpCacheLookupTableSize; i++ )

        {

        iEntries->AppendL( NULL );

        }

    }

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

// CHttpCacheLookupTable::NewL

// Two-phased constructor.

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

//

CHttpCacheLookupTable* CHttpCacheLookupTable::NewL(

    CHttpCacheEvictionHandler& aEvictionHandler,

    CHttpCacheStreamHandler& aStreamHandler )

    {

    CHttpCacheLookupTable* self = new( ELeave ) CHttpCacheLookupTable( aEvictionHandler, aStreamHandler );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

CHttpCacheLookupTable::~CHttpCacheLookupTable()

    {

    // do not call ResetAndDestroy on iEntries

    // as delete item are not set to NULL

    if (iEntries)

    {

      for( TInt i = 0; i < iEntries->Count(); i++ )

          {

          if( Valid( i ) )

              {

              CHttpCacheEntry* entry = iEntries->At( i );

              delete entry;

              }

          }

      iEntries->Reset();

    }

    delete iEntries;

    }

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

// CHttpCacheLookupTable::InsertL

//

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

//

CHttpCacheEntry* CHttpCacheLookupTable::InsertL(

    const TDesC8& aUrl )

    {

    // create and insert the item

    CHttpCacheEntry* entry = CHttpCacheEntry::NewLC( aUrl, *iEvictionHandler );

    if( InsertL( entry ) == KErrCorrupt )

        {

        // cleanup

        CleanupStack::PopAndDestroy(); // entry

        entry = NULL;

        }

    else

        {

#ifdef __CACHELOG__

        HttpCacheUtil::WriteFormatLog(0, _L("  Added entry %08x to list."), entry);

#endif

        entry->Accessed();

        iStreamHandler->InitialiseCacheEntryL(*entry);

        // lookuptable takes ownership

        CleanupStack::Pop(); // entry

        }

    return entry;

    }

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

// CHttpCacheLookupTable::Find

//

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

//

CHttpCacheEntry* CHttpCacheLookupTable::Find( const TDesC8& aUrl )

    {

    CHttpCacheEntry* entry = NULL;

    TInt pos( Probe( aUrl, EFalse ) );

#ifdef __CACHELOG__

    HttpCacheUtil::WriteUrlToLog(0, _L("CHttpCacheLookupTable::Find"), aUrl);

    HttpCacheUtil::WriteFormatLog(0, _L("  Probe returned position %d"), pos);

#endif

    if ( Valid( pos ) )

        {

#ifdef __CACHELOG__

        HttpCacheUtil::WriteFormatLog(0, _L("  Entry %d valid."), pos);

#endif

        entry = iEntries->At( pos );

        if ( entry )

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteFormatLog(0, _L("  BodySize is %d\n  State is %d"), entry->BodySize(), entry->State());

#endif

            if ( entry->BodySize() == 0 &&

                 entry->State() == CHttpCacheEntry::ECacheComplete )

                {

#ifdef __CACHELOG__

                HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CHttpCacheLookupTable::Find - Found ZERO size (can't reuse)"),

                                           entry->Filename(),

                                           entry->Url(),

                                           pos,

                                           ELogLookupTablePos );

#endif

                return NULL;

                }

            }

        }

#ifdef __CACHELOG__

    HttpCacheUtil::WriteFormatLog(0, _L("  returning entry pointer 0x%08x"), entry);

#endif

    return entry;

    }

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

// CHttpCacheLookupTable::Remove

//

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

//

TInt CHttpCacheLookupTable::Remove( const TDesC8& aUrl )

    {

    TInt status( KErrNotFound );

    TInt pos( Probe( aUrl, EFalse ) );

#ifdef __CACHELOG__

    HttpCacheUtil::WriteUrlToLog(0, _L("CHttpCacheLookupTable::Remove"), aUrl);

    HttpCacheUtil::WriteFormatLog(0, _L("  Probe returned position %d"), pos);

#endif

    if( Valid( pos ) )

        {

        // remove only nonactive entry

        CHttpCacheEntry* entry = iEntries->At( pos );

        if ( entry->State() == CHttpCacheEntry::ECacheComplete )

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CHttpCacheLookupTable::Remove - ERASING item"),

                                           entry->Filename(),

                                           entry->Url(),

                                           pos,

                                           ELogLookupTablePos );

#endif

            Erase( pos );

            status = KErrNone;

            }

#ifndef __CACHELOG__

        }

#else //__CACHELOG__

        else

            {

            HttpCacheUtil::WriteLogFilenameAndUrl( 0,

                                           _L("CHttpCacheLookupTable::Remove - can NOT remove item, is active state"),

                                           entry->Filename(),

                                           entry->Url(),

                                           pos,

                                           ELogLookupTablePos );

            }

        }

    else

        {

        HttpCacheUtil::WriteFormatLog( 0, _L( "CHttpCacheLookupTable::Remove - item %d is not valid. cannot be removed" ), pos );

        }

#endif // __CACHELOG__

    return status;

    }

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

// CHttpCacheLookupTable::EraseCacheEntry

//

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

//

void CHttpCacheLookupTable::EraseCacheEntry( const TDesC8& aUrl )

    {

    TInt pos( Probe( aUrl, EFalse ) );

    if ( Valid( pos ) )

        {

        Erase( pos );

        }

#ifdef __CACHELOG__

    else

        {

        // there must be a valid position for this entry

        __ASSERT_DEBUG( EFalse, User::Panic( _L("cacheHandler Panic"), KErrCorrupt ) );

        }

#endif // __CACHELOG__

    }

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

// CHttpCacheLookupTable::RemoveAll

//

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

//

TInt CHttpCacheLookupTable::RemoveAll()

    {

    TInt numberOfBytes( 0 );

#ifdef __CACHELOG__

    HttpCacheUtil::WriteLog( 0, _L( "CHttpCacheLookupTable::RemoveAll - remove 'em all" ) );

#endif

    for ( TInt i = 0; i < iEntries->Count(); i++ )

        {

        CHttpCacheEntry* entry = iEntries->At( i );

        // Remove all nonactive entries

        if ( Valid( i ) && entry->State() == CHttpCacheEntry::ECacheComplete )

            {

            numberOfBytes += ( entry->HeaderSize() + entry->BodySize() );

            Erase( i );

            }

        }

#ifdef __CACHELOG__

    HttpCacheUtil::WriteLog( 0, _L( "number of items left:" ), iCount );

    // check if there are pending items -should not be though

    __ASSERT_DEBUG( iCount == 0, User::Panic( _L("cacheHandler Panic"), KErrCorrupt ) );

#endif // __CACHELOG__

    return numberOfBytes;

    }

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

// CHttpCacheLookupTable::ListFiles

// Adds all filenames known to this lookup table to aFilenameList

// No ownership transfer occurs, only pointers are added

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

//

TInt CHttpCacheLookupTable::ListFiles(RPointerArray<TDesC>& aFilenameList)

    {

    TInt count( 0 );

    TInt error( KErrNone );

    //1. Tally up

    for (TInt i = 0; i < iEntries->Count(); i++)

        {

        if (Valid(i)) count++;

        }

    //2. Preallocation.

    TInt existing( aFilenameList.Count() );

    error = aFilenameList.Reserve( existing + count );

    if (error == KErrNone)

        {

        //3. Iterate once more and add pointers to filename strings

        for (TInt i = 0; i < iEntries->Count(); i++)

            {

            if (Valid(i))

                {

                //add filename pointer to the array.

                const TDesC* ptr = &(iEntries->At(i)->Filename());

                aFilenameList.Append( ptr ); // no ownership transfer happens here

                }

            }

        }

    return error;

    }

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

// CHttpCacheLookupTable::InternalizeL

//

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

//

void CHttpCacheLookupTable::InternalizeL(

    RReadStream& aReadStream,

    const TDesC& aDirectory )

    {

    // get number of entries

    TInt version = 0;

    version = aReadStream.ReadInt32L();

    if ( version == KCacheVersionNumber )

        {

        // read directory stub and validate it

        TInt len = aReadStream.ReadInt32L();

        HBufC* dirstub = HBufC::NewLC(len);

        TPtr dirstubptr = dirstub->Des();

        aReadStream.ReadL( dirstubptr, len );

        ASSERT( aDirectory.CompareF( dirstubptr ) == 0 );

        CleanupStack::PopAndDestroy( dirstub );

        TInt count( aReadStream.ReadInt32L() );

        TInt contentSize( 0 );

        TInt err;

        for( TInt i = 0; i < count; i++ )

            {

            // create empty object

            CHttpCacheEntry* entry = CHttpCacheEntry::NewLC( KNullDesC8, *iEvictionHandler );

            // read it

            err = entry->Internalize( aReadStream, aDirectory );

            // leave only on no memory

            if( err == KErrNone )

                {

                // insert to the table

                InsertL( entry );

                contentSize += entry->HeaderSize();

                contentSize += entry->BodySize();

                }

            else if ( err == KErrNoMemory )

                {

                User::Leave( KErrNoMemory );

                }

            else

                {

                // suggestions

                }

            // takes ownership

            CleanupStack::Pop(); // entry

            }

        // set startup cache size

#ifdef __CACHELOG__

        HttpCacheUtil::WriteLog( 0, _L( "startup content size" ), contentSize );

#endif

        iStreamHandler->SetSavedContentSize( contentSize );

        }

    else

        {

        // cleanup index.dat

        }

    }

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

// CHttpCacheLookupTable::Externalize

//

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

//

void CHttpCacheLookupTable::ExternalizeL(

    RWriteStream& aWriteStream, const TDesC& aDirectory )

    {

    // write version number and the number of entries

    TRAP_IGNORE( aWriteStream.WriteInt32L( KCacheVersionNumber ) );

    // directory stub length

    aWriteStream.WriteInt32L( aDirectory.Length() ) ;

    // directory stub

    aWriteStream.WriteL( aDirectory );

    // entry count - don't write entries with zero body length, so precalculate this.

    TInt goingToWrite = 0;

    for( TInt i = 0; i < iEntries->Count(); i++ )

        {

        CHttpCacheEntry* entry = iEntries->At( i );

        // save complete entries only

        if( Valid( i ) && entry->BodySize() > 0 )

            {

            goingToWrite++;

            }

        }

    aWriteStream.WriteInt32L( goingToWrite );

    for( TInt i = 0; i < iEntries->Count(); i++ )

        {

        CHttpCacheEntry* entry = iEntries->At( i );

        // save complete entries only

        if( Valid( i ) && entry->BodySize() > 0 )

            {

            // save entry

            TInt err;

            err = entry->Externalize( aWriteStream, aDirectory );

            // leave only on no memory

            if ( err == KErrNoMemory )

                {

                User::Leave( KErrNoMemory );

                }

            }

        }

    }

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

// CHttpCacheLookupTable::InsertL

//

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

//

TInt CHttpCacheLookupTable::InsertL(

    CHttpCacheEntry* aCacheEntry )

    {

    __ASSERT_DEBUG( aCacheEntry != NULL,

        User::Panic( _L("cacheHandler Panic"), KErrCorrupt ) );

    TInt pos( -1 );

    if ( aCacheEntry )

        {

        pos = Probe( aCacheEntry->Url(), ETrue );

#ifdef __CACHELOG__

        HttpCacheUtil::WriteUrlToLog(0, _L("CHttpCacheLookupTable::InsertL"), aCacheEntry->Url());

        HttpCacheUtil::WriteFormatLog(0, _L("  Probe returned position %d"), pos);

#endif

        // double check

        if( Valid( pos ) )

            {

#ifdef __CACHELOG__

            HttpCacheUtil::WriteLog(0, _L("  Valid entry already exists according to Valid(). Rehash table."));

#endif

            // try to rehash the table if probe failed

            ReHashL();

            pos = Probe( aCacheEntry->Url(), ETrue );

#ifdef __CACHELOG__

            HttpCacheUtil::WriteFormatLog(0, _L("  ReProbe after rehash returned new position %d"), pos);

#endif

            if( pos == -1 || Valid( pos ) )

                {

#ifdef __CACHELOG__

                HttpCacheUtil::WriteLog(0, _L("  Pos already filled (or == -1) - Couldn't find an empty slot to store it."));

#endif

                // completly failed

                pos = -1;

                }

            }

        // insert

        if( pos != -1 )

            {

            iEntries->At( pos ) = aCacheEntry;

            iCount++;