/*

* Copyright (c) 2000 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: Implementation of policymanagement components

*

*/

// INCLUDES

#include "ElementBase.h"

#include "PolicyStorage.h"

#include "PolicyParser.h"

#include "XACMLconstants.h"

#include "elements.h"

#include "ErrorCodes.h"

#include "debug.h"

#include "PolicyEngineServer.h"

#include <e32std.h>

// CONSTANTS

// MACROS

// DATA TYPES

// FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// CLASS DECLARATION

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

// ElementHelper namespace contains utility functions for element handling

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

namespace ElementHelper

{

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

	// ElementHelper::DecodeEmptyElement 

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

	HBufC8 * DecodeEmptyElement( const TDesC8& aElementName)

	{

		//needed extra space in description

		const TInt KExtraSpace = 4;

		//create cbuf (return value)

		HBufC8 * hbuf = HBufC8::NewL( aElementName.Length() + KExtraSpace);

		TPtr8 ptr = hbuf->Des();

		//append empty element format

		ptr.Append('<');

		ptr.Append( aElementName);

		ptr.Append(_L(" />"));

		return hbuf;		

	}

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

	// ElementHelper::CreateNewElementL Create new element, element type is identified by aElementId

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

	CElementBase * CreateNewElementL( const TUint32& aElementId)

	{

		//decode element type

		TInt type = aElementId & 0xff;

		CElementBase * element = 0;

		//create empty element

		switch ( type)

		{

			case EPolicySet:

				element = CPolicySet::NewL();

				break;

			case EPolicy:

				element = CPolicy::NewL();

				break;

			case ETarget:

				element = CTarget::NewL();

				break;

			case ERule:	

				element = CRule::NewL();

				break;

			case ESubjects:

				element = CSubjects::NewL();

				break;

			case ESubject:

				element = CSubject::NewL();

				break;

			case ESubjectAttributeDesignator:

				element = CSubjectAttributeDesignator::NewL();

				break;

			case ESubjectMatch:

				element = CMatchObject::NewL( ESubjectMatch);

			break;

			case EActions:

				element = CActions::NewL();

				break;

			case EAction:

				element = CAction::NewL();

				break;

			case EActionAttributeDesignator:

				element = CActionAttributeDesignator::NewL();

				break;

			case EActionMatch:

				element = CMatchObject::NewL( EActionMatch);

			break;

			case EResources:

				element = CResources::NewL();

				break;

			case EResource:

				element = CResource::NewL();

				break;

			case EResourceAttributeDesignator:

				element = CResourceAttributeDesignator::NewL();

				break;

			case EResourceMatch:

				element = CMatchObject::NewL( EResourceMatch);

			break;

			case EEnvironments:

				element = CEnvironment::NewL();

				break;

			case EEnvironment:

				element = CEnvironment::NewL();

				break;

			case EEnvironmentAttributeDesignator:

				element = CEnvironmentAttributeDesignator::NewL();

				break;

			case EEnvironmentMatch:

				element = CMatchObject::NewL( EEnvironmentMatch);

			break;

			case EDescription:

				element = CDescription::NewL();

			break;

			case ECondition:

				element = CCondition::NewL();

				break;

			case EApply:

				element = CApply::NewL();

				break;

			default:

				User::Panic(PolicyExecutionPanic, KErrCorrupt);	

			break;

		}

		//set id and storage reference

		element->SetId( aElementId);

		return element;

	}

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

	// ElementHelper::CompareElements Compare function for RArray 

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

	TInt CompareElements( CElementBase* const& aElement1, CElementBase* const& aElement2)

	{

		if ( aElement1->GetId() == aElement2->GetId()) return 0;

		return ( aElement1->GetId() < aElement2->GetId() ? -1 : 1 );

	}

}

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

// CElementBase::CElementBase()

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

//

CElementBase::CElementBase()

	: iElementState( ENewElement), iSaveType( EOwnElement), 

	  iCreateExternalId( EFalse), iExternalId( NULL), iParentId( 0), iElementId( 0), 

	  iReferenceCount( KNotInElementCache)

