/*

* 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:  ?Description

 *

*/

#include <s32mem.h>

#include <liwgenericparam.h>

#include <escapeutils.h>

#include <badesca.h>

#include "cpliwmap.h"

#include "cpdebug.h"

#include "cpssqlcommands.h"

#include "ccontentmap.h"

#include "cpublisherregistrymap.h"

#include "cpsecuritypolicy.h"

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

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

// 

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

//

EXPORT_C CCPLiwMap* CCPLiwMap::NewL( RDesReadStream& aStream )

    {

    CLiwGenericParamList* list = CLiwGenericParamList::NewLC( aStream );

    CCPLiwMap* map = CCPLiwMap::NewL( *list );

    CleanupStack::PopAndDestroy( list );

    return map;

    }

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

// 

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

//

EXPORT_C CCPLiwMap* CCPLiwMap::NewL( const CLiwGenericParamList& aList )

    {

    CP_DEBUG( _L8("CCPLiwMap::NewL") );

    const TLiwGenericParam* param = NULL;

    TInt pos( 0 );

    param = aList.FindFirst( pos, KType );

    CCPLiwMap* map( NULL );

    if( param && pos !=KErrNotFound )

        {

        RBuf typeBuf;

        typeBuf.CleanupClosePushL();

        TPtrC type( KNullDesC );

        if( !param->Value().Get( type ) )

            {

            TPtrC8 type8( KNullDesC8 );

            if( !param->Value().Get( type8 ) )

                {

                User::Leave( KErrBadName );

                }

            typeBuf.Assign( EscapeUtils::ConvertToUnicodeFromUtf8L( type8 ) );

            }

        else

            {

            typeBuf.CreateL( type );

            }

        if( typeBuf.Find( KCpData () ) != KErrNotFound )

            {

            map = CContentMap::NewLC();

            }

        else if ( typeBuf.Find( KPublisher () ) != KErrNotFound )

            {

            map = CPublisherRegistryMap::NewLC();

            }

        else User::Leave( KErrArgument );

        map->SetL( aList );

        CleanupStack::Pop( map );

        CleanupStack::PopAndDestroy( &typeBuf );

        }

    else

        {

        User::Leave( KErrPathNotFound );

        }

    return map;

    }

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

// 

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

//		

EXPORT_C HBufC8* CCPLiwMap::PackForServerLC() const

    {

    CP_DEBUG( _L8("CCPLiwMap::PackForServerLC") );

    HBufC8* datadesc = HBufC8::NewLC( Size() );

    TPtr8 ptr = datadesc->Des();

    RDesWriteStream datastrm( ptr );

    CleanupClosePushL(datastrm);

    ExternalizeL(datastrm);

    datastrm.CommitL();

    CleanupStack::PopAndDestroy(&datastrm);

    return datadesc;

    }

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

// 

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

//	

EXPORT_C void CCPLiwMap::Reset( ) const

    {

    iMap->Reset();    

    }

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

// 

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

//

void CCPLiwMap::IsValidForAddL( ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::IsValidForAddL") );

    TInt err( KErrNone );

    TInt32 id( 0 );

    if( GetProperty( KId, id ) && ( id < 1 ) )

        {

        err = KErrArgument;

        }

    else if( !IsId() && PropertyExists( KId ) )

        {

        err = KErrBadName;

        }

    CheckIdentifiersL();

    if( err == KErrNone && !IsId() && !( IsPublisherNameL() 

            && IsContentTypeL() && IsContentIdL() ) )

        {

        err = KErrPathNotFound;

        }

    if( err != KErrNone )

        {

        User::Leave( err );

        }

    }

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

// 

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

//

EXPORT_C void CCPLiwMap::IsValidForActionL( )const

    {

    CP_DEBUG( _L8("CCPLiwMap::IsValidForActionL") );

    CCPLiwMap::IsValidForNotificationL();

    if( !IsTriggerL() ) User::Leave( KErrPathNotFound );

    }

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

// 

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

//

EXPORT_C void CCPLiwMap::IsValidForNotificationL( ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::IsValidForAddL") );

    TInt err( KErrNone );

    TInt32 id( 0 );

    if( GetProperty( KId, id ) && ( id < 1 ) )

        {

        err = KErrArgument;

        }

    else if( !IsId() && PropertyExists( KId ) )

        {

        err = KErrBadName;

        }

    CheckIdentifiersL();

    if( err == KErrNone && !IsId() && !IsPublisherNameL() 

            && !IsContentTypeL() && !IsContentIdL() )

        {

        err = KErrPathNotFound;

        }

    if( err != KErrNone )

        {

        User::Leave( err );

        }

    }

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

