/*

* 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 <e32std.h>

#include <utf.h>

#include <e32test.h>

#include <ximpobjectfactory.h>

#include <presenceobjectfactory.h>

#include <ximpidentity.h>

#include <ximpobjectcollection.h>

#include <presentitygroupinfo.h>

#include <presentitygroupmemberinfo.h>

#include <xdmengine.h>

#include <xdmdocument.h>

#include <xdmprotocolinfo.h>

#include <xdmdocumentnode.h>

#include <xdmnodeattribute.h>

#include <xdmerrors.h>

#include <pressettingsapi.h> //for TPresSettingsSet

#include <XdmSettingsApi.h>

#include <XdmProtocolUidList.h>

#include <avabilitytext.h>

#include "presencepluginxdmpresrules.h"

#include "mpresencepluginconnectionobs.h"

#include "presenceplugincommon.h"

#include "presencepluginxdmutils.h"

#include "presencepluginvirtualgroup.h"

#include "presencepluginauthorization.h"

#include "presenceplugindata.h"

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

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

// CPresencePluginXdmUtils::CPresencePluginXdmUtils()

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

//

CPresencePluginXdmUtils::CPresencePluginXdmUtils(  

	MPresencePluginConnectionObs& aObs , TInt aXmdId, TBool aLocalmode )

    : CActive( CActive::EPriorityStandard ),

    iConnObs(aObs), iSettingsId(aXmdId),

    iXdmState(EStateIdle), iOperation( ENoOperation ),

	iPresXdmOk( EFalse ), iXdmOk( EFalse ),

	iRulesUpdateState(EStateNoOperation), iLocalMode( aLocalmode )

    {

    CActiveScheduler::Add( this );

    }

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

// CPresencePluginXdmUtils::ConstructL()

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

//

void CPresencePluginXdmUtils::ConstructL( )

    {

    //If we are in normalmode we need presence rules too

    if ( !iLocalMode )

        {

        DP_SDA("CPresencePluginXdmUtils::ConstructL NormalMode");

        iXdmPresRules = CPresencePluginXdmPresRules::NewL( 

            iSettingsId, EFalse );

        }

    }

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

// CPresencePluginXdmUtils::NewL()

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

//

CPresencePluginXdmUtils* CPresencePluginXdmUtils::NewL(

    MPresencePluginConnectionObs& aObs, TInt aXmdId, TBool aLocalmode )

    {

    CPresencePluginXdmUtils* self =

    	new( ELeave ) CPresencePluginXdmUtils( aObs, aXmdId, aLocalmode );

    CleanupStack::PushL( self );

    self->ConstructL(   );

    CleanupStack::Pop( self );

    return self;

    }

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

// CPresencePluginXdmUtils::~CPresencePluginXdmUtils()

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

//

CPresencePluginXdmUtils::~CPresencePluginXdmUtils()

    {

    DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils");

    if ( iXdmDoc )

        {

        DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 1");

        if (iXdmEngine)

            {

            DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils del doc");

            TRAP_IGNORE( iXdmEngine->DeleteDocumentModelL( iXdmDoc ));

            }

        }

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

    delete iXdmEngine;

    iXdmEngine = NULL;

    DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 4");

    delete iXdmPresRules;

    iXdmPresRules = NULL;

    DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 5");

    delete iEntityUri;

    iEntityUri = NULL;

    DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils end"); 

    }

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

// CPresencePluginXdmUtils::InitializeXdmL()

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

//

void CPresencePluginXdmUtils::InitializeXdmL( TRequestStatus& aStatus )

    {

    DP_SDA("CPresencePluginXdmUtils::InitializeXdmL");

    aStatus = KRequestPending;

	iClientStatus = &aStatus;

	// if resource-list not ready

    if ( !iXdmOk ) 

        {

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmL !iXdmOk");

        if ( !iLocalMode )

            {

            DP_SDA("CPresencePluginXdmUtils::InitializeXdmL NormalMode");

            GetXdmListsL( ETrue, EFalse );

            }

        else

            {

            DP_SDA("CPresencePluginXdmUtils::InitializeXdmL LocalMode");

            GetXdmListsL( ETrue, ETrue );

            }

        }

    else if ( !iPresXdmOk && !iLocalMode )

        {

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmL  !iPresXdmOk");

        GetXdmRulesL();  

        }

    else

        {

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmL All is OK ");

        // All is ok

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmL SEND COMPLETE")        

        CompleteClientReq( KErrNone );

        }

    }

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

// CPresencePluginXdmUtils::InitializeXdmL()

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

//    

void CPresencePluginXdmUtils::InitializePresRulesL( )

    {

    DP_SDA("CPresencePluginXdmUtils:: MakeInitialRules");

    iXdmState = ECreateXdmRules;

	iRulesUpdateState = EStateInitializeRules;

    iXdmPresRules->MakeInitialRulesDocumentL( this );

    UpdateXdmRulesL();

    DP_SDA("CPresencePluginXdmUtils:: MakeInitialRules done");

    }

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

// CPresencePluginXdmUtils::GetXdmRulesL()

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

//    

void CPresencePluginXdmUtils::GetXdmRulesL()

    {

    DP_SDA("CPresencePluginXdmUtils:: GetXdmRulesL");

	if ( !iXdmPresRules )

		{

    // get data from a network if not done so yet

		if ( !iLocalMode )

			{

			iXdmPresRules = CPresencePluginXdmPresRules::NewL( 

				iSettingsId, EFalse );

			}

		else

			{

			/*localmode*/

			//iXdmPresRules 

			//= CPresencePluginXdmPresRules::NewL( iSettingsId, ETrue );

			}

		}

	if( !iLocalMode && iXdmPresRules )

	    {

	    User::LeaveIfError( iXdmPresRules->UpdateFromServerL( this ));

	    }

    iXdmState = EGetXdmRules;

    DP_SDA("CPresencePluginXdmUtils:: GetXdmRulesL done");

    DP_SDA("CPresencePluginXdmUtils::GetXdmRulesL - add buddies to virtual");

    AddIdentityToVirtualListL( KPresenceBuddyList );

    DP_SDA("CPresencePluginXdmUtils::GetXdmRulesL - add blocked to virtual");

    AddIdentityToVirtualListL( KPresenceBlockedList );

    }

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

