/*

* Copyright (c) 2005 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:  DM tree etc.

*

*/

#include <utf.h>

#include <smldmadapter.h>

#include <nsmldebug.h>

#include <nsmldmmodule.h>

//For P&S keys

#include <e32property.h>

#include "nsmldminternalpskeys.h"

#include "nsmldmddf.h"

#include "nsmldmtreeconstants.h"

#include "nsmldmhostclient.h"

#include "nsmldmclientandserver.h"

#include "nsmldmuri.h"

#include <featmgr.h>

// FOTA

#include "nsmldmimpluids.h"

// FOTA end

#ifndef __WINS__

// This lowers the unnecessary compiler warning (armv5) to remark.

// "Warning:  #174-D: expression has no effect..." is caused by 

// DBG_ARGS8 macro in no-debug builds.

#pragma diag_remark 174

#endif

const TInt KGranularity = 4;

// FOTA

_LIT8 ( KNSmlDMFotaNode, "FUMO" );

_LIT8 ( KNSmlDMRoot, "." );

// FOTA end

// ===========================================================================

// CNSmlDmDDF

// ===========================================================================

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

// CNSmlDmDDF::CNSmlDmDDF(CNSmlDmModule& aDmModule)

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

CNSmlDmDDF::CNSmlDmDDF(CNSmlDmModule& aDmModule) : iDmModule(aDmModule)

	{

	}

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

// CNSmlDmDDF::~CNSmlDmDDF()

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

CNSmlDmDDF::~CNSmlDmDDF()

	{

	delete iMgmtTree;

	iSessionArray.Reset();

	iSessionArray.Close();

	iResultRefs.ResetAndDestroy();

	iDeleteStatusRefs.ResetAndDestroy();

	iAddNodeStatusRefs.ResetAndDestroy();

	if(iAddRootNodesList)

		{

		delete iAddRootNodesList;

		}

	//P&S key deletion,even fine if the key is not there

	RProperty::Delete( KPSUidNSmlDMSyncAgent,KNSmlDMCmdAddNodeSuccess);

	FeatureManager::UnInitializeLib();

	}

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

//CNSmlDmDDF* CNSmlDmDDF::NewL(CNSmlDmDbHandler *aDbHandler)

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

