/*

* Copyright (c) 2009 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:      

*

*/

#include "primitiveassertion.h"

#include "policyassertion.h"

#include "xorcompositeassertion.h"

#include "andcompositeassertion.h"

#include "wspolicyreader.h"

#include "wspolicyutils.h"

using namespace WSPolicy;

CPrimitiveAssertion* CPrimitiveAssertion::NewL()

{

    CPrimitiveAssertion* pSelf = CPrimitiveAssertion::NewLC();

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CPrimitiveAssertion* CPrimitiveAssertion::NewLC()

{

     CPrimitiveAssertion* pSelf = new (ELeave) CPrimitiveAssertion();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;

}

CPrimitiveAssertion* CPrimitiveAssertion::NewL(CPrimitiveAssertion* aValue)

{

    CPrimitiveAssertion* pSelf = CPrimitiveAssertion::NewLC(aValue);

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CPrimitiveAssertion* CPrimitiveAssertion::NewLC(CPrimitiveAssertion* aValue)

{

    CPrimitiveAssertion* pSelf = new (ELeave) CPrimitiveAssertion();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aValue);

    return pSelf;

}

CPrimitiveAssertion* CPrimitiveAssertion::NewL(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)

{

    CPrimitiveAssertion* pSelf = CPrimitiveAssertion::NewLC(aName,aPrefix, aUri);

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CPrimitiveAssertion* CPrimitiveAssertion::NewLC(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)

{

     CPrimitiveAssertion* pSelf = new (ELeave) CPrimitiveAssertion();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aName, aPrefix, aUri);

    return pSelf;

}

CPrimitiveAssertion::~CPrimitiveAssertion()

    {

    delete iQname;//	QName qname;

    if(iAttr != NULL)

    	{

        iAttr->Reset(); //Hashtable attributes = new Hashtable();

        delete iAttr;

    	}

	delete iStrValue;

    }

CPrimitiveAssertion::CPrimitiveAssertion():

iOwner(NULL), iIsOptional(EFalse),iStrValue(NULL)

{

}

void CPrimitiveAssertion::ConstructL()

{

    iAttr = new (ELeave) RAttributeMap(ETrue, ETrue);    

}

void CPrimitiveAssertion::ConstructL(CPrimitiveAssertion* aValue)

{

    CQName* temp = aValue->QName();

    if(temp)

    {

        TPtrC8 name = temp->Name();

        TPtrC8 prefix = temp->Prefix();

        TPtrC8 uri = temp->Uri();

        ConstructL(name, prefix,uri);

        SetAttributesL(aValue->Attributes());

        TPtrC8 strval = aValue->StrValue();

        iStrValue = strval.AllocL();

        RPolicyTerms terms = aValue->GetTerms();

        if(terms.Count() > 0)

            AddTermsCopyL(terms);

    }

}

void CPrimitiveAssertion::ConstructL(TDesC8& aName, TDesC8& aPrefix, TDesC8& aUri)

{

    iQname = CQName::NewL(aName, aPrefix, aUri);

    ConstructL();

}

MAssertion*	CPrimitiveAssertion::GetParent()

{

    return iOwner;   

}

RPolicyTerms& CPrimitiveAssertion::GetTerms()

{  

    return CAssertion::GetTerms();

}

TAssertionType CPrimitiveAssertion::Type()

{

  return EPrimitiveType;    

}

TBool CPrimitiveAssertion::HasParent()

{

    if(iOwner)    

    return ETrue;

    else

    return EFalse;

}

TBool CPrimitiveAssertion::IsEmpty()

{

    if(Size() > 0)

        return EFalse;

    else

        return ETrue;

}

void AppendAll(RPolicyTerms& aSource, RPolicyTerms& aDest)

{

    TInt count = aSource.Count();

    if(count > 0)

    {

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

        {

            MAssertion* term = aSource[i];

            aDest.Append(term);

        }

    }

}

MAssertion* CPrimitiveAssertion::NormalizeL()

{

    return NormalizeL(NULL);

}

MAssertion* CPrimitiveAssertion::NormalizeL(CPolicyRegistry* aRegistry)

{

    if (IsNormalized()) 

    {

    	return this;

    }

    if (IsOptional()) 

    {

    	CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();

    	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();

    	CPrimitiveAssertion* PRIM = GetSelfWithoutTermsL();

    	PRIM->RemoveAttribute(KWspOptinal);

    	PRIM->SetOptional(false);

    	RPolicyTerms terms1 = GetTerms();

    	PRIM->SetTermsL(terms1);

    	AND->AddTerm(PRIM);

    	XOR->AddTerm(AND);

    	XOR->AddTerm(CAndCompositeAssertion::NewL());

        MAssertion* result = XOR->NormalizeL(aRegistry);

        delete XOR;

    	return result;

    }

    RPolicyTerms terms2 = GetTerms();

    if (terms2.Count() == 0) 

    {

    	CPrimitiveAssertion* PRIM = GetSelfWithoutTermsL();

    	PRIM->SetNormalized(true);

    	return PRIM;

    }

    RPolicyTerms policyTerms;

    RPolicyTerms nonPolicyTerms;

    for(TInt i =0 ; i < terms2.Count(); i++) 

    {

    	MAssertion* term = terms2[i];

    	if (dynamic_cast<CPolicyAssertion*>(term)) 

    	{

    		policyTerms.Append(term);

    	} 

    	else if (dynamic_cast<CPrimitiveAssertion*>(term)) 

    	{

    		nonPolicyTerms.Append(term);

    	} 

    	else 

    	{

    	}

    }

    if (policyTerms.Count() == 0) {

    	CPrimitiveAssertion* PRIM = CPrimitiveAssertion::NewL(this);

    	PRIM->SetNormalized(true);

        policyTerms.Close();

        nonPolicyTerms.Close();

    	return PRIM;

    }

    CPolicyAssertion* policyTerm = CWSPolicyUtils::GetSinglePolicyL(policyTerms, aRegistry);

    RPolicyTerms polTerms = policyTerm->GetTerms();

    if(polTerms.Count() > 0)

    {

        MAssertion* xorTerm = polTerms[0];

        RPolicyTerms ANDs = xorTerm->GetTerms();

        if (ANDs.Count() == 0) 

        {

            delete policyTerm;

            policyTerms.Close();

            nonPolicyTerms.Close();

        	return CXorCompositeAssertion::NewL();

        }

        if (ANDs.Count() == 1) 

        {

        //DONE

            CAndCompositeAssertion* term = (CAndCompositeAssertion*) ANDs[0];

        	term->AddTermsCopyL(nonPolicyTerms);

        	CPrimitiveAssertion* PRIM = GetSelfWithoutTermsL();

        	PRIM->AddTerm(policyTerm);

            policyTerms.Close();

            nonPolicyTerms.Close();

        	return PRIM;

        }

        CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();

        CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

        nPOLICY->AddTerm(nXOR);

        RPolicyTerms list;

        for (TInt j = 0; j < ANDs.Count(); j++) 

        {

        	CPrimitiveAssertion* nPRIM = GetSelfWithoutTermsL();

            CAndCompositeAssertion* andTerm = (CAndCompositeAssertion*)ANDs[j];

            RPolicyTerms terms3 = andTerm->GetTerms();

        	AppendAll(terms3, list);

        	if (nonPolicyTerms.Count() > 0) 

        	{

        		AppendAll(nonPolicyTerms, list);

        	}

        	CPolicyAssertion* pol = GetSinglePolicyL(list);

        	nPRIM->AddTerm(pol);

        	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();

        	AND->AddTerm(nPRIM);

        	nXOR->AddTerm(AND);

        	list.Close();

        }

    	delete policyTerm;

        policyTerms.Close();

        nonPolicyTerms.Close();

        nPOLICY->SetNormalized(ETrue);

        return nPOLICY;    

    }

    return NULL;    

}

MAssertion* CPrimitiveAssertion::IntersectL(MAssertion* aAssertion)

{

    return IntersectL(aAssertion, NULL); 

}

MAssertion* CPrimitiveAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)