{

}

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

// CElementBase::CElementBase()

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

//

CElementBase::CElementBase( const TUint32& aElementId )

	: iElementState( ENotLoaded), iSaveType( EOwnElement), iCreateExternalId( EFalse), iExternalId( NULL), iParentId( 0), 

	  iElementId( aElementId), iReferenceCount( KNotInElementCache)

{

}

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

// CElementBase::~CElementBase()

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

//

CElementBase::~CElementBase()

{

	//delete all containers in the element list

	for (TInt i(0); i < iElements.Count(); i++)

	{

		TElementContainer * container = iElements[i];

		//delete element only when it isn't in policy storage

		if ( container->iDeleteWithElement)

		{

			delete container->iElement;

		}

		//allways delete container

		delete container;

	}

	iElements.Close();

}

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

// CElementBase::ElementType()

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

//

TNativeElementTypes CElementBase::ElementType()

{

	return iElementType;

}

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

// CElementBase::ElementType()

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

//

TNativeElementTypes CElementBase::SubElementType( const TInt& aIndex, const TInt& aExpectedCount)

{

	//check that aIndex is valid

	if ( aIndex >= iElements.Count())

	{

		return (TNativeElementTypes)KErrNotFound;

	}

	//Check also expected count if parameter is given (positive)

	if ( aExpectedCount >= 0 && aExpectedCount != iElements.Count())

	{

		return (TNativeElementTypes)KErrNotFound;

	}

	//return type of element

	return iElements[ aIndex]->iElement->ElementType();

}

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

// CElementBase::SetId()

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

//

void CElementBase::SetId( const TUint32& aElementId)

{

	iElementId = aElementId;	

}

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

// CElementBase::CreateId()

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

//

void CElementBase::CreateIdL()

{

	//if element doesn't have id, get new id from policy storage

	if ( iElementId == 0)

	{

		iElementId = CPolicyStorage::PolicyStorage()->CreateIdL( iElementType);

	}

	//create ids also for child elements

/*	for ( TInt i(0); i < iElements.Count(); i++)

	{

		TElementContainer * container = iElements[i];

		container->iElement->CreateIds( aPolicyStorage);

	}*/

}

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

// CElementBase::GetId()

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

//

TUint32 CElementBase::GetId() const 

{

	return iElementId;

}

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

// CElementBase::AddParentIdL()

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

//

void CElementBase::AddParentIdL( TUint32 iMotherId)

{

	//parent id is saved only for rules, policysets and policies

	if ( iElementType == ERule || iElementType == EPolicySet || iElementType == EPolicy )

	{

/*		//create new parant element list if list doesn't exist

		if ( !iParentElements )

		{

			iParentElements	= new (ELeave) RIdList;

		}

		//add parent to list

		iParentElements->AppendL( iMotherId);

*/

		iParentId = iMotherId;

	}

}

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

// CElementBase::CheckNewParentId()

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

//

/*

TBool CElementBase::CheckNewParentId( TUint32 iMotherId)

{

	if (!iParentElements)

	{

		return ETrue;

	}

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

	{

		if ( (*iParentElements)[i] == iMotherId)

		{

			return EFalse;

		}

	}

	return ETrue;	

}*/

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

// CElementBase::DeleteElementL()

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

//

void CElementBase::DeleteElementL()

{

	__ASSERT_ALWAYS ( iElementId || iSaveType == ESubElement, User::Panic(PolicyStoragePanic, KErrGeneral));

	//if element is subelement which is saved part of parent element

	if ( iSaveType == ESubElement) return;

	//remove element

	CPolicyStorage::PolicyStorage()->DeleteElementL( iElementId);	

}

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

// CElementBase::DeleteMarkRecursiveL()

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

//

void CElementBase::DeleteMarkRecursiveL()

