/*

* Copyright (c) 2006 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:    RLS and Presence XDM, This is class for RLS XDM

*

*/

// Includes

#include <utf.h>

#include <XdmProtocolInfo.h>

#include <XdmEngine.h>

#include <XdmDocument.h>

#include <XdmDocumentNode.h>

#include <XdmNodeAttribute.h>

#include <XdmErrors.h>

#include <xcapappusagedef.h>

#include "crlsxdm.h"

#include "mrlspresxdmasynchandler.h"

#include "rlspresxdmlogger.h"

#include "rlspresxdmconstsint.h"

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

// CRLSXDM::NewL()

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

//

EXPORT_C CRLSXDM* CRLSXDM::NewL( const TInt aSettingId )

	{

  OPENG_DP(D_OPENG_LIT( "CRLSXDM::NewL" ));

	CRLSXDM* self = CRLSXDM::NewLC(aSettingId);

	CleanupStack::Pop(self);

	return self;		

	}

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

// CRLSXDM::NewLC()

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

//

EXPORT_C CRLSXDM* CRLSXDM::NewLC( const TInt aSettingId )

	{

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::NewLC" ));

    CRLSXDM* self = new (ELeave) CRLSXDM();

    CleanupStack::PushL( self );

    self->ConstructL( aSettingId );

    return self;

	}

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

// CRLSXDM::ConstructL()

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

//	

void CRLSXDM::ConstructL(const TInt aSettingId)

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::ConstructL(%d)" ), aSettingId);

    iXDMProtocolInfo = CXdmProtocolInfo::NewL(aSettingId);

    iXDMEngine = CXdmEngine::NewL( *iXDMProtocolInfo);

    iRLSDocument = iXDMEngine->CreateDocumentModelL(KRLSDocumentName,

                                                    EXdmRlsServices);

    CreateRootIfNeededL();

    iListPath = new(ELeave)CDesCArraySeg(KPresRLSDesArrayInitlVal);

    CActiveScheduler::Add( this );

    }

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

// CRLSXDM::CreateRootIfNeededL()

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

//    

void CRLSXDM::CreateRootIfNeededL()

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::CreateRootIfNeededL" ));

    CXdmDocumentNode* myRootNode = iRLSDocument->DocumentRoot();

    if (myRootNode)

        {

        myRootNode->SetEmptyNode(EFalse);// allow new data to be created, for xdmengine bug

        return;

        }

    myRootNode = iRLSDocument->CreateRootL();

    myRootNode->SetNameL( KXdmRlsServices );

    }

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

// CRLSXDM::CRLSXDM()

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

//    

CRLSXDM::CRLSXDM() : CActive( EPriorityStandard ), 

                                            iAsyncReq(ERLSXDMNoRequestMade)

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::CRLSXDM" ));

    }

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

// CRLSXDM::~CRLSXDM()

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

//

CRLSXDM::~CRLSXDM()

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::~CRLSXDM()" ));

    if(IsActive())

        Cancel();

    delete iRLSDocument;

    delete iXDMEngine;

    delete iXDMProtocolInfo;

    iRLSDocument = NULL;

    if(iListPath)

        iListPath->Reset();

    delete iListPath;

    iListPointerPath.Reset();

    delete iNegotiatedServiceUri;

    }

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

// CRLSXDM::UpdateToServerL()

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

//    

EXPORT_C TInt CRLSXDM::UpdateToServerL(MRLSPresXDMAsyncHandler* const aHandler)

	{

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::UpdateToServerL(%d)" ), aHandler);

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

    if (IsActive())

        return KErrAlreadyExists;

    iAsyncReq = ERLSXDMUpdateToServer;

    iAsyncHandler = aHandler;

    iRLSDocument->AppendL();

    iXDMEngine->UpdateL(iRLSDocument, iStatus);

    SetActive();

    return KErrNone;

	}

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

// CRLSXDM::CancelUpdateL()

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

//	

EXPORT_C void CRLSXDM::CancelUpdateL()

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::CancelUpdateL" ));

    if (IsActive())

        {

        DoCancel();

        }

    }

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

// CRLSXDM::UpdateAllFromServerL()

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

//