CNSmlDmDDF* CNSmlDmDDF::NewL(CNSmlDmModule& aModule)

	{

	CNSmlDmDDF* self = new (ELeave) CNSmlDmDDF(aModule);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

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

// void CNSmlDmDDF::GenerateDDFL(CBufBase& aObject)

// Generates generates xml from the ddf

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

void CNSmlDmDDF::GenerateDDFL(CBufBase& aObject)

	{

	_DBG_FILE("CNSmlDmDDF::GenerateDDFL() : begin");

	iMgmtTree->GenerateXMLL(aObject);

	_DBG_FILE("CNSmlDmDDF::GenerateDDFL() : end");

	}

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

// void CNSmlDmDDF::SetServerL(const TDesC8& aURI)

// Sets serverid to db

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

void CNSmlDmDDF::SetServerL(const TDesC8& aServerId)

	{

	_DBG_FILE("CNSmlDmDDF::SetServerL() : begin");

	iDbSession.SetServerL(aServerId);

	_DBG_FILE("CNSmlDmDDF::SetServerL() : end");

	}

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

// TBool CNSmlDmDDF::IsDDFChangedL(/*CNSmlDmDbHandler *aDbHandler,*/

// 	TDesC& aServer)

// Checks if ddf has been changed. Ask the ddf version from all the adapters

// and calculates checksum from adapter implementaion uids and versions

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

TInt CNSmlDmDDF::IsDDFChangedL()

	{

	_DBG_FILE("CNSmlDmDDF::IsDDFChangedL() : begin");

	User::LeaveIfError( iDbSession.Connect() );

	TInt checkSum(0);

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

		{

		switch(i)

			{

			case 0:

				if(iSessionArray[i].ConnectL(KNSmlDmHostServer1Name,this)

					==KErrNone)

					{

					iOkSessions=iOkSessions|(0x01<<i);

					checkSum=checkSum+iSessionArray[i].DDFStructureL(

						*iMgmtTree);

					iMgmtTree->SetServerId(i+1);

					}

				break;

			case 1:

				if(iSessionArray[i].ConnectL(KNSmlDmHostServer2Name,this)

					==KErrNone)

					{

					iOkSessions=iOkSessions|(0x01<<i);

					checkSum=checkSum+iSessionArray[i].DDFStructureL(

						*iMgmtTree);

					iMgmtTree->SetServerId(i+1);

					}

				break;

			case 2:

				if(iSessionArray[i].ConnectL(KNSmlDmHostServer3Name,this)

					==KErrNone)

					{

					iOkSessions=iOkSessions|(0x01<<i);

					checkSum=checkSum+iSessionArray[i].DDFStructureL(

						*iMgmtTree);

					iMgmtTree->SetServerId(i+1);

					}

				break;

			case 3:

				if(iSessionArray[i].ConnectL(KNSmlDmHostServer4Name,this)

					==KErrNone)

					{

					iOkSessions=iOkSessions|(0x01<<i);

					checkSum=checkSum+iSessionArray[i].DDFStructureL(

						*iMgmtTree);

					iMgmtTree->SetServerId(i+1);

					}

				break;

			default:

				User::Panic ( KNSmlTxtPanicDmModule, KErrArgument );

				break;

			}

		}

	return checkSum;

	}

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

// void CNSmlDmDDF::AddObjectL(const TDesC& aURI, const TDesC8& aObject,

// 	const TDesC& aType)

// Adds object, if adapter is found by using th uri, calls the adapters add object function.

// Adapters AddNodeObjectL is called if not leaf object

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

void CNSmlDmDDF::AddObjectL(const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	const TInt aStatusRef,

	TBool aLargeItem)

	{

	_DBG_FILE("CNSmlDmDDF::AddObjectL() : begin");

	TBool adapterCalled = EFalse;

	TInt status = KNSmlDmStatusNotFound;		

	if(iAdapterId==0||iSessionId==0)

		{

		//update not allowed in object group level (levels before adapter

		//level) 

		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

		return;

		}

	if(iDbSession.CheckDynamicAclL(aURI,EAclAdd,iMgmtTree))	 //tarm

		{

		//acl rigths ok

		TNSmlDmDDFFormat format = IsLeafL(aURI);

		TPtrC8 parentUri = NSmlDmURI::ParentURI(aURI);

		if(format==ENSmlDmDDFLeaf)

			{

			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

			TInt len = luid->Length();

			CleanupStack::PushL(luid);

			TInt find = KErrNotFound;

			if( !FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112) )//means DM 1.2

			 {

			 if(iAddRootNodesList)

			     {							

			     HBufC8* puri = HBufC8::NewLC(parentUri.Length()+2);

			     puri->Des().Append(parentUri);

			     puri->Des().Append(',');

			     find = iAddRootNodesList->Find(puri->Des());	

			     CleanupStack::PopAndDestroy();

			     }			

			 if( find <= KErrNotFound )

			     {

			     TBool returnstatus = ETrue; 

			     TPtrC8 Uri1 = NSmlDmURI::URISeg(aURI,1);

			     if( iAddRootNodesList )//dm case

			     {

			     TPtrC8 FindUri = NSmlDmURI::URISeg(aURI,2);

			     HBufC8* puri = HBufC8::NewLC(Uri1.Length()+FindUri.Length()+2);

			     puri->Des().Append(aURI.Left(Uri1.Length()+FindUri.Length()+1));

			     puri->Des().Append(',');

			     find = iAddRootNodesList->Find(puri->Des());   

			     CleanupStack::PopAndDestroy();

			     if(find >= 0)

			         {

			         returnstatus = EFalse; 

			         }

			     }

			     if(returnstatus)//not added in this session

			         {			    	 

			         _DBG_FILE("CNSmlDmDDF::AddObjectL()node not added in this session");

                     if(len > 0) //Luid exists,Already existed

                     {

                     iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusAlreadyExists);	 

                     }

                     else

                     {

                     iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusNotFound);

                     }

			         CleanupStack::PopAndDestroy(); //luid

			         return;

			         }

			     }

				}

			iSessionArray[iSessionId-1].UpdateLeafL(iAdapterId,*luid,

				aStatusRef,aURI,aObject,aType,aLargeItem);

			adapterCalled = ETrue;		

			CleanupStack::PopAndDestroy(); //luid

			}

		else

			{

			RProperty::Set(KPSUidNSmlDMSyncAgent, 

						          KNSmlDMCmdAddNodeSuccess, ENotAdded);

			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

			CleanupStack::PushL(luid);			

			CNSmlCallbackElement *newElement 

				= new (ELeave)CNSmlCallbackElement();

			CleanupStack::PushL(newElement);

			newElement->iRef = aStatusRef;

			newElement->iUri = aURI.AllocL();

			iAddNodeStatusRefs.AppendL(newElement);

			CleanupStack::Pop(); //newElement

			iSessionArray[iSessionId-1].AddNodeL(iAdapterId,*luid,aStatusRef,

				aURI);

			//means DM 1.2

			if( !FeatureManager::FeatureSupported( KFeatureIdSyncMlDm112) )

			  {

			  //Check the status of add node, so that update the add buffer

			  TInt NodeAddingSuccess = KErrNotFound;

			  TInt NodeorLeafexists= KErrNotFound;

			  TInt err = RProperty::Get(KPSUidNSmlDMSyncAgent, 

					  KNSmlDMCmdAddNodeSuccess, NodeAddingSuccess);

			  //This key will be set by DM Host Session's setstatus

			  TInt err1 = RProperty::Get( KPSUidNSmlDMSyncAgent, 

					  KNSmlDMCmdAddOnExistingNodeorLeafKey,

					  NodeorLeafexists );				  

			  if( ( err1 == KErrNone && NodeorLeafexists == EAddCmd ) && 

			          (err == KErrNone && (NodeAddingSuccess == EAdded ||

			                  NodeAddingSuccess == ENotAdded) ) )

			      {

			      UpdateAddNodeListL(aURI);

			      }

			  else if(err == KErrNone && NodeAddingSuccess != EFailed )

			      {

			      //Check luid, 

			      HBufC8* newluid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

			      CleanupStack::PushL(newluid);

			      if(newluid->Length() > 0 && newluid->Compare(*luid)==0 ) 

			          {

					  _DBG_FILE("Already existed dont buffer");

			          }

			      else

			          {

			          UpdateAddNodeListL(aURI);

			          }

			      CleanupStack::PopAndDestroy(); //newluid

			      }

			  }

			adapterCalled = ETrue;

			CleanupStack::PopAndDestroy(); //luid

			}

		} //end if(iDbSession.CheckAclL())

	else

		{

		//no acl rights

		status = KNSmlDmStatusPermissionDenied;

		}

	if(!adapterCalled)

		{

		iDmModule.DoSetStatusL(aStatusRef,status);

		}

	_DBG_FILE("CNSmlDmDDF::AddObjectL() : begin");

	}

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

