/*
* Copyright (c) 2005 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:   CXcapCacheIndexAdmin
*
*/




// INCLUDE FILES
#include "ServerDefines.h"
#include "XcapCacheServer.h"
#include "XcapCacheIndexAdmin.h"
#include "XcapCacheIndexTableEntry.h"

// ----------------------------------------------------------
// CXcapCacheIndexAdmin::CXcapCacheIndexAdmin
// 
// ----------------------------------------------------------
//
CXcapCacheIndexAdmin::CXcapCacheIndexAdmin()
    {
    }

// ----------------------------------------------------------
// CXcapCacheIndexAdmin::NewL
// 
// ----------------------------------------------------------
//
CXcapCacheIndexAdmin* CXcapCacheIndexAdmin::NewL()
    {
    CXcapCacheIndexAdmin* self = new( ELeave ) CXcapCacheIndexAdmin();
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop();
    return self;
    }

// ----------------------------------------------------------
// CXcapCacheIndexAdmin::~CXcapCacheIndexAdmin
// 
// ----------------------------------------------------------
//
CXcapCacheIndexAdmin::~CXcapCacheIndexAdmin()
    {
    iEntryList.ResetAndDestroy();
    iEntryList.Close();
    }

// ----------------------------------------------------------
// CXcapCacheIndexAdmin::ConstructL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndexAdmin::ConstructL()
    {
    TInt length = 0;
    RFile indexTable = InitialisePageFileL();                                         
    CleanupClosePushL( indexTable );
    User::LeaveIfError( indexTable.Size( length ) );
    if( length > 0 )
        {
        HBufC8* data = HBufC8::NewLC( length );
        TPtr8 pointer( data->Des() );
        User::LeaveIfError( indexTable.Read( pointer ) );
        ReadEntriesL( pointer );
        CleanupStack::PopAndDestroy(); //data
        }
    CleanupStack::PopAndDestroy(); //index
    }

// ----------------------------------------------------------
// CXcapCacheIndex::InitialisePageFileL
// 
// ----------------------------------------------------------
//
RFile CXcapCacheIndexAdmin::InitialisePageFileL()
    {
    RFile ret;
    TInt error = ret.Open( CXcapCacheServer::FileSession(), KCacheServerPageFile,
                           EFileShareExclusive | EFileRead | EFileWrite );
    //No need to check the path at this time, because needed
    //directories have already been created by the CacheIndex
    //object if they didn't exist before the server was launched                           
    if( error != KErrNone )
        User::LeaveIfError( ret.Create( CXcapCacheServer::FileSession(), KCacheServerPageFile,
                                        EFileShareExclusive | EFileRead | EFileWrite ) );                           
    return ret;
    }
    
// ----------------------------------------------------------
// CXcapCacheIndexAdmin::UpdateIndexTableL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndexAdmin::UpdateIndexTableL( TInt aIndex, const TCacheEntryInfo* aHeader )
    {
    CXcapCacheIndexTableEntry* entry =
        CXcapCacheIndexTableEntry::NewL( aIndex, *aHeader->iRootUri,
                                         *aHeader->iDocumentUri );
    CleanupStack::PushL( entry );
    User::LeaveIfError( iEntryList.Append( entry ) );
    CleanupStack::Pop();  //entry
    }

// ----------------------------------------------------------
// CXcapCacheSession::ReadIndexL
// 
// ----------------------------------------------------------
//
TInt CXcapCacheIndexAdmin::ReadIndexL( const CXcapCacheIndexTableEntry& aEntry )
    {
    TBool found = EFalse;
    TInt ret = KErrNotFound;
    TInt count = iEntryList.Count();
    CXcapCacheIndexTableEntry* entry = NULL;
    for( TInt i = 0;!found && i < count;i++ )
        {
        entry = iEntryList[i];
        if( *entry == aEntry )
            { 
            ret = entry->Index();
            found = ETrue;
            }
        }
    return ret;
    }