EXPORT_C TInt CRLSXDM::UpdateAllFromServerL(MRLSPresXDMAsyncHandler* const aHandler)

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::UpdateAllFromServerL(%d)" ));

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

    if (IsActive())

        return KErrAlreadyExists;

    iAsyncHandler = aHandler;

    iRLSDocument->ResetContents();

    iRLSDocument->FetchDataL();

    iAsyncReq = ERLSXDMUpdateFromServer;

    iXDMEngine->UpdateL(iRLSDocument, iStatus);

    SetActive();

    return KErrNone;

    }

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

// CRLSXDM::DeleteAll()

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

//    

EXPORT_C void CRLSXDM::DeleteAll()

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::DeleteAllL"));

    // resetting current path

    iListPath->Reset();

    iListPointerPath.Reset();

    CXdmDocumentNode* myRootNode = iRLSDocument->DocumentRoot();

    if (myRootNode==NULL)

        return;

    myRootNode->SetEmptyNode(ETrue); // delete all data

    myRootNode->SetEmptyNode(EFalse);// allow new data to be created

    }

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

// CRLSXDM::AddServiceURIL()

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

//

EXPORT_C TInt CRLSXDM::AddServiceURIL(const TDesC& aServiceURI)

	{

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::AddServiceURIL(%S)" ),&aServiceURI);

    CXdmDocumentNode* myRootNode = iRLSDocument->DocumentRoot();

    if (myRootNode==NULL)

        return KErrNotFound;

    //check if already exist    

    if (IsServiceUriExist(aServiceURI, myRootNode) != NULL)

        return KErrAlreadyExists;

    //workaround

    myRootNode->SetEmptyNode(EFalse);// allow new data to be created

    CXdmDocumentNode* listServNode = myRootNode->CreateChileNodeL(KXdmService);

    CXdmNodeAttribute* attributeUri = listServNode->CreateAttributeL(KXdmUri);

    attributeUri->SetAttributeValueL(aServiceURI);

    // now add the packages

    CXdmDocumentNode* packagesNode = listServNode->CreateChileNodeL(KXdmPackages);

    CXdmDocumentNode* packageNode = packagesNode->CreateChileNodeL(KXdmPackage);

    packageNode->SetLeafNode(ETrue);

    packageNode->SetLeafNodeContentL(KXdmPresence);

    return KErrNone;

    }

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

// CRLSXDM::RemoveServiceURIL()

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

//

EXPORT_C TInt CRLSXDM::RemoveServiceURIL(const TDesC& aServiceURI)

	{

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::RemoveServiceURIL(%S)" ),&aServiceURI);

    CXdmDocumentNode* myRootNode = iRLSDocument->DocumentRoot();

    TInt err(KErrNotFound);

    if (myRootNode!=NULL)

        {

        CXdmDocumentNode* serviceNode = IsServiceUriExist(aServiceURI, myRootNode);

        if(serviceNode) // if exist

            {

            iRLSDocument->RemoveFromModelL(serviceNode);

            err = KErrNone;

            }

        }

    // check valdity of path if operation is successful

    if(iListPath->Count() && (err==KErrNone))

        {

        if( (iListPath->MdcaPoint(0)) == aServiceURI)

            {

            // resetting current path

            iListPath->Reset();

            iListPointerPath.Reset();

            }

        }

    OPENG_DP(D_OPENG_LIT( "     returned: %d" ),err);

    return err;

	}

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

// CRLSXDM::IsExistServiceURI()

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

//

EXPORT_C TBool CRLSXDM::IsExistServiceURI(const TDesC& aServiceURI)

	{

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::IsExistServiceURI(%S)" ),&aServiceURI);

    CXdmDocumentNode* myRootNode = iRLSDocument->DocumentRoot();

    TBool isExist(EFalse);

    if (myRootNode!=NULL)

        {

        CXdmDocumentNode* serviceNode = IsServiceUriExist(aServiceURI, myRootNode);

        if(serviceNode) // if exist

            {

            isExist = ETrue;

            }

        }

    OPENG_DP(D_OPENG_LIT( "     returned: %d" ),isExist);

    return isExist;

	}

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