{

	iElementState = EDeletedEditableElement;

	for ( TInt i(0); i < iElements.Count(); i++)

	{

		//get element from list, add parent and save it

		CElementBase * element = iElements[i]->iElement;

		//check and load element (to editable cache)

		TElementReserver reserver( element);

		CPolicyStorage::PolicyStorage()->CheckElementL( element);	

		element->DeleteMarkRecursiveL();

		reserver.Release();

	}

}

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

// CElementBase::RemoveChild()

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

//

TInt CElementBase::RemoveChild( const TUint32& aChildId)

{

	TInt err = KErrNotFound;

	//delete also child elements

	for ( TInt i(0); i < iElements.Count(); i++)

	{

		//get element from list, add parent and save it

		TElementContainer * container = iElements[i];

		__ASSERT_ALWAYS ( container, User::Panic(PolicyStoragePanic, KErrGeneral));

		if ( container->iElement->iElementId == aChildId)

		{

			//delete container and remove it from child list

			delete iElements[i];

			iElements.Remove( i);

			err = KErrNone;

			break;

		}

	}		

	return err;

}

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

// CElementBase::CreateExternalId()

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

//

void CElementBase::CreateExternalId()

{

	iCreateExternalId = ETrue;

}

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

// CElementBase::SaveElementL()

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

//

TInt CElementBase::SaveElementL( TBool aRecursive)

{

	//check id

	if ( (iElementId == 0 && iSaveType == EOwnElement )|| iCreateExternalId)

	{

		if ( iElementId == 0)

		{

			iElementId = CPolicyStorage::PolicyStorage()->CreateIdL( iElementType);

		}

	}

	//if aResursive, make recursive save also for childs

	if ( aRecursive )

	{

		for ( TInt i(0); i < iElements.Count(); i++)

		{

			//get element from list, add parent and save it

			TElementContainer * container = iElements[i];

			if ( iSaveType == EOwnElement)

			{

				container->iElement->AddParentIdL( GetId());

			}

			container->iElement->SaveElementL( ETrue);

		}

	}

	TInt err(KErrNone);

	//Save element, if element is subelement it is already saved by parent element

	if ( iSaveType == EOwnElement)

	{

		//decode element, use id mode where only child id is saved to description

		HBufC8 * description = DecodeElementL( ENative, EIdMode);

		CleanupStack::PushL( description);

		//id parent element is defined

		if ( iParentId )

		{

			//create buffer for parent mapping

			HBufC8 * temp = HBufC8::NewL( description->Length() + (KIdLength + 1));		

			TPtr8 ptr = temp->Des();

			//add original description

			ptr.Append( *description);

			//and parent mapping

			ptr.Append( KParentListStartMark);

			ptr.AppendNum( iParentId);

			//delete old description and push old in cleanup stack

			CleanupStack::PopAndDestroy( description);			//old description

			CleanupStack::PushL( temp);

			description = temp;

		}

		//write policy to database

		CPolicyStorage::PolicyStorage()->SaveElementL( iElementId, description);

		CleanupStack::PopAndDestroy( description);

	}

	return err;

}

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

// CElementBase::SelectCorrectValue()

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

//

const TDesC8& CElementBase::SelectCorrectValue( const TLanguageSelector &aLanguage, const TDesC8& aOriginalValue ) const

{

	if ( aLanguage == ENative )

	{

		return aOriginalValue;

	}

	return CPolicyParser::ConvertValues( ENative, aOriginalValue);

}

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

// CElementBase::DecodeElementOrIdL()

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

//

HBufC8 * CElementBase::DecodeElementOrIdL( const TLanguageSelector &aLanguage, CElementBase * aElement, const TDecodeMode &aMode)

{		

	HBufC8 * buffer = NULL;

	//if full mode, decode full element. In id mode only id list is decoded

	if ( aMode == EFullMode)

	{

		buffer = aElement->DecodeElementL( aLanguage, EFullMode);

	}

	else 

	{

		if ( aElement->iSaveType == ESubElement )

		{