{

	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);

	if (!(dynamic_cast<CPrimitiveAssertion*>(normalizedMe))) 

	{

		return normalizedMe->IntersectL(aAssertion, aRegistry);

	}

	MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);

	// Am not a primitive assertion anymore ..

	if (!(dynamic_cast<CPrimitiveAssertion*>(aAssertion))) 

	{

		return normalizedMe->IntersectL(aAssertion, aRegistry);

	}

	// argument is not primitive type ..

	if (!(dynamic_cast<CPrimitiveAssertion*>(target))) 

	{

		return target->IntersectL(normalizedMe, aRegistry);

	}

	CPrimitiveAssertion* arg = (CPrimitiveAssertion*) target;

	CPrimitiveAssertion* self = (CPrimitiveAssertion*) normalizedMe;

	if (!self->Name().Compare(arg->Name()) == 0) 

	{

		return CXorCompositeAssertion::NewL(); // no bahaviour is admisible

	}

	if (self->GetTerms().Count() == 0 && arg->GetTerms().Count() == 0) 

	{

		CAndCompositeAssertion* assertion2 = CAndCompositeAssertion::NewL();

		assertion2->AddTermCopyL(self);

		assertion2->AddTermCopyL(arg);

		return assertion2;

	}

	if (self->GetTerms().Count() == 0 || arg->GetTerms().Count() == 0) 

	{

		return CXorCompositeAssertion::NewL(); // no

	}

	RPolicyTerms argChildTerms;

	TBool closeArrayarg = EFalse;

	if (dynamic_cast<CPolicyAssertion*>(arg->GetTerms()[0])) 

	{

		CWSPolicyUtils::GetPrimTermsListL((CPolicyAssertion*) arg->GetTerms()[0], argChildTerms);

		closeArrayarg = ETrue;

	}

	else 

	{

		argChildTerms = arg->GetTerms();

	}

	RPolicyTerms selfChildTerms;

	TBool closeArrayself = EFalse;

	if (dynamic_cast<CPolicyAssertion*>(self->GetTerms()[0])) 

	{

		CWSPolicyUtils::GetPrimTermsListL((CPolicyAssertion*) self->GetTerms()[0], selfChildTerms);

		closeArrayself = ETrue;

	} 

	else 

	{

		selfChildTerms = self->GetTerms();

	}

	///////////////////////////////////////////////////////////////////////

	///////////////////////////////////////////////////////////////////////

	CPrimitiveAssertion* PRIMITIVE_A = NULL;

	CPrimitiveAssertion* PRIMITIVE_B = NULL;

	RPolicyTerms primListA, primListB;

	if (selfChildTerms.Count() > argChildTerms.Count()) {

		primListA = selfChildTerms;

		primListB = argChildTerms;

	} else {

		primListA = argChildTerms;

		primListB = selfChildTerms;

	}

    for (TInt i = 0 ; i < primListA.Count(); i++)

    {

		PRIMITIVE_A = (CPrimitiveAssertion*) primListA[i];

		TBool found = EFalse;

        for (TInt j = 0 ; j < primListB.Count(); j++)

        {

			PRIMITIVE_B = (CPrimitiveAssertion*) primListB[j];

			if (PRIMITIVE_A->Name().Compare(PRIMITIVE_B->Name()) == 0)

			{

				found = ETrue;

				break;

			}

		}

		if (!found) 

		{

		    if(closeArrayarg)

		        argChildTerms.Close();

		    if(closeArrayself)

		        selfChildTerms.Close();

			return CXorCompositeAssertion::NewL();

		}

        MAssertion* assert = PRIMITIVE_A->IntersectL(PRIMITIVE_B);

		if (dynamic_cast<CXorCompositeAssertion*>(assert)) 

		{

		    if(closeArrayarg)

		        argChildTerms.Close();

		    if(closeArrayself)

		        selfChildTerms.Close();

		    DeleteAssertion(assert);

			return CXorCompositeAssertion::NewL();

		}

		else

		{

		    DeleteAssertion(assert);

		}

	}

	CAndCompositeAssertion* andCompositeAssertion = CAndCompositeAssertion::NewL();

	andCompositeAssertion->AddTermCopyL(arg);

	andCompositeAssertion->AddTermCopyL(self);

		    if(closeArrayarg)

		        argChildTerms.Close();

		    if(closeArrayself)

		        selfChildTerms.Close();

	return andCompositeAssertion;

}