// CRLSXDM::GetServiceUris()

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

//

EXPORT_C void CRLSXDM::GetServiceUrisL(CDesCArray& aServiceUris)

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::GetServiceUris" ));

    CXdmDocumentNode* myRootNode = iRLSDocument->DocumentRoot();

    RPointerArray<CXdmDocumentNode> nodes;

    CXdmNodeAttribute* uriAttribute(NULL);

    if (myRootNode!=NULL)

        {

        // Find all Service Uris under root Node

        if ((myRootNode->Find(KXdmService, nodes)) == KErrNone)

            { // go through all found Uris

            TInt uriCountInNode = nodes.Count();

            OPENG_DP(D_OPENG_LIT( "     uriCountInNode(%d)" ),uriCountInNode);

            for (TInt k=0;k<uriCountInNode;k++)

                { // get the uri attribute

                uriAttribute = (nodes[k])->Attribute(KXdmUri);

                // push it to given discriptor array

                aServiceUris.AppendL(uriAttribute->AttributeValue());

                }

            }

        }

    nodes.Close();

    }

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

// CRLSXDM::DeleteAllEmptyServiceUrisL()

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

//	

EXPORT_C void CRLSXDM::DeleteAllEmptyServiceUrisL()

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::DeleteAllEmptyServiceUrisL" ));

    RPointerArray<CXdmDocumentNode> uriNodes;

    // resetting current path

    iListPath->Reset();

    iListPointerPath.Reset();

    TInt found = iRLSDocument->Find( KXdmService, uriNodes);

    OPENG_DP(D_OPENG_LIT( "     total Uris: %d" ), found);

    for (TInt i=0;i<found;i++)

        {

        if ( ((uriNodes[i])->NodeCount()) <= 1)// if Uri have only package node

            {

            iRLSDocument->RemoveFromModelL(uriNodes[i]);

            OPENG_DP(D_OPENG_LIT( "     delete at i = %d" ), i);

            }

        }

    uriNodes.Close();    

    }

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

// CRLSXDM::RenameListL()

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

//	

EXPORT_C TInt CRLSXDM::RenameListL(const TDesC& aListName, 

                                                    const TDesC& aListNewName)

	{

	OPENG_DP(D_OPENG_LIT( "CRLSXDM::RenameListL(%S)" ),&aListName);

	TInt err(KErrNotFound);

	TInt count = iListPointerPath.Count();

	if (count)

	    {

	    CXdmDocumentNode* list = GetNonLeafChild(KXdmList,aListName,

                                                    iListPointerPath[count-1]);

	    if (list!=NULL) // if found

            { // if new name already exist

            CXdmDocumentNode* newList = GetNonLeafChild(KXdmList, aListNewName,

                                                        iListPointerPath[count-1]);

            if (newList)

                err = KErrAlreadyExists;

            else

                {

         	    CXdmNodeAttribute* myAttribute = list->Attribute(KXdmName);

        	    myAttribute->SetAttributeValueL(aListNewName);

        	    err = KErrNone;

                }

            }

        }

    OPENG_DP(D_OPENG_LIT( "     returned: %d" ),err);

    return err;

	}

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

// CRLSXDM::DeleteAllEmptyLists()

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

//

EXPORT_C TInt CRLSXDM::DeleteAllEmptyLists(MRLSPresXDMAsyncHandler* const aHandler)

    {

    OPENG_DP(D_OPENG_LIT( "CRLSXDM::DeleteAllEmptyListsL(%d)" ), aHandler);

    if(aHandler==NULL)

        return KErrArgument;

    if (IsActive())

        return KErrAlreadyExists;

    // resetting current path

    iListPath->Reset();

    iListPointerPath.Reset();

    iAsyncReq = ERLSXDMDeletingEmptyLists;

    iAsyncHandler = aHandler;

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status,KErrNone);

    SetActive();

    return KErrNone;

    }

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

// CRLSXDM::AddElementL()

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

//

