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


// System includes
#include <centralrepository.h>
#include <s32mem.h>

// User includes
#include "cenrephandler.h"
#include "presetcrkeys.h"
#include <preset.h>
#include "cenrepbookkeeping.h"
#include "trace.h"


class TChannelIndexList
    {
public:
    TInt iChannelIndex;
    TInt iNameIndex;
    TInt iFrequencyIndex;
    TInt iUrlIndex;
    TInt iRestOfParametersIndex;
    };

// ============= STATIC FUNCTIONS ==============

static TInt CalculateChannelIndexes( const TInt aChannelIndex,  TChannelIndexList& aChannelIndexList)
    {
    FUNC_LOG;
    TInt err( KErrNone );
    if ( ( KMaxNumberOfPresetStations <= aChannelIndex ) ||
            ( 0 >  aChannelIndex ) )
        {
        err = KErrArgument;
        }
    else
        {
        aChannelIndexList.iChannelIndex = 
         KRadioPresetChannel1 + ( KNbrOfParametersPerChannelSequence * aChannelIndex );
        aChannelIndexList.iNameIndex =
            aChannelIndexList.iChannelIndex + KChannelNameOffset;        
        aChannelIndexList.iFrequencyIndex =
            aChannelIndexList.iChannelIndex + KFrequencyOffset;        
        aChannelIndexList.iUrlIndex =
            aChannelIndexList.iChannelIndex + KUrlOffset;        
        aChannelIndexList.iRestOfParametersIndex =
            aChannelIndexList.iChannelIndex + KRestOfParametersOffset;
        }
    return err;
    }

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

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CCenrepHandler::CCenrepHandler()
    {
    FUNC_LOG;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CCenrepHandler::ConstructL()
    {
    FUNC_LOG;
    iCentralRepository = CRepository::NewL( KCRUidPresetUtility );
    iBookKeeping = new (ELeave) CCenrepBookKeeping;
    ReadBookKeepingL();
    }

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

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CCenrepHandler::~CCenrepHandler()
    {
    FUNC_LOG;
    delete iCentralRepository;
    delete iBookKeeping;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CCenrepHandler::MaxPresetCount() const
    {
    FUNC_LOG;
    return KMaxNumberOfPresetStations;
    }

// -----------------------------------------------------------------------------
// Get the current number of presets
// -----------------------------------------------------------------------------
//
TInt CCenrepHandler::PresetCount() const
    {
    FUNC_LOG;
    return iBookKeeping->PresetCount();
    }

// -----------------------------------------------------------------------------
// Gets the first preset
// -----------------------------------------------------------------------------
//
TInt CCenrepHandler::FirstPreset() const
    {
    FUNC_LOG;
    return iBookKeeping->FirstIndex();
    }

// -----------------------------------------------------------------------------
// Get the next preset index that has been set, given the current index
// -----------------------------------------------------------------------------
//
TInt CCenrepHandler::NextPreset( TInt aFromIndex ) const
    {
    FUNC_LOG;
    return iBookKeeping->NextIndex( aFromIndex );
    }

// -----------------------------------------------------------------------------
// Delete the current preset
// -----------------------------------------------------------------------------
//
TInt CCenrepHandler::DeletePreset( TInt aIndex )
    {
    FUNC_LOG;
    TInt err( KErrNone );
    if ( -1 == aIndex )
        {
        // Delete all
        TChannelIndexList channelIndexList;
        for (  TInt j( FirstPreset() ); 0 <= j;  j = FirstPreset() )
            {
            INFO_1("Deleting index: %i", j );
            if ( KErrNone == CalculateChannelIndexes( j, channelIndexList ) )
                {                
                iCentralRepository->Delete( channelIndexList.iNameIndex );    
                iCentralRepository->Delete( channelIndexList.iFrequencyIndex );   
                iCentralRepository->Delete( channelIndexList.iUrlIndex );
                iCentralRepository->Delete( channelIndexList.iRestOfParametersIndex );
                iBookKeeping->RemoveIndex( j );        
                }
            }
        }
    else
        {
        TChannelIndexList channelIndexList;
        err = CalculateChannelIndexes( aIndex, channelIndexList );
        if ( KErrNone == err )
            {
            iCentralRepository->Delete( channelIndexList.iNameIndex );    
            iCentralRepository->Delete( channelIndexList.iFrequencyIndex );   
            iCentralRepository->Delete( channelIndexList.iUrlIndex );
            iCentralRepository->Delete( channelIndexList.iRestOfParametersIndex );
            iBookKeeping->RemoveIndex( aIndex );        
            }
        }
    if ( KErrNone == err )
        {
        SaveBookKeeping();
        }
    return err;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CCenrepHandler::SavePresetL( const TPreset& aPreset, TInt aIndex )
    {
    FUNC_LOG;
    if ( 0 > aIndex )
        {
        aIndex = iBookKeeping->FindUnusedIndex();
        }
    if ( 0 > aIndex )
        {
        User::Leave( KErrDiskFull ); // Not really a good code for this
        }
    TChannelIndexList channelIndexList;
    User::LeaveIfError( CalculateChannelIndexes( aIndex, channelIndexList) );

    // First save name to its own key in the key sequence.
    User::LeaveIfError( iCentralRepository->Set( channelIndexList.iNameIndex, aPreset.Name() ) );

    // Frequency  to its own key in the key sequence.
    User::LeaveIfError( iCentralRepository->Set( channelIndexList.iFrequencyIndex, (TInt)aPreset.Frequency() ) );

    // Url to its own key in the key sequence.
    User::LeaveIfError( iCentralRepository->Set( channelIndexList.iUrlIndex, aPreset.Url() ) );

    // Then externalize the rest of the data to a common key.
    TInt err( KErrNone );
    TInt length( aPreset.MyExternalizedDataSize() );
    TUint i ( 1 );
    INFO_1( "aPreset.MyExternalizedDataSize()=%i", length );
    for ( TBool cont = ( 0 < length ) ? ETrue : EFalse; (cont); cont = ( KErrOverflow == err ) ?  ETrue : EFalse ) 
        {
        HBufC8* buf = HBufC8::NewLC( i * length  );
        TPtr8 bufPtr = buf->Des();
        RDesWriteStream outStream( bufPtr );
        CleanupClosePushL( outStream );
        TRAP( err, aPreset.ExternalizeL( outStream ) );
        if ( KErrNone == err )
            {
            outStream.CommitL();
            User::LeaveIfError( iCentralRepository->Set( channelIndexList.iRestOfParametersIndex, *buf ) );
            }
        else
            {
            INFO_2( "SavePresetL bigger buffer (%i) needed than required by aPreset.MyExternalizedDataSize()=%i", i*length, aPreset.MyExternalizedDataSize() );
            ++i;
            }
        CleanupStack::PopAndDestroy( &outStream );
        CleanupStack::PopAndDestroy( buf );
        }
    User::LeaveIfError( err );

    iBookKeeping->AddIndex( aIndex );
    SaveBookKeeping();
    return aIndex;
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CCenrepHandler::ReadPresetL( TInt aIndex, TPreset& aPreset )
    {
    FUNC_LOG;

    // Read name from its own key in the key sequence
    TChannelIndexList channelIndexList;
    User::LeaveIfError( CalculateChannelIndexes( aIndex, channelIndexList) );
    TPresetName tempChannelName;
    User::LeaveIfError( iCentralRepository->Get(channelIndexList.iNameIndex, tempChannelName ) );
    aPreset.SetName( tempChannelName );

    // Read frequency from its own key in the key sequence
    TInt frequency( 0 );
    User::LeaveIfError( iCentralRepository->Get( channelIndexList.iFrequencyIndex, frequency ) );
    aPreset.SetFrequency( frequency );

    // Read url from its own key in the key sequence
    TRadioUrl tempUrlName;
    TInt err = iCentralRepository->Get( channelIndexList.iUrlIndex, tempUrlName );
    if ( KErrNone == err )
        {        
        aPreset.SetUrl( tempUrlName );
        }
    else if ( KErrNotFound == err )
        {
        // This is an optional parameter.
        }
    else
        {
        User::Leave( err );
        }
                      

    // Then use the below code to internalize rest of parameters from the common key
    TInt actualLength( aPreset.MyExternalizedDataSize() );
    INFO_1( "ReadPresetL aPreset.MyExternalizedDataSize()=%i", actualLength );
    for ( TBool cont = ( 0 < actualLength ) ? ETrue : EFalse; (cont); cont = ( KErrOverflow == err ) ?  ETrue : EFalse ) 
        {
        HBufC8* buf = HBufC8::NewLC( actualLength );
        TPtr8 bufPtr = buf->Des();
        err = iCentralRepository->Get( channelIndexList.iRestOfParametersIndex, bufPtr, actualLength );
        if ( ( KErrNone == err ) && ( 0 < buf->Length() ) )
            {
            RDesReadStream inStream;
            inStream.Open( *buf );
            CleanupClosePushL( inStream );       
            aPreset.InternalizeL( inStream );        
            CleanupStack::PopAndDestroy( &inStream );
            }
        else if ( KErrNotFound == err )
            {
            // This is not filled by CT tool even though name, frequency and URL might be 
            // filled for the current channel. Don't leave.
            INFO_1( "ReadPresetL KErrNotFound, key=%i", channelIndexList.iRestOfParametersIndex );
            }
        else if ( KErrOverflow == err )
            {
            INFO_2( "ReadPresetL KErrOverflow, buf->Length()=%i actualLength=%i", buf->Length(), actualLength );
            // Trying again with actual with buffer that can store the whole key
            }
        else
            {
            User::Leave( err );
            }
        CleanupStack::PopAndDestroy(buf);
        } // for (;;) 
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CCenrepHandler::ReadBookKeepingL()
    {
    FUNC_LOG;
    TPtr8 bufPtr = iBookKeeping->BookKeepingData();

    TInt err( iCentralRepository->Get( KRadioBookKeepingLocation, bufPtr ) );
    if ( KErrNotFound == err )
        {
        // Bookkeeping does not exist. Search possible preconfigured channels.
        ReadPreDefinedPresetsL();
        err = KErrNone;
        }
    User::LeaveIfError( err );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CCenrepHandler::SaveBookKeeping()
    {
    FUNC_LOG;
    TInt err( iCentralRepository->Set( KRadioBookKeepingLocation, iBookKeeping->BookKeepingData() ) );
    if ( KErrNone !=  err )
        {
        INFO_1("Saving of BookKeeping failed with error: %i ", err)
        // It is better to destroy data that is out of sync
        iCentralRepository->Delete( KRadioBookKeepingLocation );
        // Go on with local bookkeeping data
        }
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CCenrepHandler::ReadPreDefinedPresetsL()
    {
    FUNC_LOG;
    TInt frequency ( 0 );
    TInt err( KErrNone );
    TChannelIndexList channelIndexList;
    iBookKeeping->Clear();
    for(TInt index = 0; index < KMaxNumberOfPresetStations; index++)
        {
        User::LeaveIfError( CalculateChannelIndexes( index, channelIndexList) );
        err = iCentralRepository->Get( channelIndexList.iFrequencyIndex, frequency );
        if ( KErrNone ==  err )
            {
            iBookKeeping->AddIndex( index );
            }
        } 
    SaveBookKeeping();
    }