/*
* 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:   CXcapCacheIndex
*
*/




// INCLUDE FILES
#include "ServerDefines.h"
#include "XcapCacheIndex.h"
#include "XcapCacheServer.h"
#include "XcapCacheIndexEntry.h"

// ----------------------------------------------------------
// CXcapCacheIndex::CXcapCacheIndex
// 
// ----------------------------------------------------------
//
CXcapCacheIndex::CXcapCacheIndex()
    {
    }

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

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

// ----------------------------------------------------------
// CXcapCacheIndex::InitialiseIndexL
// 
// ----------------------------------------------------------
//
RFile CXcapCacheIndex::InitialiseIndexL()
    {
    RFile ret;
    TUid process = RProcess().Identity();
    #ifdef _DEBUG
        CXcapCacheServer::WriteToLog( _L8( "CXcapCacheIndex::InitialiseIndexL() - Process: %x" ), process ) ;
    #endif
    TInt error = ret.Open( CXcapCacheServer::FileSession(), KCacheServerIndex,
                           EFileShareExclusive | EFileRead | EFileWrite );
    if( error != KErrNone )
        {
        if( error == KErrPathNotFound )
            User::LeaveIfError( CXcapCacheServer::FileSession().MkDirAll( KCacheServerRoot ) );
        User::LeaveIfError( ret.Create( CXcapCacheServer::FileSession(), KCacheServerIndex,
                            EFileShareExclusive | EFileRead | EFileWrite ) );
        }
    return ret;
    }
    
// ----------------------------------------------------------
// CXcapCacheIndex::~CXcapCacheIndex
// 
// ----------------------------------------------------------
//
CXcapCacheIndex::~CXcapCacheIndex()
    {
    iEntryList.ResetAndDestroy();
    iEntryList.Close();
    }

// ----------------------------------------------------------
// CXcapCacheIndex::ConstructL
// 
// ----------------------------------------------------------
//
TInt CXcapCacheIndex::UpdateIndexL( const CXcapCacheIndexEntry* aEntry )
    {
    if( aEntry != NULL )
        {
        User::LeaveIfError( iEntryList.Append( aEntry ) );
        return iEntryList.Find( aEntry );
        }
    else return KErrNotFound;
    }

// ----------------------------------------------------------
// CXcapCacheIndex::Entry
// 
// ----------------------------------------------------------
//
CXcapCacheIndexEntry* CXcapCacheIndex::Entry( TInt aIndex ) const
    {
    TInt count = iEntryList.Count();
    CXcapCacheIndexEntry* entry = NULL;
    if( count > 0 && aIndex >= 0 && aIndex < count )
        entry = iEntryList[aIndex];
    return entry;
    }

// ----------------------------------------------------------
// CXcapCacheIndex::EntryCount
// 
// ----------------------------------------------------------
//
TInt CXcapCacheIndex::EntryCount() const
	{
	return iEntryList.Count();
	}

// ----------------------------------------------------------
// CXcapCacheIndex::Compare
// 
// ----------------------------------------------------------
//
TInt CXcapCacheIndex::Compare( const CXcapCacheIndexEntry& aFirst,
                               const CXcapCacheIndexEntry& aSecond )
    {
    if( aFirst.LastModified() == aSecond.LastModified() )
        return 0;
    else if( aFirst.LastModified() > aSecond.LastModified() )
        return 1;
    else return -1;
    }

// ----------------------------------------------------------
// CXcapCacheIndex::SortEntries
// 
// ----------------------------------------------------------
//
void CXcapCacheIndex::SortEntriesL()
    {
    TLinearOrder<CXcapCacheIndexEntry> order( CXcapCacheIndex::Compare );
    iEntryList.Sort( order );
    #ifdef _DEBUG
        TPtrC8 entryDesc;
        TInt count = iEntryList.Count();
        CXcapCacheServer::WriteToLog( _L8( "CXcapCacheIndex::SortEntriesL()" ) );
        CXcapCacheServer::WriteToLog( _L8( "------------------------------------------" ) );
        CXcapCacheServer::WriteToLog( _L8( " Sorted list:" ) );
        for( TInt i = 0;i < count;i++ )
            {
            HBufC* buffer = NULL;
            buffer = CXcapCacheServer::DateTimeL( iEntryList[i]->LastModified() );
            TBuf8<KDateTimeMaxSize> printBuffer( _L8( "  " ) );
            printBuffer.AppendFormat( _L8( "%d: " ), i );
            printBuffer.Append( *buffer );
            CXcapCacheServer::WriteToLog( printBuffer );
            }
        CXcapCacheServer::WriteToLog( _L8( "------------------------------------------" ) );
    #endif
    }

// ----------------------------------------------------------
// CXcapCacheIndex::RemoveEntry
// 
// ----------------------------------------------------------
//
void CXcapCacheIndex::RemoveEntry( TInt aIndex )
    {
    TInt count = iEntryList.Count();
    if( count > 0 && aIndex >= 0 && aIndex < count )
        {
        CXcapCacheIndexEntry* entry = iEntryList[aIndex];
        iEntryList.Remove( aIndex );
        delete entry;
        entry = NULL;
        }
    }

// ----------------------------------------------------------
// CXcapCacheIndex::ReadEntriesL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndex::ReadEntriesL( TPtr8& aIndexData )
    {
    TBool finished = EFalse;
    while( !finished && aIndexData.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 = aIndexData.FindF( KIndexFileEndOfLine );
        if( entryIndex > 0 )
            {
            TPtr8 entryData = CXcapCacheServer::DescriptorCast( 
                              aIndexData.Left( entryIndex ) );
            CXcapCacheIndexEntry* entry = CXcapCacheIndexEntry::NewL( entryData );
            CleanupStack::PushL( entry );
            User::LeaveIfError( iEntryList.Append( entry ) );
            CleanupStack::Pop();
            aIndexData.Delete( 0, entryIndex + 2 );
            }
        else finished = ETrue;
        }
    }

// ----------------------------------------------------------
// CXcapCacheIndex::ConstructL
// 
// ----------------------------------------------------------
//
void CXcapCacheIndex::StoreCacheDataL()
    {
    RFile index;
    TInt count = iEntryList.Count();
    if( count > 0 )
        {
        User::LeaveIfError( index.Replace( CXcapCacheServer::FileSession(),
                            KCacheServerIndex, EFileWrite ) );
        CleanupClosePushL( index );
        for( TInt i = 0;i < count;i++ )
            {
            CXcapCacheIndexEntry* entry = iEntryList[i];
            HBufC8* entryData = entry->PrintLC();
            if( entryData )
                {
                User::LeaveIfError( index.Write( entryData->Des() ) );
                CleanupStack::PopAndDestroy();  //entryData
                }
            }
        CleanupStack::PopAndDestroy();  //index
        }
    else
        {
        CFileMan* manager = CFileMan::NewL( CXcapCacheServer::FileSession() );
        manager->Delete( KCacheServerIndex );
        delete manager;
        manager = NULL;
        }
    }