// 

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

//

EXPORT_C TBool CCPLiwMap::GetPropertyL( const TDesC8& aProperty ,

        RBuf& aResult ) const

    {

    //change name

    CP_DEBUG( _L8("CCPLiwMap::GetProperty - TPtrC") );

    TBool result( EFalse );

    TInt pos( 0 );

    TPtrC result16( KNullDesC);

    TPtrC8 result8( KNullDesC8);

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );

    if ( pos != KErrNotFound )

        {

        if( paramForValue->Value().Get( result16 ) )

            {

            aResult.CreateL( result16 );

            result = ETrue;

            }

        else if( paramForValue->Value().Get( result8 ) )

            {

            aResult.Assign( EscapeUtils::ConvertToUnicodeFromUtf8L( result8 ) );

            result = ETrue;

            }

        else

        	{

        	User::Leave( KErrBadName );

        	}

        }

    return result;

    }

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

// 

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

//

EXPORT_C TBool CCPLiwMap::GetPropertyL( const TDesC8& aProperty ,

        RBuf8& aResult ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::GetProperty - TPtrC8") );

    TBool result( EFalse );

    TInt pos( 0 );

    TPtrC8 result8( KNullDesC8 );

    TPtrC result16( KNullDesC );

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );

    if ( pos != KErrNotFound )

        {

        if( paramForValue->Value().Get( result8 ) )

            {

            aResult.CreateL( result8 );

            result = ETrue;

            }

        else if( paramForValue->Value().Get( result16 ) )

            {

            aResult.Assign( EscapeUtils::ConvertFromUnicodeToUtf8L( result16 ) );

            result = ETrue;

            }

        else

        	{

        	User::Leave( KErrBadName );

        	}

        }

    return result;

    }

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

// 

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

//

EXPORT_C TBool CCPLiwMap::GetProperty( const TDesC8& aProperty ,

		TInt32& aResult ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::GetProperty - TInt32") );

    TBool result( EFalse );

    TInt pos( 0 );

    const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, aProperty );

    if ( pos != KErrNotFound )

        {

        if( paramForValue->Value().Get( aResult ) )

            {

            result = ETrue;

            }

        }

    return result;

    }

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

// 

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

//

EXPORT_C void CCPLiwMap::SetSecurityL(  const RMessage2& aMessage )

    {

    delete iPolicy;

    iPolicy = NULL;    

    iPolicy = CCPSecurityPolicy::NewL( aMessage );

    }

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

// 

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

//

CCPLiwMap::~CCPLiwMap()

    {

    delete iMap;

    delete iPolicy;

    }

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

// 

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

//

CCPLiwMap::CCPLiwMap()

    {

    }

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

// 

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

//

void CCPLiwMap::InsertL( const TDesC8& aKey, const TLiwVariant& aValue )

    {

    CP_DEBUG( _L8("CCPLiwMap::InsertL") );

    Remove( aKey );

    TLiwGenericParam mp;

    mp.SetNameAndValueL( aKey, aValue );

    iMap->AppendL( mp );

    mp.Reset( );

    }

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

// 

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

//

TBool CCPLiwMap::FindL( const TDesC8& aKey, TLiwVariant& aValue ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::FindL") );

    TInt pos = 0;

    TBool result(EFalse);

    const TLiwGenericParam* tempParam = iMap->FindFirst( pos, aKey );

    if ( tempParam )

        {

        aValue.SetL( tempParam->Value( ) );

        result = ETrue;

        }

    return result;

    }

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

// 

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

//

TInt CCPLiwMap::Count() const

    {

    return iMap->Count( );

    }

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

// 

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

//

TBool CCPLiwMap::AtL( TInt aIndex, TDes8& aKey ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::AtL") );

    TBool result(EFalse);

    if ( 0 <= aIndex && aIndex < iMap->Count( ) )

        {

        aKey = ((*iMap)[aIndex]).Name( );

        result = ETrue;

        }

    return result;

    }

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

// 

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

//

void CCPLiwMap::Remove( const TDesC8& aKey )

    {

    CP_DEBUG( _L8("CCPLiwMap::Remove") );

    TInt pos = 0;

    iMap->FindFirst( pos, aKey );

    if ( pos != KErrNotFound )

        {

        iMap->Remove( aKey );

        }

    }

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

// 

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

//

TInt CCPLiwMap::Size() const

    {

    return iMap->Size( );

    }

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

