/*

* 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

        {

        entry->Accessed();

        // lookuptable takes ownership

        CleanupStack::Pop(); // entry

        }

    return entry;

    }

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

// CHttpCacheLookupTable::Find

//

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

//

CHttpCacheEntry* CHttpCacheLookupTable::Find(

    const TDesC8& aUrl )

    {

    CHttpCacheEntry* entry = NULL;

  TInt pos( Probe( aUrl, EFalse ) );

    //

  if( Valid( pos ) )

        {

        entry = iEntries->At( pos );

        }

  return entry;

    }

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

// CHttpCacheLookupTable::Remove

//

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

//

TInt CHttpCacheLookupTable::Remove(

    const TDesC8& aUrl )

    {

    TInt status( KErrNotFound );

  TInt pos( Probe( aUrl, EFalse ) );

    //

  if( Valid( pos ) )

        {

        // remove only nonactive entry

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

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

            {

            Erase( pos );

            status = KErrNone;

            HttpCacheUtil::WriteLog( 0, _L( "remove item" ), pos );

            }

#ifndef __CACHELOG__

        }

#else // __CACHELOG__

        else

            {

            HttpCacheUtil::WriteLog( 0, _L( "item is active. cannot be removed" ), pos );

            }

        }

    else

        {

        HttpCacheUtil::WriteLog( 0, _L( "item is not valid. cannot be removed" ), pos );

        }

#endif // __CACHELOG__

    return status;

    }

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

// CHttpCacheLookupTable::EraseCorruptEntry

//

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

//

void CHttpCacheLookupTable::EraseCorruptEntry(

    const TDesC8& aUrl )

    {

  TInt pos( Probe( aUrl, EFalse ) );

    //

  if( Valid( pos ) )

        {

        Erase( pos );

        HttpCacheUtil::WriteLog( 0, _L( "remove corrupt item" ), pos );

        }

#ifdef __CACHELOG__

    else

        {

        // there must be a valid position for this entry

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

        HttpCacheUtil::WriteLog( 0, _L( "corrupt item is not valid" ), pos );

        }

#endif // __CACHELOG__

    }

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

// CHttpCacheLookupTable::RemoveAll

//

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

//

TInt CHttpCacheLookupTable::RemoveAll()

    {

    TInt numberOfBytes( 0 );

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

    //

    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->Size() );

            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::Internalize

//

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

//

void CHttpCacheLookupTable::InternalizeL(

    RFileReadStream& aReadStream,

    const TDesC& /*aDirectory*/ )

    {

    // get number of entries

    TInt version = 0;

    TRAP_IGNORE( version = aReadStream.ReadInt32L() );

    if( version == KCacheVersionNumber )

        {

        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 );

            // leave only on no memory

            if( err == KErrNone )

                {

                // insert to the table

                InsertL( entry );

                contentSize+=entry->HeaderSize();

                contentSize+=entry->Size();

                }

            else if( err == KErrNoMemory )

                {

                User::Leave( KErrNoMemory );

                }

            else

                {

                // suggestions?

                }

            // takes ownership

            CleanupStack::Pop(); // entry

            }

        // set startup cache size

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

        iStreamHandler->SetStartupCacheSize( contentSize );

        }

    else

        {

        // cleanup index.dat?

        }

    }

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

// CHttpCacheLookupTable::Externalize

//

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

//

void CHttpCacheLookupTable::ExternalizeL(

    RFileWriteStream& aWriteStream )

    {

    // write version number and the number of entries

    TRAP_IGNORE( aWriteStream.WriteInt32L( KCacheVersionNumber );

    aWriteStream.WriteInt32L( iCount ) );

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

        {

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

        // save complete entries only

        if( Valid( i ) )

            {

            // save entry

            TInt err;

            err = entry->Externalize( aWriteStream );

            // 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 );

        // double check

        if( Valid( pos ) )

            {

            // try to rehash the table if probe failed

            ReHashL();

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

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

                {

                // completly failed

                pos = -1;

                }

            }

        // insert

        if( pos != -1 )

            {

            iEntries->At( pos ) = aCacheEntry;

            iCount++;

            HttpCacheUtil::WriteLog( 0, _L( "insert new item to the lookuptable" ), pos );

            // check if the hashtable is full

            if( iCount > ( iEntries->Count() >> 1 ) )

                {

                ReHashL();

                }

            }

        else

            {

            // lose entry???

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

            }

        }

    return pos == -1 ? KErrCorrupt : KErrNone;

    }

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

// CHttpCacheLookupTable::Probe

//

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

//

TInt CHttpCacheLookupTable::Probe(

    const TDesC8& aKey,

    TBool aInsert )

    {

    //

  TInt collision( 0 );

  TInt pos( HashUrl( aKey ) );

  if( aInsert )

        {

        // insert

        while( Valid( pos ) && ( collision < ( iEntries->Count() / 2 ) ) )

            {

            pos += ++collision * 2 - 1;

            pos = pos % iEntries->Count();

            }

        }

    else

        {

        // find

      while( !Empty( pos ) )

            {

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

            if( Valid( pos ) && entry && entry->Url().CompareF( aKey ) == 0 )

                {

                break;

                }

            if( collision > iEntries->Count() )

                {

                return -1;

                }

            pos += ++collision * 2 - 1;

            pos = pos % iEntries->Count();

            }

        }

#ifdef __CACHELOG__

    if( collision > 0 )

        {

        HttpCacheUtil::WriteLog( 1, _L( "collision" ), collision );

        }

#endif // __CACHELOG__

  return pos;

    }

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

// CHttpCacheLookupTable::HashUrl

//

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

//

TInt CHttpCacheLookupTable::HashUrl(

    const TDesC8& aUrl )

    {

    // This hash algorithm comes from:

    // http://burtleburtle.net/bob/hash/hashfaq.html

    // http://burtleburtle.net/bob/hash/doobs.html

    TUint len( aUrl.Length() );

    TUint h( KHashPHI );

    h += len;

    h += (h << 10);

    h ^= (h << 6);

    //

    if( len )

        {

        // hash backward to avoid collisions

        // as the first part of the url is

        // always the same http://www.

        // take 16 characters by default

        TUint hashStringLength( len < KHashStringLength ? len : KHashStringLength );

        for( TUint i = ( len - 1 ); i > len - hashStringLength; i-- )

            {

        h += aUrl[ i ];

        h += (h << 10);

        h ^= (h << 6);

          }

        }

    h += (h << 3);

    h ^= (h >> 11);

    h += (h << 15);

    //

    h = h % iEntries->Count();

#ifdef __CACHELOG__

    HttpCacheUtil::WriteUrlToLog( 1, aUrl, h );

#endif // __CACHELOG__

    return h;

    }

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

// CHttpCacheLookupTable::ReHashL

//

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

//

void CHttpCacheLookupTable::ReHashL()

    {

    HttpCacheUtil::WriteLog( 1, _L( "Resize lookuptable!" ) );