/*

* Copyright (c) 2002-2009 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:  This module contains the implementation of 

*                CNWNetworkHZCbCacheHandler class member functions.

*

*/

// INCLUDE FILES

#include    <e32math.h>  // for Math::Random

#include    "NWLogger.h"

#include    "CNWNetworkHZCbCacheHandler.h"

// FORWARD DECLARATIONS

class Math;

// DEFINITIONS

const TInt KMaxNumberOfItemsInHomeZoneCache = 21;

const TInt KMaxNumberOfItemsInCityZoneCache = 5;

// LOCAL FUNCTIONS

LOCAL_C void PrintCacheContent( 

    const RArray<RMmCustomAPI::TViagCacheRecordContent> * aCache, 

    const TInt aCacheId )

    {

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

        {

        RMmCustomAPI::TViagCacheRecordContent rec = (*aCache)[i];

        TBuf<70> buffer;

        _LIT(KData,"Cache[%d], Position[%d], LacId[%d], CellId[%d]");

        buffer.Format(KData, aCacheId, i, rec.iLac, rec.iCellId);

        NWLOGSTRING2( KNWINT, "NW: CBS HZ: PrintCacheContent, %S", &buffer );

        }

    }

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

// CNWNetworkHZCbCacheHandler::NewL

// 

// (other items were commented in a header).

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

//

CNWNetworkHZCbCacheHandler * CNWNetworkHZCbCacheHandler::NewL( 

    RMmCustomAPI& aCustomAPI )

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::NewL() Begin " );

    CNWNetworkHZCbCacheHandler * self = 

        new (ELeave) CNWNetworkHZCbCacheHandler( aCustomAPI );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::NewL() End " );

    return self;

    }

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

// CNWNetworkHZCbCacheHandler::CNWNetworkHZCbCacheHandler

// 

// (other items were commented in a header).

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

//

CNWNetworkHZCbCacheHandler::CNWNetworkHZCbCacheHandler( 

    RMmCustomAPI& aCustomAPI ) : iCustomAPI (aCustomAPI) 

    { 

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::\

        CNWNetworkHZCbCacheHandler() called " );

    }

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

// CNWNetworkHZCbCacheHandler::ConstructL

// 

// (other items were commented in a header).

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

//

void CNWNetworkHZCbCacheHandler::ConstructL()

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::ConstructL() Begin " );

    iSimCacheMonitor = CNWNetworkEFReader::NewL( iCustomAPI, this );

    SetInitialisingStatus( ECBSHZCacheReader_NotInitialised );

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler: ConstructL() End " );

    }

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

// CNWNetworkHZCbCacheHandler::~CNWNetworkHZCbCacheHandler

// 

// (other items were commented in a header).

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

//

CNWNetworkHZCbCacheHandler::~CNWNetworkHZCbCacheHandler()

    {

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::\

        ~CNWNetworkHZCbCacheHandler() Begin " );

    if ( iSimCacheMonitor )

        {

        iSimCacheMonitor->Cancel();

        }

    delete iSimCacheMonitor;

    iSimCache1.Close();

    iSimCache2.Close();

    iSimCache3.Close();

    iDynCache.Close();    

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::\

        ~CNWNetworkHZCbCacheHandler() End " );

    }

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

// CNWNetworkHZCbCacheHandler::InitialiseHomeZoneCaches

// 

// (other items were commented in a header).

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

//

