/*
* Copyright (c) 2007 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:  PSM Settings handler
*
*/


#include <ecom/ecom.h>
#include <centralrepository.h>
#include "psmsettingshandler.h"
#include "psmconfigstorage.h"
#include "psmbackupstorage.h"
#include "psmcenrepstorage.h"
#include "psmtrace.h"

// -----------------------------------------------------------------------------
// CloseHandler
// closes the storage handler
// -----------------------------------------------------------------------------
//
void CleanupStorage(TAny* aPtr)
    {
    CPsmStorage* self = static_cast<CPsmStorage*> (aPtr);
    //Ignore the Trap as Cleanup can't leave.
    TRAP_IGNORE(self->CloseStorageL());
    }

// -----------------------------------------------------------------------------
// CloseHandler
// closes the backup storage handler
// -----------------------------------------------------------------------------
//
void CleanupBackupStorage(TAny* aPtr)
    {
    CPsmBackupStorage* self = static_cast<CPsmBackupStorage*> (aPtr);
    //Ignore the Trap as Cleanup can't leave.
    TRAP_IGNORE(self->CloseStorageL());
    }
	
// CPsmSettingsHandler::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPsmSettingsHandler* CPsmSettingsHandler::NewL( const TPsmsrvMode aMode )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::NewL()" ) ) );

    CPsmSettingsHandler* self = CPsmSettingsHandler::NewLC( aMode );
    CleanupStack::Pop( self );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::NewL - return 0x%x" ), self ) );

    return self;
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CPsmSettingsHandler* CPsmSettingsHandler::NewLC( const TPsmsrvMode aMode )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::NewLC()" ) ) );

    CPsmSettingsHandler* self = new( ELeave ) CPsmSettingsHandler( aMode );
    CleanupStack::PushL( self );
    self->ConstructL();

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::NewLC - return 0x%x" ), self ) );

    return self;
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::CPsmSettingsHandler
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CPsmSettingsHandler::CPsmSettingsHandler( const TPsmsrvMode aMode ) :
    iMode( aMode ),
    iCurrentMode( aMode )
    {
    // Nothing to do
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::ConstructL()
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ConstructL()" ) ) );
    User::LeaveIfError( iFileSession.Connect() );
    // Create storage files
    iConfigStorage = CPsmConfigStorage::NewL( iMode, iFileSession );
    iBackupStorage = CPsmBackupStorage::NewL( iMode, iFileSession );
    iCenRepStorage = CPsmCenRepStorage::NewL( iMode, iFileSession );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ConstructL - return" ) ) );
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CPsmSettingsHandler::~CPsmSettingsHandler()
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::~CPsmSettingsHandler()" ) ) );

    delete iConfigStorage;
    delete iBackupStorage;
    delete iCenRepStorage;

    iFileSession.Close();

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::~CPsmSettingsHandler - return") ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::BackupAndGetSettingsL
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::BackupAndGetSettingsL( 
    RConfigInfoArray& aPsmConfigArray, TUint32 aRepository )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::BackupAndGetSettingsL()" ) ) );
    //Close config handle in case of any error
    CleanupStack::PushL(TCleanupItem(CleanupStorage, iConfigStorage));
    // Change settings from normal config storage
    iConfigStorage->InitStorageL( aRepository );
    ChangeSettingsL( aPsmConfigArray, aRepository, *iConfigStorage );
    iConfigStorage->CloseStorageL();
    CleanupStack::Pop(iConfigStorage);
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::BackupAndGetSettingsL() - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::GetCurrentSettingsL
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::GetSettingsL( 
    RConfigInfoArray& aPsmConfigArray, TUint32 aRepository )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::GetCurrentSettingsL()" ) ) );
    // Get current settings from normal config storage

    // Use own storage in case PSM mode is ongoing by some plugin
    if ( EPsmsrvModeNormal == iMode )
        {
        // Normal mode, get current settings from backup storage
        CPsmBackupStorage* backupStorage = CPsmBackupStorage::NewLC( iMode, iFileSession );
        backupStorage->InitStorageL( aRepository );
        backupStorage->GetConfigurationL( aPsmConfigArray );
        CleanupStack::PopAndDestroy( backupStorage );
        }
    else
        {
        // PSM mode, get current settings from config storage
        CPsmConfigStorage* configStorage = CPsmConfigStorage::NewLC( iMode, iFileSession );
        configStorage->InitStorageL( aRepository );
        configStorage->GetConfigurationL( aPsmConfigArray );
        CleanupStack::PopAndDestroy( configStorage );
        }

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::GetCurrentSettingsL() - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::BackupSettingsL
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::BackupSettingsL( 
    const RConfigInfoArray& aPsmConfigArray, const TUint32 aRepository )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::BackupSettingsL()" ) ) );

    if ( EPsmsrvModeNormal == iMode )
        {
        ERROR_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::BackupSettingsL() - Not allowed in normal mode - LEAVE" ) ) );
        // Backup is not allowed in normal mode
        User::Leave( KErrWrite );
        }

    // Use own storage in case PSM mode is ongoing by some plugin
    CPsmBackupStorage* backupStorage = CPsmBackupStorage::NewLC( iMode, iFileSession );
    backupStorage->InitStorageL( aRepository );
    backupStorage->BackupConfigurationL( aPsmConfigArray );
    backupStorage->CloseStorageL();
    CleanupStack::PopAndDestroy( backupStorage );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::BackupSettingsL() - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::Compare
// -----------------------------------------------------------------------------
//
TBool CPsmSettingsHandler::Compare( 
    const TPsmsrvConfigInfo& aSource, 
    const TPsmsrvConfigInfo& aTarget ) const
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::Compare()" ) ) );
    TBool returnValue( EFalse );
    if ( ( aSource.iConfigId == aTarget.iConfigId ) &&
         ( aSource.iConfigType == aTarget.iConfigType ) )
        {
        // Check type and copare values
        switch ( aSource.iConfigType )
            {
            case EConfigTypeInt:
                returnValue = ( aSource.iIntValue == aTarget.iIntValue );
                break;
            case EConfigTypeReal:
                returnValue = ( aSource.iRealValue == aTarget.iRealValue );
                break;
            case EConfigTypeBuf:
                returnValue = ( aSource.iDesValue == aTarget.iDesValue );
                break;
            default:
                returnValue = EFalse;
            }
        }
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::Compare() - return" ) ) );
    return returnValue;
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::ChangeSettingsL
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::ChangeSettingsL( 
    RConfigInfoArray& aPsmConfigArray, 
    TUint32 aRepository,
    CPsmStorage& aConfigStorage )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeSettingsL()" ) ) );

    TInt err( KErrNone );
    // First, get current settings
    RConfigInfoArray currentSettings;
    CleanupClosePushL( currentSettings );
    
    //Close backup handler in case of any error
    CleanupStack::PushL(TCleanupItem(CleanupBackupStorage, iBackupStorage));
    iBackupStorage->InitStorageL( aRepository );
    iBackupStorage->ListCurrentSettingSetL( currentSettings );

    // Check currently owned settings and compare those to the new ones
    RConfigInfoArray settingsToBackUp;
    CleanupClosePushL( settingsToBackUp );

    for ( TInt i = 0; aPsmConfigArray.Count() != i; i++ )
        {
        TBool found = EFalse;
        for ( TInt a = 0; !found && currentSettings.Count() != a; a++ )
            {
            found = Compare( currentSettings[ a ], aPsmConfigArray[ i ] );
            }

        if ( !found )
            {
            // Add new settings to backup
            settingsToBackUp.AppendL( aPsmConfigArray[ i ] );
            currentSettings.AppendL( aPsmConfigArray[ i ] );
            }
        }

    // Get new values from config
    if ( EPsmsrvModeNormal == iMode )
        {
        // Restore to normal mode, initialize backup storage
        iBackupStorage->GetConfigurationL( aPsmConfigArray );
        }
    else
        {
        // Moving from power save mode to another power save mode
        iBackupStorage->BackupConfigurationL( settingsToBackUp );
        aConfigStorage.GetConfigurationL( aPsmConfigArray );
        }

    if( aPsmConfigArray.Count() == 0 )
        {
        err = KErrNotFound;
        }

    // Check for missing values and get those from backup
    RConfigInfoArray settingsFromBackUp;
    CleanupClosePushL( settingsFromBackUp );

    for ( TInt i = 0; currentSettings.Count() != i; ++i )
        {
        TPsmsrvConfigInfo& currentInfo = currentSettings[ i ];
        TBool found = EFalse;
        TPsmsrvConfigInfo newInfo;
        for ( TInt index = 0; !found && aPsmConfigArray.Count() != index; index++ )
            {
            newInfo = aPsmConfigArray[ index ];
            found = ( newInfo.iConfigId == currentInfo.iConfigId );
            }

        // Check was setting found
        if ( !found )
            {
            // not found, get setting from backup
            settingsFromBackUp.AppendL( currentInfo );
            currentSettings.Remove( i );
            --i;
            }
        else
            {
            // Setting found, update values
            currentInfo = newInfo;
            }
        }

    // Finally, get remaining settings from backup
    if ( settingsFromBackUp.Count() )
        {
        iBackupStorage->GetConfigurationL( settingsFromBackUp );
        }

    iBackupStorage->UpdateCurrentSettingSetL( currentSettings );

    // Close backup storage
    iBackupStorage->CloseStorageL();

    // add settings from backup to settings
    for ( TInt i = 0; i < settingsFromBackUp.Count(); i++ )
        {
        //Ignore the error returned by Append  
        aPsmConfigArray.Append( settingsFromBackUp[ i ]);
        }

    // Cleanup config arrays
    CleanupStack::PopAndDestroy( &settingsFromBackUp );
    CleanupStack::PopAndDestroy( &settingsToBackUp );
    CleanupStack::Pop( iBackupStorage );
    CleanupStack::PopAndDestroy( &currentSettings );

    User::LeaveIfError( err );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeSettingsL() - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::ChangeCenRepSettingsL
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::ChangeCenRepSettingsL()
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeCenRepSettingsL()" ) ) );

    // First resolve the CenRep config files
    RPassiveConfigList passiveConfigs;
    CleanupClosePushL( passiveConfigs );

    iCenRepStorage->ListPassiveConfigs( passiveConfigs );

    const TInt configCount( passiveConfigs.Count() );

    // Loop found passive configs
    for ( TInt i = 0; i < configCount; i++ )
        {
        RConfigInfoArray psmConfigArray;
        CleanupClosePushL( psmConfigArray );

        const TUint32 repository = passiveConfigs[i];
        //Close Cenrep handler in case of any error
        CleanupStack::PushL(TCleanupItem(CleanupStorage, iCenRepStorage));
        iCenRepStorage->InitStorageL( repository );

        if ( EPsmsrvModeNormal == iMode )
            {
            //Close Cenrep handler in case of any error
    		CleanupStack::PushL(TCleanupItem(CleanupBackupStorage, iBackupStorage));	
            // Moving to normal mode, get passive config set from baskup storage
            iBackupStorage->InitStorageL( repository );
            iBackupStorage->ListPassiveConfigSetL( psmConfigArray );
            iBackupStorage->CloseStorageL();
            CleanupStack::Pop( iBackupStorage );
            }
        else
            {
            // Get configuration set
            iCenRepStorage->ListPassiveConfigSetL( psmConfigArray );
            }

        // Change values
        ChangeCenRepSettingsL( psmConfigArray, repository );

        // close storage
        iCenRepStorage->CloseStorageL();
        CleanupStack::Pop( iCenRepStorage );
        CleanupStack::PopAndDestroy( &psmConfigArray );
        }

    CleanupStack::PopAndDestroy( &passiveConfigs );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeCenRepSettingsL() - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::ChangeCenRepSettingsL
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::ChangeCenRepSettingsL( 
    RConfigInfoArray& aPsmConfigArray, TUint32 aRepository )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeCenRepSettingsL()" ) ) );

    // First read current values from CenRep
    TUid cenRepUid = { aRepository };
    CRepository* cenrep = CRepository::NewLC( cenRepUid );

    TInt setCount( aPsmConfigArray.Count() );

    for ( TInt i = 0; i < setCount; i++ )
        {
        TPsmsrvConfigInfo& info = aPsmConfigArray[i];
        switch ( info.iConfigType )
            {
            case EConfigTypeInt:
                {
                User::LeaveIfError( cenrep->Get( info.iConfigId, info.iIntValue ) );
                break;
                }
            case EConfigTypeReal:
                {
                User::LeaveIfError( cenrep->Get( info.iConfigId, info.iRealValue ) );
                break;
                }
            case EConfigTypeBuf:
                {
                User::LeaveIfError( cenrep->Get( info.iConfigId, info.iDesValue ) );
                break;
                }
            default:
                {
                COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeCenRepSettingsL() - Unknown type LEAVE" ) ) );
                User::Leave( KErrUnknown );
                }
            }
        }

    // Get new values from storage
    TRAP_IGNORE( ChangeSettingsL( aPsmConfigArray, aRepository, *iCenRepStorage ) );

    // Get new count
    setCount = aPsmConfigArray.Count();

    // Write new values to CenRep
    for ( TInt j = 0; j < setCount; j++ )
        {
        TPsmsrvConfigInfo& info = aPsmConfigArray[j];
        switch ( info.iConfigType )
            {
            case EConfigTypeInt:
                {
                User::LeaveIfError( cenrep->Set( info.iConfigId, info.iIntValue ) );
                break;
                }
            case EConfigTypeReal:
                {
                User::LeaveIfError( cenrep->Set( info.iConfigId, info.iRealValue ) );
                break;
                }
            case EConfigTypeBuf:
                {
                User::LeaveIfError( cenrep->Set( info.iConfigId, info.iDesValue ) );
                break;
                }
            default:
                {
                COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeCenRepSettingsL() - Unknown type LEAVE" ) ) );
                User::Leave( KErrUnknown );
                }
            }
        }

    // Cleanup CenRep
    CleanupStack::PopAndDestroy( cenrep );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::ChangeCenRepSettingsL() - return" ) ) );
    }

// -----------------------------------------------------------------------------
// CPsmSettingsHandler::SetMode
// -----------------------------------------------------------------------------
//
void CPsmSettingsHandler::SetMode( TPsmsrvMode aMode )
    {
    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::SetMode()" ) ) );

    // Store previous mode
    iCurrentMode = iMode;

    // Store mode
    iMode = aMode;

    // Update mode to storage handlers also
    iBackupStorage->SetMode( aMode );
    iConfigStorage->SetMode( aMode );
    iCenRepStorage->SetMode( aMode );

    COMPONENT_TRACE( ( _L( "PSM Server - CPsmSettingsHandler::SetMode() - return" ) ) );
    }

// End of file