EXPORT_C TInt CRLSXDM::AddElementL(const TDesC& aElementType,

                        const TDesC& aData, const TDesC& aDisplayName)

    {

	OPENG_DP(D_OPENG_LIT( "CRLSXDM::AddElementL" ));

	OPENG_DP(D_OPENG_LIT( "     aElementType(%S), aData(%S), aDisplayName(%S)"),

	                                &aElementType, &aData, &aDisplayName);

	TInt err(KErrNone);

    TInt count = iListPointerPath.Count();

	if(aElementType==KXdmResourceList)

	    {

    	if (count) // should be atleast 1, so that resource-list reside inside serviceUri

    	    {

    	    CXdmDocumentNode* list = GetLeafChild(aElementType, aData,

                                                        iListPointerPath[count-1]);

    	    if (!list) // if not found

	            {

        	    if(count==1)// if the package on same level

        	        RemovePackageL();

                AddLeafElementL(KXdmResourceList, aData, iListPointerPath[count-1]);	    

                if(count==1)// if the package on same level

        	        AddPackageL(); // so that package is the last element on service-uri

        	    err = KErrNone;

	            }

	        else

                err = KErrAlreadyExists;

            }

        else

            err = KErrPermissionDenied; // path is not suitable

	    }

	else if(IsNonLeafElementValid(aElementType))

	    {

	    if( (count>1) || ((aElementType==KXdmList)&&(count)) )

	        {

	        CXdmDocumentNode* element = GetNonLeafChild(aElementType, aData,

                                                        iListPointerPath[count-1]);

            if(!element) // if element doesnt exist

	            {

        	    if(count==1)// if the package on same level

        	        RemovePackageL();

                AddNonLeafElementL(aElementType, aData, aDisplayName, iListPointerPath[count-1]);	    

                if(count==1)// if the package on same level

        	        AddPackageL(); // so that package is the last element on service-uri

        	    err = KErrNone;

	            }

            else

                err = KErrAlreadyExists;

	        }

        else

            err = KErrPermissionDenied; // path is not suitable

	    }

	else

	    err = KErrArgument;

	OPENG_DP(D_OPENG_LIT( " return: err(%d)" ), err);

	return err;

    }

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

// CRLSXDM::GetDisplayName()

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

//

EXPORT_C TInt CRLSXDM::GetDisplayName(const TDesC& aElementType,

                                const TDesC& aData, TPtrC8& aDisplayName)

    {

	OPENG_DP(D_OPENG_LIT( "CRLSXDM::GetDisplayName" ));

	OPENG_DP(D_OPENG_LIT( "     aElementType(%S), aData(%S)"),

	                                    &aElementType, &aData);

	TInt err(KErrNotFound);

	TInt count = iListPointerPath.Count();

	if (count) // if there is atleast service uri

	    {

	    if(IsNonLeafElementValid(aElementType))

	        {

	        err = GetDisplayNameInt(aElementType, aData, aDisplayName,

                                            iListPointerPath[count-1]);

	        }

	    else

	        err = KErrArgument;

        }

    return err;     

    }

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

// CRLSXDM::UpdateDisplayNameL()

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

//

EXPORT_C TInt CRLSXDM::UpdateDisplayNameL(const TDesC& aElementType,  

                        const TDesC& aData, const TDesC& aDisplayName)

    {

	OPENG_DP(D_OPENG_LIT( "CRLSXDM::UpdateDisplayNameL" ));

	OPENG_DP(D_OPENG_LIT( "     aElementType(%S), aData(%S), aDisplayName(%S)"),

	                                    &aElementType, &aData, &aDisplayName);

	TInt err(KErrNotFound);

	TInt count = iListPointerPath.Count();

	if (count) // if there is atleast service uri

	    {

	    if(IsNonLeafElementValid(aElementType))

	        {

	        err = UpdateDisplayNameIntL(aElementType, aData, aDisplayName,

                                            iListPointerPath[count-1]);

	        }

	    else

	        err = KErrArgument;

        }

    return err;     

    }

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

// CRLSXDM::GetElementsL()

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

//

EXPORT_C void CRLSXDM::GetElementsL(const TDesC& aElementType, 

                                                    CDesCArray& aValues)

    {

	OPENG_DP(D_OPENG_LIT( "CRLSXDM::GetElementsL" ));

	OPENG_DP(D_OPENG_LIT( "     aElementType(%S)"),&aElementType);