void CNWNetworkHZCbCacheHandler::InitialiseHomeZoneCachesAsync(

    MHZCachesInitialisationObserver * aObserver )

    {

    NWLOGSTRING( KNWINT, "NW: CB HZ:: InitialiseHomeZoneCachesAsync Begin" );

    iObserver = aObserver;

    TInt error( KErrNotFound );

    SetInitialisingStatus( ECBSHZCacheReader_Initialising_Cache_HZ1 );

    error = iSimCacheMonitor->StartMonitoringSimCache( this );

    if ( error != KErrNone )

        {

        NWLOGSTRING( KNWINT, 

            "NW:CB HZ:InitialiseHomeZoneCachesAsync Already active!" );

        NWLOGSTRING2( KNWINT, 

            "NW:CB HZ:InitialiseHomeZoneCachesAsync(),\

            error = %d", error );

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW CNWNetworkHZCbCacheHandler::\

        InitialiseHomeZoneCachesAsync() End " );

    }

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

// CNWNetworkHZCbCacheHandler::Find

// 

// (other items were commented in a header).

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

//

TInt CNWNetworkHZCbCacheHandler::Find( THomeZoneCacheId aCacheId,

    RMmCustomAPI::TViagCacheRecordContent aRecord )

    {

    NWLOGSTRING3( KNWINT, 

        "NW: CNWNetworkHZCbCacheHandler::Find() Begin,\

        aRecord.iLac = %d, aRecord.iCellId = %d ",

        aRecord.iLac, aRecord.iCellId );

    if( InitialisingStatus() != ECBSHZCacheReader_Ready )

        {

        NWLOGSTRING( KNWINT, 

            "NW: CNWNetworkHZCbCacheHandler::Find(),\

             CBSHZCacheReader not ready!");

        return KErrNotReady;

        }

    TInt retVal = KErrNotFound;

    RArray<RMmCustomAPI::TViagCacheRecordContent> * cache;

    cache = Cache( aCacheId );

    ASSERT( cache );

    if( cache )

        {

        retVal = cache->Find( aRecord );

        }

    NWLOGSTRING2( KNWINT, 

        "NW: CNWNetworkHZCbCacheHandler::Find() End,\

        retVal = %d ", retVal );

    return retVal;        

    }

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

// CNWNetworkHZCbCacheHandler::Insert

// 

// (other items were commented in a header).

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

//

TInt CNWNetworkHZCbCacheHandler::Insert(

    const THomeZoneCacheId aCacheId,

    const RMmCustomAPI::TViagCacheRecordContent aRecord )    

    {

    NWLOGSTRING4( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler::Insert() Begin,\

         aCacheId = %d, aRecord.iLac = %d, aRecord.iCellId = %d",

         aCacheId, aRecord.iLac, aRecord.iCellId );

    if( InitialisingStatus() != ECBSHZCacheReader_Ready )

        {

        NWLOGSTRING( KNWOBJECT, 

            "NW: CNWNetworkHZCbCacheHandler::Insert(),\

             CBSHZCacheReader not ready!" );

        return KErrNotReady;

        }

    TInt retVal = KErrNotFound;

   // Add HomeZone cells in SIM

    switch( aCacheId )

        {

        case EHZ_HomeZoneCache1:

        case EHZ_HomeZoneCache2:

        case EHZ_HomeZoneCache3:

            {

            retVal = DoInsertInHomeZoneCache( aRecord, aCacheId );

            }

            break;

        case EHZ_CityZoneCache:

            {

            retVal = DoInsertInCityZoneCache( aRecord );

            }

            break;

         default:

            // This should not ever happen.

            ASSERT( EFalse );

            break;

        }

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler::Insert() End,\

         retVal = %d ", retVal );

    return retVal;           

    }

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

// CNWNetworkHZCbCacheHandler::Remove

// 

// (other items were commented in a header).

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

//

TInt CNWNetworkHZCbCacheHandler::Remove( const THomeZoneCacheId aCacheId, 

    const TInt aIndex )

    {

    NWLOGSTRING3( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler::Remove() Begin,\

         aCacheId = %d, aIndex = %d ", aCacheId, aIndex );

    if( InitialisingStatus() != ECBSHZCacheReader_Ready )

        {

        NWLOGSTRING( KNWOBJECT, 

            "NW: CNWNetworkHZCbCacheHandler::Remove(),\

             CBSHZCacheReader not ready!" );

        return KErrNotReady;

        }

   // TBD remove aIndex handling

    TInt retVal = KErrNotFound;

    RArray<RMmCustomAPI::TViagCacheRecordContent> * cache;

    cache = Cache( aCacheId );

    ASSERT( cache );

    if( cache )

        {

        TInt itemCount = cache->Count();

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkHZCbCacheHandler::Remove(),\

            cache->Count = %d ", itemCount );

        if( aIndex < itemCount )

            {

            switch( aCacheId )

                {

                case EHZ_HomeZoneCache1:

                case EHZ_HomeZoneCache2:

                case EHZ_HomeZoneCache3:

                    {

                    ASSERT( itemCount <= KMaxNumberOfItemsInHomeZoneCache );

                    RMmCustomAPI::TViagCacheRecordContent nullEntry;

                    nullEntry.iLac = 0xffff;

                    nullEntry.iCellId = 0xffff;

                    // Remove from SIM cache first

                    RMmCustomAPI::TViagCacheRecordId sim_cache;

                    sim_cache.iCacheId = aCacheId;

                    sim_cache.iRecordId = aIndex;

                    retVal = iCustomAPI.WriteViagHomeZoneCache( sim_cache,

                        nullEntry );

                    NWLOGSTRING2( KNWOBJECT, 

                        "NW: CNWNetworkHZCbCacheHandler::Remove(),\

                        WriteViagHomeZoneCache() error code: %d ", retVal );

                    // ... and then from local cache

                    if( retVal == KErrNone )

                        {

                        cache->Remove( aIndex );

                        cache->Insert( nullEntry, aIndex );

                        cache->Compress();

                        }

                    retVal = KErrNone;

                    }

                    break;

                case EHZ_CityZoneCache:

                    {

                    ASSERT( itemCount <= KMaxNumberOfItemsInCityZoneCache );

                    cache->Remove( aIndex );

                    cache->Compress();

                    retVal = KErrNone;

                    break;

                    }

                default:

                    // This should never happen.

                    ASSERT( EFalse );

                    break;

                }

            }

        }

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler::Remove() End,\

        retVal = %d ", retVal );

    return retVal;

    }

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

// CNWNetworkHZCbCacheHandler::ReadCacheFromSIM

// 

// (other items were commented in a header).

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

//

TInt CNWNetworkHZCbCacheHandler::ReadCacheFromSIM( 

    RArray<RMmCustomAPI::TViagCacheRecordContent> & aDestArray,

    const THomeZoneCacheId aCacheId, const TInt aNumberofItems )

    {

    NWLOGSTRING3( KNWINT, 

        "NW: CNWNetworkHZCbCacheHandler: ReadCacheFromSIM() Begin,\

        aCacheId = %d, aNumberofItems = %d ", aCacheId, aNumberofItems );

    ASSERT( aCacheId >= EHZ_HomeZoneCache1 && aCacheId <= EHZ_HomeZoneCache3 );

    ASSERT( aNumberofItems <= KMaxNumberOfItemsInHomeZoneCache );

    TInt retVal = KErrNone;

    RMmCustomAPI::TViagCacheRecordId cache;

    cache.iCacheId = aCacheId;

    aDestArray.Reset();

    for( TInt index = 0; index < aNumberofItems; index++ )

        {

         //Check all Record Ids (twenty of them)

        RMmCustomAPI::TViagCacheRecordContent record;

        cache.iRecordId = index;

        retVal = iCustomAPI.ReadViagHomeZoneCache( cache, record );

        if( retVal )

            {

            NWLOGSTRING2( KNWERROR, "NW: CNWNetworkHZCbCacheHandler::\

                ReadViagHomeZoneCache() error code: %d ", retVal );

            // Error happened. Stop here.

            break;

            }

        aDestArray.Insert( record, index );

        }

    NWLOGSTRING2( KNWINT, 

        "NW: CNWNetworkHZCbCacheHandler: ReadCacheFromSIM() End,\

        retVal = %d ", retVal );

    return retVal;

    }

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

// CNWNetworkHZCbCacheHandler::Cache

// 

// (other items were commented in a header).

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

//

RArray<RMmCustomAPI::TViagCacheRecordContent> * CNWNetworkHZCbCacheHandler::

    Cache( const THomeZoneCacheId aCacheId )

    {

    NWLOGSTRING2( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler: Cache() Begin,\

        aCacheId = %d ", aCacheId );

    RArray<RMmCustomAPI::TViagCacheRecordContent> * retVal;

    switch( aCacheId )

        {

        case EHZ_HomeZoneCache1:

          retVal = &iSimCache1;

          break;

        case EHZ_HomeZoneCache2:

          retVal = &iSimCache2;

          break;

        case EHZ_HomeZoneCache3:

          retVal = &iSimCache3;

          break;

        case EHZ_CityZoneCache:

          retVal = &iDynCache;

          break;

        default:

          retVal = NULL;

          break;        

        }

    NWLOGSTRING( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler: Cache() End" );

    return retVal;

    }

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

// CNWNetworkHZCbCacheHandler::DoInsertInHomeZoneCache

// 

// (other items were commented in a header).

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

//

TInt CNWNetworkHZCbCacheHandler::DoInsertInHomeZoneCache( 

    const RMmCustomAPI::TViagCacheRecordContent aRecord,

    const THomeZoneCacheId aCacheId )

    {

    NWLOGSTRING4( KNWOBJECT, 

        "NW: CNWNetworkHZCbCacheHandler: DoInsertInHomeZoneCache() Begin,\

        aCacheId = %d, aRecord.iLac = %d, aRecord.iCellId = %d ",

        aCacheId, aRecord.iLac, aRecord.iCellId );

    TInt retVal = KErrNotFound;

    RArray<RMmCustomAPI::TViagCacheRecordContent> * cache;

    cache = Cache( aCacheId );

    ASSERT( cache );

    if( cache )

        {

        TInt pos = KErrNotFound;

        TInt itemCount = cache->Count();

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkHZCbCacheHandler: DoInsertInHomeZoneCache(),\

            itemCount = %d ", itemCount );

        ASSERT( itemCount <= KMaxNumberOfItemsInHomeZoneCache );

        TBool replace = EFalse;

        // Check if there free slots available.

        pos = FindNullEntry( aCacheId );

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkHZCbCacheHandler: DoInsertInHomeZoneCache(),\

            Trying finding free slots: %d", pos );

        if( pos == KErrNotFound )

            {

            if( itemCount < KMaxNumberOfItemsInHomeZoneCache )

                {

                // Append at the end of cache

                pos = itemCount;

                }

            else

                {

                // We have replace some randomly selected item

                TUint32 random = Math::Random();

                pos = random % KMaxNumberOfItemsInHomeZoneCache;

                replace = ETrue;

                }

            }

         else

            {

            // Replace the founded nullEntry

            replace = ETrue;

            }

        NWLOGSTRING2( KNWOBJECT, 

            "NW: CNWNetworkHZCbCacheHandler: DoInsertInHomeZoneCache(),\

            pos = %d", pos );

         ASSERT( pos >= 0 && pos < KMaxNumberOfItemsInHomeZoneCache );

         if( pos >= 0 && pos < KMaxNumberOfItemsInHomeZoneCache )

            {

            // Update SIM cache

            RMmCustomAPI::TViagCacheRecordId sim_cache;

            sim_cache.iCacheId = aCacheId;

            sim_cache.iRecordId = pos;

            TInt custError = iCustomAPI.WriteViagHomeZoneCache( 

                sim_cache, aRecord );

            NWLOGSTRING2( KNWOBJECT, 

                 "NW: CNWNetworkHZCbCacheHandler: DoInsertInHomeZoneCache(),\

                 WriteViagHomeZoneCache error code: %d", custError );

            if( custError )

                {

                // Failed

                pos = KErrNotFound;

                }

            else

                {

                // Update local cache

                if( replace )

                    {

                    cache->Remove( pos );

                    cache->Compress();

                    }

                cache->Insert( aRecord, pos );

                }

            }

        else

            {