// CPresencePluginXdmUtils::InitializeXdmsOnlyL()

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

//   

void CPresencePluginXdmUtils::InitializeXdmsOnlyL( TRequestStatus& aStatus )

    {

    DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL");             

	aStatus = KRequestPending;

    iClientStatus = &aStatus;

    if ( !iXdmOk )

        {

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL 1");

        GetXdmListsL( EFalse, EFalse );        

        }

    else

        {

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL all ok");

        // All is ok

        DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL SEND COMPLETE")        

        CompleteClientReq( KErrNone );

        }

    DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL end");

    }

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

// CPresencePluginXdmUtils::CheckXdmDoc()

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

//    

TBool CPresencePluginXdmUtils::CheckXdmDoc()

    {

    DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc");

    if ( iXdmDoc )

        {

        CXdmDocumentNode* root = iXdmDoc->DocumentRoot();

        DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc2");

        if( root )

        	{	

            TInt count = root->NodeCount();

            DP_SDA2("CPresencePluginXdmUtils::CheckXdmDoc count %d", count);

            if ( !count )

                {

                DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc NotFound");

                iXdmOk = EFalse;

                }

            else

                {

                DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc file ok");

                iXdmOk = ETrue;

                }

        	}

        }

    else

        {

        DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc file False");

        iXdmOk = EFalse;

        }

    return iXdmOk;

    }

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

// CPresencePluginXdmUtils::CheckIfError

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

//