// 

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

//	

void CCPLiwMap::ExternalizeL( RWriteStream& aStream ) const

    {

    CP_DEBUG( _L8("CCPLiwMap::ExternalizeL") );

    iMap->ExternalizeL( aStream );

    }

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

// 

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

//                  

void CCPLiwMap::FillChangeInfoMapL( RSqlStatement& aStmt, 

		CLiwDefaultMap* aMap )const

	{

    TInt idIndex = ColumnIndexL( aStmt, KColumnId );

    TInt publisherIndex = ColumnIndexL( aStmt, KColumnPublisher );

    TInt contentIndex = ColumnIndexL( aStmt, KColumnContent_type );

    TInt content_idIndex = ColumnIndexL( aStmt, KColumnContent_id );

    TInt acl_Index = ColumnIndexL( aStmt, KColumnAccessList );

    TInt32 id = aStmt.ColumnInt( idIndex ) ;

    TPtrC publisher;

    User::LeaveIfError(aStmt.ColumnText( publisherIndex,publisher) );

    TPtrC content_type;

    User::LeaveIfError(aStmt.ColumnText( contentIndex,content_type ) );

    TPtrC content_id;

    User::LeaveIfError(aStmt.ColumnText( content_idIndex,content_id) );

    aMap->InsertL( KId, TLiwVariant( id ) );

    aMap->InsertL( KPublisherId, TLiwVariant( publisher ) );

    aMap->InsertL( KContentType, TLiwVariant( content_type ) );

    aMap->InsertL( KContentId, TLiwVariant( content_id ) );

    aMap->InsertL( KOperation, TLiwVariant( KOperationDelete ) );

    RBuf type;

    type.CleanupClosePushL();

    if( GetPropertyL( KType, type ) )

         {

         aMap->InsertL( KType , TLiwVariant( type ) );

         }        

    CleanupStack::PopAndDestroy( &type );  

	}

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

// 

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

//

void CCPLiwMap::SetL( const CLiwGenericParamList& aInParamList )

    {

    CP_DEBUG( _L8("CCPLiwMap::SetL") );

    for ( TInt i = 0; i < aInParamList.Count( ); i++ )

        {

        const TLiwGenericParam& param = aInParamList[i];

        if ( param.Value().TypeId( ) == LIW::EVariantTypeMap )

            {

            const CLiwMap* map = param.Value().AsMap( );

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

                {

                TBuf8<128> key;

                map->AtL( i, key );

                TLiwVariant value;

                value.PushL( );

                map->FindL( key, value );

                if ( key == KOperation )

                	{

                	IsProperOperationL( value );

                	}

                RBuf8 datadesc;

                datadesc.CleanupClosePushL();

                if ( value.TypeId( ) == LIW::EVariantTypeMap )

                    {

                    const CLiwMap* internalMap = value.AsMap( );

                    datadesc.CreateL( internalMap->Size( ) );

                    RDesWriteStream datastrm(datadesc);

                    CleanupClosePushL( datastrm );

                    internalMap->ExternalizeL( datastrm );

                    datastrm.CommitL( );

                    CleanupStack::PopAndDestroy( &datastrm );

                    value.Reset( );

                    value.Set( datadesc );

                    }

                TLiwGenericParam data( key, value);

                iMap->AppendL( data );

                CleanupStack::PopAndDestroy( &datadesc );

                CleanupStack::PopAndDestroy( &value );

                }

            }

        else

            {

            iMap->AppendL( param );

            }

        }

    }

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

// 

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

// 

void CCPLiwMap::IsProperOperationL( const TLiwVariant& aValue ) const

    {

    CP_DEBUG( _L8("CContentMap::IsProperOperationL") );

	TPtrC valDesc( KNullDesC );

	TPtrC8 valDesc8( KNullDesC8 );

	RBuf desc;

	desc.CleanupClosePushL();

    if( aValue.Get( valDesc ) == EFalse )

    	{

    	if( aValue.Get( valDesc8 ) != EFalse )

			{

			desc.Assign( EscapeUtils::ConvertToUnicodeFromUtf8L( valDesc8 ) );

			valDesc.Set( desc );

			}

    	else

    		{

    		User::Leave( KErrBadName );

    		}

    	}

    TLex input( valDesc );

    CDesC16Array* array = new (ELeave) CDesC16ArrayFlat(4);

    CleanupStack::PushL( array );

    TLexMark startMark;

    input.Mark( startMark );

    TBool notEmpty = EFalse;

    while ( !input.Eos() )

        {