// void CNSmlDmDDF::UpdateObjectL(const TDesC& aURI, const TDesC8& aObject,

//	const TDesC& aType)

// Calls the adapters UpdateObjectL function if the adapter is recognised by

// using URI 

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

void CNSmlDmDDF::UpdateObjectL(const TDesC8& aURI,

	const TDesC8& aObject,

	const TDesC8& aType,

	const TInt aStatusRef,

	TBool aLargeItem,

	// FOTA

	TInt aTotSizeOfLarge

	// FOTA end

	)

	{

	_DBG_FILE("CNSmlDmDDF::UpdateObjectL() : begin");

	TBool adapterCalled = EFalse;

	TInt status = KNSmlDmStatusNotFound;

	if(iAdapterId==0||iSessionId==0)

		{

		//update not allowed in object group level

		//(levels before adapter level) 

		iDmModule.DoSetStatusL(aStatusRef,KNSmlDmStatusCommandNotAllowed);

		return;

		}

	if(iDbSession.CheckDynamicAclL(aURI,EAclReplace,iMgmtTree)) //tarm

		{

		//acl rigths ok

		TNSmlDmDDFFormat format = IsLeafL(aURI);

		if(format==ENSmlDmDDFLeaf)

			{

			HBufC8* luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

			CleanupStack::PushL(luid);

			// FOTA

			iSessionArray[iSessionId-1].UpdateLeafL(iAdapterId,*luid,

				aStatusRef,aURI,aObject,aType,aLargeItem,aTotSizeOfLarge);

			// FOTA end

			adapterCalled = ETrue;

			CleanupStack::PopAndDestroy(); //luid

			}

		else

			{

			status=KNSmlDmStatusCommandNotAllowed;

			}

		} //end if(iDbSession.CheckAclL())

	else

		{

		//no acl rights

		status = KNSmlDmStatusPermissionDenied;

		}

	if(!adapterCalled)

		{

		iDmModule.DoSetStatusL(aStatusRef,status);

		}

	_DBG_FILE("CNSmlDmDDF::UpdateObjectL() : end");

	}

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