TInt CPresencePluginXdmUtils::CheckIfErrorL( TInt aMyStatus )

    {

    TInt myStatus = aMyStatus;

    DP_SDA2("CPresencePluginXdmUtils::CheckIfError ErrorCode %d ", myStatus);

    if ( myStatus == KErrTimedOut )

        {

        DP_SDA("CPresencePluginXdmUtils::CheckIfError  TimeOut error");

        myStatus = KErrTimedOut;

        User::Leave( KErrTimedOut );

        }

    else if ( myStatus == KErrCouldNotConnect || 

    	myStatus == KXcapErrorNetworkNotAvailabe )

        {

        DP_SDA("CheckIfError KErrCouldNotConnect error");

        myStatus = aMyStatus;

        }

	else if ( myStatus == KXcapErrorHttpNotFound )

		{

		DP_SDA("CheckIfError KXcapErrorHttpNotFound");

        myStatus = aMyStatus;

		}

    else if ( myStatus == KXcapErrorAuthentication )

        {

        DP_SDA("CPresencePluginXdmUtils::CheckIfError auth error");                        

        myStatus = aMyStatus;

        }

    else if ( myStatus == KXcapErrorTooManyOccurencies )

        {

        DP_SDA("CPresencePluginXdmUtils KXcapErrorTooManyOccurencies");                        

        myStatus = 0;

        }

    else if( myStatus == KErrDisconnected )

        {

        myStatus = aMyStatus;

        User::Leave( KErrCancel );

        }

    else if( myStatus == KXcapErrorHttpPrecondFailed )

    	{

    	DP_SDA("CheckIfError KXcapErrorHttpPrecondFailed");

        myStatus = aMyStatus;

    	}

    else if ( KErrNoMemory == myStatus )

        {

        DP_SDA("CheckIfError KErrNoMemory");

        User::Leave( KErrNoMemory );

        }

    else

        {

        DP_SDA("CPresencePluginXdmUtils::CheckIfError ERROR");

        myStatus = aMyStatus;

        }

    return myStatus;

    }

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

// CPresencePluginXdmUtils::RunL()

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

//

void CPresencePluginXdmUtils::RunL(  )

    {    

    DP_SDA("CPresencePluginXdmUtils::RunL");    

    TPluginXdmState origState = iXdmState;

    iXdmState = EStateIdle;

    TInt myStatus = iStatus.Int();

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

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

    DP_SDA2("CPresencePluginXdmUtils:: ClientStatus %d",iClientStatus->Int() );

    if ( myStatus == KErrCancel )

        {

        DP_SDA("CPresencePluginXdmUtils::RunL CANCEL SEND COMPLETE")

        CompleteClientReq( KErrCancel );

        }

    switch ( origState )

        {

        case EGetXdmLists:

		case EGetXdmListsOnly:

            {

            DoGetXdmListsL( myStatus, origState );

            }

        break;

        case ECreateXdmLists:

            {

            DoCreateXdmListsL( myStatus, origState, EFalse );

            }

        break;

        case ECreateXdmListsOnly:

            {

            DoCreateXdmListsL( myStatus, origState, ETrue );

            }

        break;

        case EGetXdmBlockList:

            {

            DP_SDA("RunL EGetXdmBlockList SEND COMPLETE");

            CompleteClientReq( KErrNone );

            }

        break;

        case EUpdateXdmList:

            {

            DoUpdateXdmListsL( myStatus, origState );

            }

        break;

        default:

            {

            DP_SDA("CPresencePluginXdmUtils::RunL last else");        

            //check myStatus error

            myStatus = CheckIfErrorL( myStatus );

            if ( myStatus )

                {

                // complete reqular request

                DP_SDA("CPresencePluginXdmUtils::RunL SEND LAST COMPLETE");

                CompleteClientReq( myStatus );

                }

            DP_SDA("CPresencePluginXdmUtils::RunL default end")

            }

        break;

        }

    DP_SDA("CPresencePluginXdmUtils::RunL end");

    }

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