MAssertion* CPrimitiveAssertion::MergeL(MAssertion* aAssertion)

{

    return MergeL(aAssertion, NULL);

}

MAssertion* CPrimitiveAssertion::MergeL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)

{

	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);

	if (!(dynamic_cast<CPrimitiveAssertion*>(normalizedMe))) 

	{

		return normalizedMe->MergeL(aAssertion, aRegistry);

	}

	MAssertion* target = (aAssertion->IsNormalized()) ? aAssertion : aAssertion->NormalizeL(aRegistry);

	if (!(dynamic_cast<CPrimitiveAssertion*>(target))) 

	{

		return target->MergeL(normalizedMe, aRegistry);

	}

	/*

	 * both self and the argument are primitive assertions. Hence both

	 * should be wrapped in an AndCompositeType

	 */

	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();

	AND->AddTermCopyL(target);

	AND->AddTermCopyL(normalizedMe);

	return AND;

}

TBool CPrimitiveAssertion::Remove(MAssertion* aAssertion)

{

    if(aAssertion)

    {

        CAssertion::Remove(aAssertion);

    }

    return ETrue;

}

TInt CPrimitiveAssertion::Size()

{

    return CAssertion::Size();

}

TInt CPrimitiveAssertion::SetTermsL(RPolicyTerms& aTerms)

{

		this->AddTermsCopyL(aTerms);

		return KErrNone;    

}

void  CPrimitiveAssertion::AddAttributeL(TDesC8& aQname, TDesC8& aValue)

{

    TInt indx = iAttr->Find(aQname);

    if(indx == KErrNotFound)

    {

        iAttr->Append(aQname.AllocL(),aValue.AllocL());        

    }

    else

    {

        iAttr->UpdateValue(aQname.AllocL(),aValue.AllocL());    

    }

}

TPtrC8 CPrimitiveAssertion::GetAttributeValue(const TDesC8& aQname)

{

    TInt indx = iAttr->Find(aQname);

    if(indx != KErrNotFound)

    {

        const TDesC8* value =  iAttr->ValueAt(indx);

        return *value; //->Ptr();

    }

    return KNullDesC8();

}

RAttributeMap& CPrimitiveAssertion::Attributes()

{

//    aAttributes.Copy(iAttr);

return *iAttr;

}

TInt CPrimitiveAssertion::SetAttributesL(RAttributeMap& aAttributes)

{

 TInt count = aAttributes.Count();

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

 {

    const TDesC8* name = aAttributes.KeyAt(i);

    const TDesC8* value = aAttributes.ValueAt(i);

    HBufC8* tt = name->AllocL();

    HBufC8* tt2 = value->AllocL();

    TPtrC8 namePtr = tt->Des();

    TPtrC8 valPtr = tt2->Des();

    AddAttributeL(namePtr, valPtr);

    delete tt;