// void CNSmlDmDDF::FetchObjectL(const TDesC& aURI, const TDesC& aType,

//	CBufBase& aObject )

// Calls the adapters FetchObjectL function via IPC if the adapter and 

// correct host server are recognised by using URI.

// Adapters ChildURIListL is called, if not leaf object

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

void CNSmlDmDDF::FetchObjectL(const TDesC8& aURI,

	const TDesC8& aType,

	const TInt aResultsRef,

	const TInt aStatusRef,

	TBool aAclPass )

	{

	_DBG_FILE("CNSmlDmDDF::FetchObjectL() : begin");

	TBool adapterCalled = EFalse;

	TInt status = KNSmlDmStatusNotFound;

	if(aAclPass||iDbSession.CheckDynamicAclL(aURI,EAclGet,iMgmtTree)) //tarm

		{

		//acl rights ok or internal query when aclchecking is passed

		HBufC8* luid = NULL;

		if(iAdapterId==0||iSessionId==0)

			{

			//this will response to gets before adapter level

			TInt status = KNSmlDmStatusOK;

			CBufBase* object = CBufFlat::NewL(128);

			CleanupStack::PushL(object);

			CNSmlDmNodeList* final = NULL;

			if(aURI.Length()==0||aURI.Compare(KNSmlDmRootUri)==0)

				{

				//fetch for the root level

				CNSmlDmNodeList* nodeListPtr = iMgmtTree->iNodeListPtr;

				//loop through the fisrt level after root

				while(nodeListPtr!=0)

					{

					object->InsertL(object->Size(),

						nodeListPtr->iNode->iNodeName.iContent,

						nodeListPtr->iNode->iNodeName.iLength);

					if(nodeListPtr->iNext!=0)

						{

						object->InsertL(object->Size(),KNSmlDmLitSeparator8);

						}

					nodeListPtr = nodeListPtr->iNext;

					}

				}

			else

				{

				iMgmtTree->FindNameFromNodeListL(aURI,final);

				if(!final)

					{

					//the node was not found from ddf

					status = KNSmlDmStatusNotFound;

					}

				else

					{

					if(final->iNode)

						{

						CNSmlDmNodeList* nodeListPtr =

							final->iNode->iNodeListPtr;

						//loop the childs of "final" node

						while(nodeListPtr)

							{

							object->InsertL(object->Size(),

								nodeListPtr->iNode->iNodeName.iContent,

								nodeListPtr->iNode->iNodeName.iLength);

							if(nodeListPtr->iNext)

								{

								object->InsertL(object->Size(),

									KNSmlDmLitSeparator8);

								}

							nodeListPtr = nodeListPtr->iNext;

							}

						}

					else

						{

						object->InsertL(0,KNullDesC8);

						}

					}

				}

			iDmModule.DoSetStatusL(aStatusRef,status);

			if(status == KNSmlDmStatusOK)

				{

				CNSmlCallbackElement *newElement =

					new (ELeave)CNSmlCallbackElement();

				CleanupStack::PushL(newElement);

				newElement->iRef = aResultsRef;

				newElement->iUri = aURI.AllocL();

				newElement->iNode = ETrue;

				iResultRefs.AppendL(newElement);

				CleanupStack::Pop(); //newElement

				SetResultsL(aResultsRef,*object,aType,object->Size());

				}

			CleanupStack::PopAndDestroy(); //object

			return;

			} //end if(iAdapterId==0||iSessionId==0)

		luid = iDbSession.GetLuidAllocL(iAdapterId,aURI);

		CleanupStack::PushL(luid);

		CNSmlCallbackElement *newElement = new (ELeave)CNSmlCallbackElement();

		CleanupStack::PushL(newElement);

		newElement->iRef = aResultsRef;

		newElement->iUri = 0;

		//mapping info found for the uri

		TNSmlDmDDFFormat format = IsLeafL(aURI);

		if(format==ENSmlDmDDFLeaf)

			{

			newElement->iUri = aURI.AllocL();

			newElement->iNode = EFalse;

			iResultRefs.AppendL(newElement);

			CleanupStack::Pop(); //newElement

			iSessionArray[iSessionId-1].FetchLeafObjectL(iAdapterId,

				aURI,*luid,aType,aResultsRef,aStatusRef);

			adapterCalled = ETrue;

			}

		else if(format==ENSmlDmDDFNode)