// ----------------------------------------------------------
// CXcapCacheSession::FindL
// 
// ----------------------------------------------------------
//
CXcapCacheIndexTableEntry* CXcapCacheIndexAdmin::FindL( TInt& aTableIndex,
                                                        const TDesC8& aRootUri,
                                                        const TDesC& aDocumentUri )
    {
    #ifdef _DEBUG
        CXcapCacheServer::WriteToLog( _L8( "CXcapCacheIndexAdmin::FindL()" ) );
    #endif
    TBool found = EFalse;
    TInt count = iEntryList.Count();
    CXcapCacheIndexTableEntry* entry = NULL;
    if( count > 0 )
        {
        CXcapCacheIndexTableEntry* newEntry = CXcapCacheIndexTableEntry::NewL(
                                              aRootUri, aDocumentUri );
        for( TInt i = 0;!found && i < count;i++ )
            {
            CXcapCacheIndexTableEntry* listEntry = iEntryList[i];
            if( *newEntry == *listEntry )
                {
                aTableIndex = i;
                entry = iEntryList[i];
                found = ETrue;
                }
            }
        delete newEntry;
        newEntry = NULL;
        }
    return entry;
    }

// ----------------------------------------------------------
// CXcapCacheSession::RemoveTableIndexL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndexAdmin::RemoveTableIndex( TInt aIndex )
    {
    TInt count = iEntryList.Count();
    if( count > 0 && aIndex >= 0 && aIndex < count )
        {
        CXcapCacheIndexTableEntry* entry = iEntryList[aIndex];
        iEntryList.Remove( aIndex );
        delete entry;
        entry = NULL;
        for( TInt i = aIndex;i < count - 1;i++ )
            {
            CXcapCacheIndexTableEntry* z = iEntryList[i];
            z->Decrease();
            }   
        }
    }

// ----------------------------------------------------------
// CXcapCacheSession::StoreIndexTableL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndexAdmin::StoreIndexTableL()
    {
    RFile indexTable;
    TInt count = iEntryList.Count();
    if( count > 0 )
        {
        TBuf8<7> numBuf;
        User::LeaveIfError( indexTable.Replace( CXcapCacheServer::FileSession(),
                                                KCacheServerPageFile, EFileWrite ) );
        CleanupClosePushL( indexTable );
        for( TInt i = 0;i < count;i++ )
            {
            numBuf.AppendNum( iEntryList[i]->Index() );
            indexTable.Write( iEntryList[i]->RootUri() );
            indexTable.Write( KValueFieldSeparator );
            indexTable.Write( iEntryList[i]->DocumentUri() );
            indexTable.Write( KPageFileSeparator );
            indexTable.Write( numBuf );
            indexTable.Write( KIndexFileEndOfLine );
            numBuf.Zero();
            }
        CleanupStack::PopAndDestroy();  //indexTable
        }
    else
        {
        CFileMan* manager = CFileMan::NewL( CXcapCacheServer::FileSession() );
        manager->Delete( KCacheServerPageFile );
        delete manager;
        manager = NULL;
        }
    }

// ----------------------------------------------------------
// CXcapCacheSession::UpdatePageFileL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndexAdmin::ReadEntriesL( TPtr8& aDataDesc )
    {
    TBool finished = EFalse;
    while( !finished && aDataDesc.Length() > 0 )
        {
        //If we find that there is still more data, but no \r\n
        //to denote the end of an entry, simply quit. The data
        //format has most probably been corrupted at some point.
        TInt entryIndex = aDataDesc.FindF( KIndexFileEndOfLine );
        if( entryIndex > 0 )
            {
            TPtrC8 one = aDataDesc.Left( entryIndex );
            CXcapCacheIndexTableEntry* entry = ParseOneEntryL( one );
            CleanupStack::PushL( entry );
            User::LeaveIfError( iEntryList.Append( entry ) );
            CleanupStack::Pop();
            aDataDesc.Delete( 0, entryIndex + 2 );
            }
        else finished = ETrue;
        }
    }

// ----------------------------------------------------------
// CXcapCacheSession::ParseOneEntryL
// 
// ----------------------------------------------------------
//
CXcapCacheIndexTableEntry* CXcapCacheIndexAdmin::ParseOneEntryL( const TDesC8& aEntryData )
    {
    CXcapCacheIndexTableEntry* ret = NULL;
    TInt rootIndex = aEntryData.FindF( KValueFieldSeparator );
    if( rootIndex > 0 )
        {
        TPtrC8 root( aEntryData.Left( rootIndex ) );
        TInt docIndex = aEntryData.FindF( KPageFileSeparator );
        TPtrC8 doc( aEntryData.Mid( rootIndex + 1, docIndex - ( rootIndex + 1 ) ) );
        TPtrC8 pos( aEntryData.Mid( docIndex + 1, aEntryData.Length() - ( docIndex + 1 ) ) );
        TInt index( CXcapCacheServer::ConvertDesc( pos ) );
        ret = CXcapCacheIndexTableEntry::NewL( index, root, doc );
        }
    return ret;
    }