/*

* Copyright (c) 2006-2010 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:  IETF SIMPLE Protocol implementation for XIMP Framework

*

*/

#include <xdmengine.h>

#include <xdmprotocolinfo.h>

#include <xdmdocument.h>

#include <xdmdocumentnode.h>

#include <xdmnodeattribute.h>

#include <xdmerrors.h>

#include <XdmProtocolUidList.h>

#include "presencepluginxdmpresrules.h"

#include "mpresrulesasynchandler.h"

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

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

// CPresencePluginXdmPresRules::NewLC()

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

//

CPresencePluginXdmPresRules* CPresencePluginXdmPresRules::NewLC( 

	const TInt aSettingId, TBool aLocalMode )

    {

    CPresencePluginXdmPresRules* self =

    	new (ELeave) CPresencePluginXdmPresRules( aSettingId );

    CleanupStack::PushL( self );

    self->ConstructL( aSettingId, aLocalMode );

    return self;

    }

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

// CPresencePluginXdmPresRules::NewL()

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

//

CPresencePluginXdmPresRules* CPresencePluginXdmPresRules::NewL(

    const TInt aXmdId, TBool aLocalMode )

    {

    CPresencePluginXdmPresRules* self =

        new( ELeave ) CPresencePluginXdmPresRules( aXmdId );

    CleanupStack::PushL( self );

    self->ConstructL( aXmdId, aLocalMode  );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginXdmPresRules::CPresencePluginXdmPresRules()

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

//

CPresencePluginXdmPresRules::CPresencePluginXdmPresRules( const TInt aXdmId )

    :CActive( EPriorityStandard ),

    iSettingsId( aXdmId ),

    iXdmState( EStateIdle ), //Listeting xdState

    iRulesUpdateState(EStateNoOperation),

	iPresXdmOk( EFalse ),

	iAsyncReq( ENoOperation )

    {

    CActiveScheduler::Add( this );

    }

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

// CPresencePluginXdmPresRules::ConstructL()

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

//

void CPresencePluginXdmPresRules::ConstructL( 

	const TInt aXmdId,

	TBool aLocalMode )

    {

    DP_SDA2("CPresencePluginXdmPresRules::ConstructL - aXdmId: %d", aXmdId );

    using namespace NPresencePlugin::NPresence;

    if ( !aLocalMode )

        {

        DP_SDA("CPresencePluginXdmPresRules::ConstructL Normal Mode");

        CXdmProtocolInfo* xdmProtocolInfo = CXdmProtocolInfo::NewL( aXmdId );

        CleanupStack::PushL( xdmProtocolInfo );

        DP_SDA("CPresencePluginXdmPresRules::ConstructL - protocol info created");

        xdmProtocolInfo->SetCacheUsage( EFalse );

        DP_SDA("CPresencePluginXdmPresRules::ConstructL - create xdm engine");

        iXdmEngine = CXdmEngine::NewL( *xdmProtocolInfo );

        CleanupStack::PopAndDestroy( xdmProtocolInfo );

        DP_SDA("CPresencePluginXdmPresRules::ConstructL - xdm engine created");

        DP_SDA("CPresencePluginXdmPresRules::ConstructL - create doc model");

		//Create empty document model

		iPresRulesDoc =

            iXdmEngine->CreateDocumentModelL( 

                KPresencePresRules, EXdmOmaPresenceRules );

        DP_SDA("CPresencePluginXdmPresRules::ConstructL - create doc model ok");        

        }

    else

        {

        DP_SDA("CPresencePluginXdmPresRules::ConstructL LocalMode Mode");

        //Lets Try localmode 

        CXdmProtocolInfo* xdmProtocolInfo =

            CXdmProtocolInfo::NewL( 0, KLocalProtocol, KNullDesC );

        CleanupStack::PushL( xdmProtocolInfo );

        iXdmEngine = CXdmEngine::NewL( *xdmProtocolInfo );

        CleanupStack::PopAndDestroy( xdmProtocolInfo );

				//Create empty document model

		iPresRulesDoc =

            iXdmEngine->CreateDocumentModelL( 

                KPresencePresRules, EXdmOmaPresenceRules );

        }

    DP_SDA("CPresencePluginXdmPresRules::ConstructL create root");

	CreateRootIfNeededL();

	DP_SDA("CPresencePluginXdmPresRules::ConstructL - out" );

    }

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

// CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules()

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

//

CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules()

    {

	DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules");

    if ( iPresRulesDoc )

        {

        DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules 2");

        if ( iXdmEngine )

            {

            DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules 3");

            TRAP_IGNORE( iXdmEngine->DeleteDocumentModelL( iPresRulesDoc ));

            }

        }

    delete iXdmEngine;  

    delete iEntityUri;

    DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules Done");

    }

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

// CPresencePluginXdmPresRules::GetXdmRulesL()

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

//    

TInt CPresencePluginXdmPresRules::GetXdmRulesL( 

    MPresRulesAsyncHandler* const aHandler )

    {

    DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL");

	__ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

	if (IsActive())

        return KErrAlreadyExists;

	iAsyncReq = EXdmGetRulesFromServer;

	iAsyncHandler = aHandler;

	using namespace NPresencePlugin::NPresence;

    if ( !iPresXdmOk )

        {

        DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL !iPresXdmOk");

        iPresRulesDoc->FetchDataL();

        DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL !iPresXdmOk end");

        }

    else

        {

        // Document already exists, no need to search from a server

        DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL Already exists");

        iStatus = KRequestPending;

        SetActive();        

        }

  	return KErrNone;

    }

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

// CPresencePluginXdmPresRules::UpdateXdmRulesL()

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

//     

TInt CPresencePluginXdmPresRules::UpdateXdmRulesL( 

	MPresRulesAsyncHandler* const aHandler )

    {

    __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

    if (IsActive())

		{

		return KErrAlreadyExists;

		}

	iAsyncReq = EXdmUpdateRules;

    iAsyncHandler = aHandler;

    iPresRulesDoc->AppendL();

    iXdmEngine->UpdateL(iPresRulesDoc, iStatus);

    SetActive();

    return KErrNone;

    }

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

// CPresencePluginXdmPresRules::MakeInitialRulesDocumentL()

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

//    

void CPresencePluginXdmPresRules::MakeInitialRulesDocumentL( 

    MPresRulesAsyncHandler* const aHandler )

    {

    DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL");

   	__ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

	iAsyncReq = EXdmInitialPresDoc;

	iAsyncHandler = aHandler;

	CXdmDocumentNode* root = iPresRulesDoc->DocumentRoot();

	if ( !root )

	    {

	    DP_SDA("CPresencePluginXdmPresRules:: Create root");

	    root = iPresRulesDoc->CreateRootL();

	    }

    using namespace NPresencePlugin::NPresence;

    root->SetNameL( KPresenceRuleset );

    // send to the server and start wait a response

    iPresRulesDoc->AppendL( root );

    DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL append");

    iAsyncReq = EXdmInitialPresDoc;

    DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL end");

    }

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

// CPresencePluginXdmPresRules::AddWhiteListL()

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

//

void CPresencePluginXdmPresRules::AddWhiteListL( CXdmDocumentNode* aRoot )

    {

    DP_SDA("CPresencePluginXdmPresRules::AddWhiteList");

    using namespace NPresencePlugin::NPresence;

    using namespace NPresencePlugin::NPresenceTransformations;

    if ( aRoot->IsEmptyNode() )

        {

        DP_SDA("AddWhiteList is empty node");

        aRoot->SetEmptyNode( EFalse );

        }

    // whitelist

    CXdmDocumentNode* child2 = aRoot->CreateChileNodeL( KPresenceRule );

    CleanupStack::PushL( child2 );

    CXdmNodeAttribute* name2 = child2->CreateAttributeL( KPresenceId );

    CleanupStack::PushL( name2 );

    name2->SetAttributeValueL( KPresenceXdmWhiteList );

    DP_SDA("CPresencePluginXdmPresRules::AddWhiteList 2");

    CXdmDocumentNode* conditionsNode2 =

        child2->CreateChileNodeL( KPresenceConditions );

    conditionsNode2->CreateChileNodeL( KPresenceIdentity ); 

    CXdmDocumentNode* actionNode2 =

        child2->CreateChileNodeL( KPresenceAction );

    DP_SDA("CPresencePluginXdmPresRules::AddWhiteList 3"); 

    CXdmDocumentNode* subNode2 = actionNode2->CreateChileNodeL( KPresenceSub );

    DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL 4");

    subNode2->SetLeafNode( ETrue ); 

    subNode2->SetLeafNodeContentL( KPresenceAllow8 );

    DP_SDA("CPresencePluginXdmPresRules::AddWhiteList 5"); 

    //Add transformations

    /*<transformations>

    <pr:provide-services>

    <pr:all-services/>

    </pr:provide-services>

    <pr:provide-persons>

    <pr:all-persons/>

    </pr:provide-persons>

    <pr:provide-devices>

    <pr:all-devices/>

    </pr:provide-devices>

    <pr:provide-all-attributes/>

    </transformations>*/

    CXdmDocumentNode* trasform2 =

        child2->CreateChileNodeL( KPresenceTrasformations );

    CXdmDocumentNode* services2 =

        trasform2->CreateChileNodeL( KPresenceProvideServices );

    services2->CreateChileNodeL( KPresenceAllServices );

    CXdmDocumentNode* person2 =

        trasform2->CreateChileNodeL( KPresenceProvidePersons );

    person2->CreateChileNodeL( KPresenceAllPersons );

    CXdmDocumentNode* devices2 =

        trasform2->CreateChileNodeL( KPresenceProvidedevices );

    devices2->CreateChileNodeL( KPresenceAlldevices );

    trasform2->CreateChileNodeL( KPresenceProvideAllAttributes );

    CleanupStack::Pop( name2 );

    CleanupStack::Pop( child2 );

    }

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

// CPresencePluginXdmPresRules::AddBlackList()

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

//

void CPresencePluginXdmPresRules::AddBlackListL( CXdmDocumentNode* aRoot )

    {

    DP_SDA("CPresencePluginXdmPresRules::AddBlackList");

    // add all the list nodes

    // buddylist

    using namespace NPresencePlugin::NPresence;

    using namespace NPresencePlugin::NPresenceTransformations;

    if ( aRoot->IsEmptyNode() )

        {

        DP_SDA("AddBlackList is empty node");

        aRoot->SetEmptyNode( EFalse );

        }

    CXdmDocumentNode* child1 = aRoot->CreateChileNodeL( KPresenceRule );

    CleanupStack::PushL( child1 );

    CXdmNodeAttribute* name = child1->CreateAttributeL( KPresenceId );

    CleanupStack::PushL( name );

    name->SetAttributeValueL( KPresenceXdmBlockRule );

    // add condition

    CXdmDocumentNode* conditionsNode =

        child1->CreateChileNodeL( KPresenceConditions );

    conditionsNode->CreateChileNodeL( KPresenceIdentity );

    CXdmDocumentNode* actionNode =

        child1->CreateChileNodeL( KPresenceAction );

    DP_SDA("CPresencePluginXdmPresRules::AddBlackList 1");

    CXdmDocumentNode* subNode =

        actionNode->CreateChileNodeL( KPresenceSub );

    DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL 1/2");

    subNode->SetLeafNode(ETrue);

    subNode->SetLeafNodeContentL( KPresenceBlock8 ); 

    DP_SDA("CPresencePluginXdmPresRules::AddBlackList 1/3");

    CXdmDocumentNode* trasform =

        child1->CreateChileNodeL( KPresenceTrasformations );

    CXdmDocumentNode* services =

        trasform->CreateChileNodeL( KPresenceProvideServices );

    services->CreateChileNodeL( KPresenceAllServices );

    CXdmDocumentNode* person =

        trasform->CreateChileNodeL( KPresenceProvidePersons );

    person->CreateChileNodeL( KPresenceAllPersons );

    CXdmDocumentNode* devices =

        trasform->CreateChileNodeL( KPresenceProvidedevices );

    devices->CreateChileNodeL( KPresenceAlldevices );

    trasform->CreateChileNodeL( KPresenceProvideAllAttributes );     

    CleanupStack::Pop( name );

    CleanupStack::Pop( child1 );

    }

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

// CPresencePluginXdmPresRules::RunL()

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

//

void CPresencePluginXdmPresRules::RunL( )

    {    

    DP_SDA("CPresencePluginXdmPresRules::RunL");    

    TPluginPresRulesXdmOperation origState = iAsyncReq;

    iAsyncReq = ENoOperation;

    TInt myStatus = iStatus.Int();

    DP_SDA2("CPresencePluginXdmPresRules::RunL mystatus %d ", myStatus);

    DP_SDA2("CPresencePluginXdmPresRules::RunL state %d ", origState);

    switch( origState )

        {

        case EXdmGetRulesFromServer:

            {

            DP_SDA("CPresencePluginXdmPresRules::RunL EXdmGetRulesFromServer");

            iAsyncHandler->HandlePresUpdateDocumentL( 

                iStatus.Int() );

            }     

        break;

        case EXdmInitialPresDoc:

            {

            DP_SDA("CPresencePluginXdmPresRules::RunL EXdmInitialPresDoc");

            iAsyncHandler->HandlePresUpdateDocumentL( 

                iStatus.Int() );

            }

        break;

        case EXdmUpdateRules:

            {

            DP_SDA("CPresencePluginXdmPresRules::RunL EXdmUpdateRules");

            iAsyncHandler->HandlePresUpdateDocumentL( 

                iStatus.Int() );

            }

        break;

        case EXdmUpdateRulesFromServer:

            {

            DP_SDA("RunL ExdmUpdateRulesFromServer");

			CreateRootIfNeededL(); //This check is added for Openser/OpenXcap

            iAsyncHandler->HandlePresUpdateDocumentL( iStatus.Int() );           

            iRulesUpdateState = EStateNoOperation;

            }

        break;

        case ENoOperation:

        default:

            break;

        }

     DP_SDA("CPresencePluginXdmPresRules::RunL end"); 

    }

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

// CPresencePluginXdmPresRules::DoCancel()

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

//    

void CPresencePluginXdmPresRules::DoCancel(  )

    {

	DP_SDA("CPresencePluginXdmPresRules::DoCancel");

	iXdmEngine->CancelUpdate(iPresRulesDoc);

    iAsyncReq = ECancelDocument;   

    }

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

// CPresencePluginXdmPresRules::RunError()

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

//

TInt CPresencePluginXdmPresRules::RunError( TInt /*aError*/ )

    {

	DP_SDA("CPresencePluginXdmPresRules::RunError");

    return KErrNone;

    }

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

// CPresencePluginXdmPresRules::AddEntityToWhiteListL()

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

// 

void CPresencePluginXdmPresRules::AddEntityToWhiteListL(

	const TDesC&  aUri,

	MPresRulesAsyncHandler* const aHandler )

    {

    DP_SDA("CPresencePluginXdmPresRules::AddEntityToWhiteListL");

    iEntityUri = aUri.Alloc();

    DP_SDA2( "AddEntityToWhiteListL entity %S", iEntityUri );

    __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

    iAsyncReq = EXdmUpdateRules;

    iAsyncHandler = aHandler;

    iRulesUpdateState = EStateAddToWhiteList;

    DoOneAddUserL( KPresenceXdmWhiteList, iEntityUri->Des() );

    UpdateXdmRulesL( aHandler );   

    }

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

// CPresencePluginXdmPresRules::RemoveEntityFromWhiteListL()

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

//    

void CPresencePluginXdmPresRules::RemoveEntityFromWhiteListL(

	const TDesC& aUri,

	MPresRulesAsyncHandler* const aHandler )

    {

    DP_SDA("CPresencePluginXdmPresRules::RemoveEntityFromWhiteListL");

    iEntityUri =  aUri.Alloc();

    __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

    iAsyncReq = EXdmUpdateRules;

    iAsyncHandler = aHandler;

    iRulesUpdateState = EStateRemoveFromWhiteList;

    RemoveOneFromRuleL( KPresenceXdmWhiteList, iEntityUri->Des() );

    UpdateXdmRulesL( aHandler );

    }

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

// CPresencePluginXdmPresRules::AddEntityToBlockedRulesL()

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

// 

void CPresencePluginXdmPresRules::AddEntityToBlockedRulesL(

    const TDesC& aUri,

	MPresRulesAsyncHandler* const aHandler )

    {

    DP_SDA("CPresencePluginXdmPresRules::AddEntityToBlockedRulesL");

    iEntityUri =  aUri.Alloc();

     __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

    iAsyncReq = EXdmUpdateRules;

    iAsyncHandler = aHandler;

    iRulesUpdateState = EStateAddToBlockList;

    DoOneAddUserL( KPresenceXdmBlockRule, iEntityUri->Des() );

    UpdateXdmRulesL( aHandler );    

    }

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

// CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL()

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

//

void CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL(

	const TDesC& aUri,

	MPresRulesAsyncHandler* const aHandler )

    {

    DP_SDA("CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL");

    iEntityUri =  aUri.Alloc();

    __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument));

    iAsyncReq = EXdmUpdateRules;

    iAsyncHandler = aHandler;

	iRulesUpdateState = EStateRemoveFromBlackList;

    RemoveOneFromRuleL( KPresenceXdmBlockRule, iEntityUri->Des() );

    UpdateXdmRulesL( aHandler );

    DP_SDA("CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL end");   

    }    

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

// CPresencePluginXdmPresRules::RemoveOneFromRule()

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

//    

void CPresencePluginXdmPresRules::RemoveOneFromRuleL(

   const TDesC& aRule, const TDesC&  aUri )

    {

    DP_SDA("CPresencePluginXdmPresRules::RemoveOneFromRule");

    CXdmDocumentNode* ruleNode = NULL;

    CXdmNodeAttribute* attr = NULL;

    TBool found( EFalse );

    TBool ruleAvaible( EFalse );

    using namespace NPresencePlugin::NPresence;