// CPresencePluginXdmUtils::DoUpdateXdmLists()

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

//

void CPresencePluginXdmUtils::DoUpdateXdmListsL( 

    TInt aMyStatus,

    TPluginXdmState /*aOrigState*/)

    {

    DP_SDA("CPresencePluginXdmUtils::DoUpdateXdmLists EUpdateXdmList");

    if ( !iLocalMode )

        {

        DP_SDA("CPresencePluginXdmUtils::DoUpdateXdmLists updaterules");

        if( aMyStatus )

        	{

        	DP_SDA("DoUpdateXdmLists updaterules error");

        	aMyStatus = CheckIfErrorL( aMyStatus );

        	CompleteClientReq( aMyStatus );

        	}

        else

        	{

        	DP_SDA("DoUpdateXdmLists updaterules else");	 

        	UpdateXdmRulesL();

        	}

        }

    else

        {

        DP_SDA("EUpdateXdmList LOCALMODE SEND COMPLETE");

        aMyStatus = CheckIfErrorL( aMyStatus );

        CompleteClientReq( aMyStatus );

        } 

    iRulesUpdateState = EStateNoOperation;

    DP_SDA("CPresencePluginXdmUtils::DoUpdateXdmLists EUpdateXdmList end");

    }

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

// CPresencePluginXdmUtils::DoCreateXdmLists()

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

//

void CPresencePluginXdmUtils::DoCreateXdmListsL( 

    TInt aMyStatus,

    TPluginXdmState /*aOrigState*/,

    TBool aOnlyResourceList )

    {

    DP_SDA("CPresencePluginXdmUtils::DoCreateXdmListsL ECreateXdmLists");

    //check myStatus error

    aMyStatus = CheckIfErrorL( aMyStatus );

    if( !aOnlyResourceList )

        {

        if ( aMyStatus )

            {

            DP_SDA("DoCreateXdmLists ECreateXdmLists SEND COMPLETE");

            CompleteClientReq( aMyStatus );

            }

        else if ( !iLocalMode )

            {

            DP_SDA("ECreateXdmLists !myStatus GetXdmRules");

            iXdmOk = ETrue;

            GetXdmRulesL();

            }

        else if ( iLocalMode )

            {

            DP_SDA("DoCreateXdmLists ECreateXdmLists SEND COMPLETE 2");

            iXdmOk = ETrue;

            CompleteClientReq( aMyStatus );

            }

        }

    else

        {

        //check myStatus error

        aMyStatus = CheckIfErrorL( aMyStatus );     

        if ( aMyStatus == KErrTimedOut  )

            { 

            DP_SDA("DoCreateXdmLists EGetXdmListsOnly 1");

            aMyStatus = 0;

            }           

        if ( !aMyStatus )

            {

            DP_SDA("DoCreateXdmLists EGetXdmListsOnly 2");

            iXdmOk = ETrue;

            }

        if( !(KXcapErrorNetworkNotAvailabe == aMyStatus || 

              KErrCouldNotConnect == aMyStatus ) )

            {

            DP_SDA("DoCreateXdmLists EGetXdmListsOnly SEND COMPLETE");

            CompleteClientReq( aMyStatus );

            }

        }

    DP_SDA("CPresencePluginXdmUtils::DoCreateXdmListsL ECreateXdmLists end");

    }

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

// CPresencePluginXdmUtils::DoGetXdmLists()

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

//

void CPresencePluginXdmUtils::DoGetXdmListsL( 

    TInt aMyStatus,

    TPluginXdmState aOrigState )

    {

    DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists EGetXdmLists");

    //check myStatus error

    aMyStatus = CheckIfErrorL( aMyStatus );

    if ( aMyStatus )//Check is file includes nodes

        {

        DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists CreateXDM");

        // no resource-list, let's start to create it.

        CreateXdmListsL( ETrue );

        }

    else

        {

        DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists EGetXdmLists else");

        if( iLocalMode )

            {