/*
* Copyright (c) 2008 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:  factory settings for content harvester
 *
*/


// INCLUDE FILES
#include <xcfwtree.h>
#include <xcfwengine.h>
#include <gecoobjectbase.h>
#include <gecodefaultobject.h>
#include <e32const.h>
#include <liwservicehandler.h>

#include "chfactorysettingsparser.h"
#include "chfactorysettingsglobals.h"
#include "chfactsetutils.h"
#include "cpdebug.h"

_LIT8( KType, "type" );
_LIT8( KItem, "item" );
_LIT8( KData, "data" );
_LIT8( KAdd, "Add" );
_LIT8( KDelete, "Delete" );
_LIT( KCpData, "cp_data" );
_LIT( KPublisher, "publisher" );

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

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::CCHFactorySettingsParser
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCHFactorySettingsParser::CCHFactorySettingsParser()
    {
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::ConstructL( MLiwInterface* aInterface )
    {
    iActiveScheduler = new ( ELeave ) CActiveSchedulerWait();

    iContentEngine = CXCFWEngine::NewL( this );
    iCPSInterface = aInterface;
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCHFactorySettingsParser* CCHFactorySettingsParser::NewL(
    MLiwInterface* aInterface )
    {
    CCHFactorySettingsParser* self = NewLC( aInterface );
    CleanupStack::Pop( self );
    return self;
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::NewLC
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCHFactorySettingsParser* CCHFactorySettingsParser::NewLC(
    MLiwInterface* aInterface )
    {
    CCHFactorySettingsParser* self = new( ELeave ) CCHFactorySettingsParser();
    CleanupStack::PushL( self );
    self->ConstructL( aInterface );
    return self;
    }

// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
//
CCHFactorySettingsParser::~CCHFactorySettingsParser()
    {
    delete iContentTree;
    delete iContentEngine;
    delete iActiveScheduler;
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::RestoreL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
TInt CCHFactorySettingsParser::RestoreL( const TDesC& aStr, TBool aUnInstall )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::RestoreL" ));
    TInt err;
    iContentTree = CXCFWTree::NewL( );

    iContentEngine->LoadL( *iContentTree, aStr );

    iActiveScheduler->Start( );

    if ( iCompletionStatus == MADatFactorySettingsObserver::ECompleted )
        {
        //this trap ensures stoping the ActiveSheduler
        //in case a leave occurs when updating data
        TRAP( err, HandleEntriesL( aUnInstall ) );
        }

    delete iContentTree;
    iContentTree = NULL;
    return err;
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::HandleCompletionL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::HandleCompletionL(
    TADatFactorySettingsStatus aStatus )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::HandleCompletionL" ));
    iCompletionStatus = aStatus;
    iActiveScheduler->AsyncStop( );
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::HandleEngineEventL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::HandleEngineEventL( TXCFWEngineEvent aEvent )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::HandleEngineEventL" ));
    // handle completion
    if ( aEvent == EEvtParsingComplete )
        {
        TADatFactorySettingsStatus status =
                MADatFactorySettingsObserver::ECompleted;
        HandleCompletionL( status );
        }

    // else => ignore
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::HandleEngineErrorL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::HandleEngineErrorL( TInt /*aErrorCode*/)
    {
    HandleCompletionL( MADatFactorySettingsObserver::EFailed );
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::HandleEntriesL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::HandleEntriesL( TBool aUnInstall )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::HandleEntriesL" ));
    MXCFWNode* root = iContentTree->Root( );
    // get children 
    RNodeArray entries;
    CleanupClosePushL( entries );
    iContentTree->GetChildNodesL( root, entries );
    for ( TInt i = 0; i < entries.Count( ); i++ )
        {
        TPtrC typeIdentifier(entries[i]->Data()->TypeIdentifier( ));

        if ( ( typeIdentifier == KMainDataItem )
            || ( typeIdentifier == KMainPublisherItem ) )
            {
            CLiwGenericParamList* inparam = CLiwGenericParamList::NewLC( );
            CLiwGenericParamList* outparam = CLiwGenericParamList::NewLC( );
            CLiwDefaultMap* map = CLiwDefaultMap::NewLC( );
            if ( typeIdentifier == KMainDataItem )
                {
                TLiwGenericParam item_type( KType, TLiwVariant( KCpData ));
                inparam->AppendL( item_type );
                }
            else
                {
                TLiwGenericParam item_type( KType, TLiwVariant( KPublisher ));
                inparam->AppendL( item_type );
                }

            if ( aUnInstall )
                {
                RemoveItemL( entries[i], map );
                TLiwGenericParam item( KData, TLiwVariant( map ));
                inparam->AppendL( item );
                iCPSInterface->ExecuteCmdL( KDelete, *inparam, *outparam );
                }
            else
                {
                AddItemL( entries[i], map, EMap );
                TLiwGenericParam item( KItem, TLiwVariant( map ));
                inparam->AppendL( item );
                iCPSInterface->ExecuteCmdL( KAdd, *inparam, *outparam );
                }
            CleanupStack::PopAndDestroy( map );
            CleanupStack::PopAndDestroy( outparam );
            CleanupStack::PopAndDestroy( inparam );
            }

        }
    // clean up
    CleanupStack::PopAndDestroy( &entries );
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::AddMapL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::AddItemL( MXCFWNode* aItem,
    CLiwContainer* aContainer, TTypes aType )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::AddItemL" ));
    RNodeArray children;
    CleanupClosePushL( children );
    iContentTree->GetChildNodesL( aItem, children );
    for ( TInt i = 0; i < children.Count( ); i++ )
        {
        if ( children[i]->Data()->TypeIdentifier( ) == KDataItem )
            {
            switch ( aType )
                {
                case EMap:
                    ExtractAttributesAndAddL( children[i],
                        static_cast<CLiwDefaultMap*>(aContainer) );
                    break;
                case EList:
                    ExtractAttributesAndAddL( children[i],
                        static_cast<CLiwDefaultList*>(aContainer ) );
                    break;
                default:
                    {
                    User::Panic( _L("Wrong Type" ),1 );
                    }
                }

            }
        }
    CleanupStack::PopAndDestroy( &children );
    }

// -----------------------------------------------------------------------------
// CCHFactorySettingsParser::RemoveItemL
// (other items were commented in a header).
// -----------------------------------------------------------------------------
//
void CCHFactorySettingsParser::RemoveItemL( MXCFWNode* aItem,
    CLiwDefaultMap* aMap )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::RemoveItemL" ));
    RNodeArray children;
    CleanupClosePushL( children );
    iContentTree->GetChildNodesL( aItem, children );
    for ( TInt i = 0; i < children.Count( ); i++ )
        {
        if ( children[i]->Data()->TypeIdentifier( ) == KDataItem )
            {
            ExtractDeleteAttributesL( children[i], aMap );
            }
        }
    CleanupStack::PopAndDestroy( &children );
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//     
void CCHFactorySettingsParser::ExtractAttributesAndAddL( MXCFWNode* aItem,
    CLiwDefaultList* aList )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::ExtractAttributesAndAddL" ));
    TPtrC type;
    CGECODefaultObject* node=
            static_cast<CGECODefaultObject*>(aItem->Data( ));
    if ( !node->GetAttribute( KAttributeType, type ) )
        {
        HBufC8* bufV= NULL;
        CLiwDefaultMap* nestedMap= NULL;
        CLiwDefaultList* nestedList= NULL;
        TPtrC value;
        TBool valueExist(node->GetAttribute( KAttributeValue, value ) );
        TTypes typeCheck = ConvertToType( type );
        //check if value exist
        //it is not needed in case of Map and List    
        if ( valueExist==KErrNone || typeCheck==EMap || typeCheck==EList )
            {
            switch ( typeCheck )
                {
                case EInteger:
                    aList->AppendL( FactSetCHUtils::Str2Int32( value ) );
                    break;
                case EUInteger:
                    aList->AppendL( FactSetCHUtils::Str2Uint( value ) );
                    break;
                case EDescriptor8:
                    bufV = FactSetCHUtils::Str2Str8LC( value );
                    aList->AppendL( *bufV );
                    CleanupStack::PopAndDestroy( bufV );
                    break;
                case EDescriptor16:
                    aList->AppendL( value );
                    break;
                case EMap:
                    nestedMap = CLiwDefaultMap::NewLC( );
                    AddItemL( aItem, nestedMap, EMap );
                    aList->AppendL( nestedMap );
                    CleanupStack::PopAndDestroy( nestedMap );
                    break;
                case EList:
                    nestedList = CLiwDefaultList::NewLC( );
                    AddItemL( aItem, nestedList, EList );
                    aList->AppendL( nestedList );
                    CleanupStack::PopAndDestroy( nestedList );
                    break;
                case EBool:
                    aList->AppendL( FactSetCHUtils::Str2Bool( value ) );
                    break;
                case EReal:
                    aList->AppendL( FactSetCHUtils::Str2Real( value ) );
                case EUid:
                    aList->AppendL( FactSetCHUtils::Str2Uid( value ) );
                    break;
                default:
                    {
                    //wrong type - ignore     
                    }
                }
            }
        }
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//     
void CCHFactorySettingsParser::ExtractAttributesAndAddL( MXCFWNode* aItem,
    CLiwDefaultMap* aMap )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::ExtractAttributesAndAddL" ));
    TPtrC key;
    TPtrC type;
    CGECODefaultObject* node=
            static_cast<CGECODefaultObject*>(aItem->Data( ));
    if ( !node->GetAttribute( KAttributeType, type ) 
        && !node->GetAttribute( KAttributeKey, key ) )
        {
        HBufC8* bufV= NULL;
        CLiwDefaultMap* nestedMap= NULL;
        HBufC8* buf = FactSetCHUtils::Str2Str8LC( key );
        TPtrC value;
        CLiwDefaultList* nestedList= NULL;
        TBool valueExist(node->GetAttribute( KAttributeValue, value ) );
        TTypes typeCheck = ConvertToType( type );
        //check if value exist
        //it is not needed in case of Map and List    
        if ( valueExist==KErrNone || typeCheck==EMap || typeCheck==EList )
            {
            switch ( typeCheck )
                {
                case EInteger:
                    aMap->InsertL( *buf, FactSetCHUtils::Str2Int32( value ) );
                    break;
                case EUInteger:
                    aMap->InsertL( *buf, FactSetCHUtils::Str2Uint( value ) );
                    break;
                case EDescriptor8:
                    bufV = FactSetCHUtils::Str2Str8LC( value );
                    aMap->InsertL( *buf, *bufV );
                    CleanupStack::PopAndDestroy( bufV );
                    break;
                case EDescriptor16:
                    aMap->InsertL( *buf, value );
                    break;
                case EMap:
                    nestedMap = CLiwDefaultMap::NewL( );
                    AddItemL( aItem, nestedMap, EMap );
                    aMap->InsertL( *buf, nestedMap );
                    nestedMap->DecRef( );
                    break;
                case EList:
                    nestedList = CLiwDefaultList::NewL( );
                    AddItemL( aItem, nestedList, EList );
                    aMap->InsertL( *buf, nestedList );
                    nestedList->DecRef( );
                    break;
                case EBool:
                    aMap->InsertL( *buf, FactSetCHUtils::Str2Bool( value ) );
                    break;
                case EReal:
                    aMap->InsertL( *buf, FactSetCHUtils::Str2Real( value ) );
                    break;
                case EUid:
                    aMap->InsertL( *buf, FactSetCHUtils::Str2Uid( value ) );
                    break;
                default:
                    {
                    //wrong type - ignore     
                    }
                }
            }
        CleanupStack::PopAndDestroy( buf );
        }
    }
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//     
void CCHFactorySettingsParser::ExtractDeleteAttributesL( MXCFWNode* aItem,
    CLiwDefaultMap* aMap )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::ExtractDeleteAttributesL" ));
    TPtrC key;
    TPtrC type;
    CGECODefaultObject* node=
            static_cast<CGECODefaultObject*>(aItem->Data( ));
    if ( !node->GetAttribute( KAttributeType, type ) 
        && !node->GetAttribute( KAttributeKey, key ) )
        {
        HBufC8* bufV= NULL;
        HBufC8* buf = FactSetCHUtils::Str2Str8LC( key );
        TPtrC value;
        TBool valueExist(node->GetAttribute( KAttributeValue, value ) );
        TTypes typeCheck = ConvertToType( type );
        //check if value exist
        if ( valueExist==KErrNone )
            {
            switch ( typeCheck )
                {
                case EDescriptor8:
                    bufV = FactSetCHUtils::Str2Str8LC( value );
                    aMap->InsertL( *buf, *bufV );
                    CleanupStack::PopAndDestroy( bufV );
                    break;
                case EDescriptor16:
                    aMap->InsertL( *buf, value );
                    break;

                default:
                    {
                    //wrong type - ignore     
                    }
                }
            }
        CleanupStack::PopAndDestroy( buf );
        }
    }

// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//     
CCHFactorySettingsParser::TTypes CCHFactorySettingsParser::ConvertToType(
    const TDesC& aType )
    {
    CP_DEBUG(_L8("CCHFactorySettingsParser::ConvertToType" ));
    if ( !aType.Compare( KInteger ) )
        return EInteger;
    if ( !aType.Compare( KUInteger ) )
        return EUInteger;
    if ( !aType.Compare( KDescriptor8 ) )
        return EDescriptor8;
    if ( !aType.Compare( KDescriptor16 ) )
        return EDescriptor16;
    if ( !aType.Compare( KMap ) )
        return EMap;
    if ( !aType.Compare( KList ) )
        return EList;
    if ( !aType.Compare( KBool ) )
        return EBool;
    if ( !aType.Compare( KReal ) )
        return EReal;
    if ( !aType.Compare( KUid ) )
        return EUid;
    return EUndefined;
    }

//  End of File