/*

* 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 "xorcompositeassertion.h"

#include "andcompositeassertion.h"

#include "primitiveassertion.h"

#include "policyassertion.h"

CXorCompositeAssertion* CXorCompositeAssertion::NewL()

{

    CXorCompositeAssertion* pSelf = CXorCompositeAssertion::NewLC();

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CXorCompositeAssertion* CXorCompositeAssertion::NewLC()

{

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

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;

}

CXorCompositeAssertion* CXorCompositeAssertion::NewL(CXorCompositeAssertion* aValue)

{

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

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CXorCompositeAssertion* CXorCompositeAssertion::NewLC(CXorCompositeAssertion* aValue)

{

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

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL(aValue);

    return pSelf;

}

CXorCompositeAssertion::~CXorCompositeAssertion()

{

}

CXorCompositeAssertion::CXorCompositeAssertion()

{

}

void CXorCompositeAssertion::ConstructL(CXorCompositeAssertion* aValue)

{

    ConstructL();

    RPolicyTerms terms = aValue->GetTerms();

    if(terms.Count() > 0)

        AddTermsCopyL(terms);

//    terms.Close();

}

void CXorCompositeAssertion::ConstructL()

{

}

//from CAssertion

TAssertionType CXorCompositeAssertion::Type()

{

  return ECompositeXorType;    

}

void CXorCompositeAssertion::AddTerm(MAssertion* aAssertion)

{

	if ( IsNormalized() 

	    && (aAssertion->Type() == ECompositeAndType) 

	    && (aAssertion->IsNormalized()

	    ))

	{

			SetNormalized(EFalse);

	}

	CAssertion::AddTerm(aAssertion);

}

void CXorCompositeAssertion::AddTermCopyL(MAssertion* aAssertion)

{

	if ( IsNormalized() 

	    && (aAssertion->Type() == ECompositeAndType) 

	    && (aAssertion->IsNormalized()

	    ))

	{

			SetNormalized(EFalse);

	}

	CAssertion::AddTermCopyL(aAssertion);

}

MAssertion*	CXorCompositeAssertion::NormalizeL(CPolicyRegistry* aRegistry)

{

	if (IsNormalized()) {

			return this;

		}

		CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();

		if (IsEmpty()) {

			XOR->SetNormalized(true);

			return XOR;

		}

		RPointerArray<MAssertion> terms1 = GetTerms();

        TInt termCount = terms1.Count();

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

        {

			MAssertion* term = terms1[i];

			MAssertion* result = term;

			if(!dynamic_cast<CPolicyAssertion*>(term))

			{

			    result = term->NormalizeL(aRegistry);

			}

			if (dynamic_cast<CPolicyAssertion*>(result))

			{

				CAndCompositeAssertion* wrapper = CAndCompositeAssertion::NewL();

				RPolicyTerms termsPol1 = result->GetTerms();

				wrapper->AddTermsCopyL(termsPol1);

    			if(result != term)

    			{

                    CPolicyAssertion* eleToDel = (CPolicyAssertion*)result;

                    delete eleToDel;

    			}

				result = NULL;

				result = wrapper->NormalizeL(aRegistry);

				delete wrapper;

				if (dynamic_cast<CAndCompositeAssertion*>(result))

				{

					XOR->AddTerm(result);

				}

				else

				{

				    RPolicyTerms termsPol2 = result->GetTerms();

					XOR->AddTermsCopyL(termsPol2);

					CPolicyAssertion* eleToDel = (CPolicyAssertion*)result;

					delete eleToDel;

//					termsPol2.Close();

				}

				continue;

			}

            if (dynamic_cast<CPrimitiveAssertion*>(result)) 

			{

				CAndCompositeAssertion* wrapper = CAndCompositeAssertion::NewL();

				wrapper->AddTermCopyL(result);

				XOR->AddTerm(wrapper);

				CPrimitiveAssertion* eleToDel = (CPrimitiveAssertion*)result;

				delete eleToDel;

				result = NULL;

				continue;

			}

			if (dynamic_cast<CXorCompositeAssertion*>(result)) 

			{

			    RPolicyTerms termsPol3 = result->GetTerms();

				XOR->AddTermsCopyL(termsPol3);

				CXorCompositeAssertion* eleToDel = (CXorCompositeAssertion*)result;				

                delete eleToDel;				

				continue;

			}

			if (dynamic_cast<CAndCompositeAssertion*>(result)) 

			{

				XOR->AddTerm(result);

			}

		}

//        terms1.Close();

		XOR->SetNormalized(ETrue);

		return XOR;    

}

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

{

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

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

    {

    	return normalizedMe->IntersectL(aAssertion, aRegistry);

    }

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

    short type = target->Type();

    RPolicyTerms terms = normalizedMe->GetTerms();

    switch (type) {

    case ECompositePolicyType: {

    	CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();

        CXorCompositeAssertion* term = (CXorCompositeAssertion*)terms[0];

    	nPOLICY->AddTerm(term->IntersectL(target, NULL));

    	return nPOLICY;

    }

    case ECompositeXorType: {

    	CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

    	MAssertion* asser = NULL;

    	CAndCompositeAssertion* AND;

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

    	{

    		AND = (CAndCompositeAssertion*)terms[i];

            RPolicyTerms tgtTerms = target->GetTerms();

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

    		{

    		    asser = NULL;

    			asser = AND->IntersectL((CAndCompositeAssertion*)tgtTerms[j], NULL);

    			if (dynamic_cast<CAndCompositeAssertion*>(asser)) 

    			{

    				nXOR->AddTerm(asser);

    			}

    			else

    			{

    			    DeleteAssertion(asser);

    			}

    		}

    	}

    	return nXOR;

    }

    case ECompositeAndType: {

    	CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

    	MAssertion* asser;

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

    	{

    		asser = ((CAndCompositeAssertion*) terms[i])->IntersectL(target, NULL);

    		if (dynamic_cast<CAndCompositeAssertion*>(asser)) 

    		{

    			nXOR->AddTerm(asser);

    		}

            else

            {

                DeleteAssertion(asser);

            }

    	}

    	return nXOR;

    }

    case EPrimitiveType: {

    	CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

    	MAssertion* asser;

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

    	{

    		asser = ((CAndCompositeAssertion*)terms[i])->IntersectL(target, NULL);

    		if (dynamic_cast<CAndCompositeAssertion*>(asser)) 

    		{

    			nXOR->AddTerm(asser);

    		}

            else

            {

                DeleteAssertion(asser);

            }

    	}

    	return nXOR;

    }

    default: {

    }

    }

return NULL;    

}

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

{

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

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

	{

		return normalizedMe->MergeL(aAssertion, aRegistry);

	}

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

	short type = target->Type();

	switch (type) 

	{

    	case ECompositePolicyType: 

    	{

    		CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();

    		nPOLICY->AddTerm(normalizedMe->MergeL(target->GetTerms()[0]));

    		return nPOLICY;

    	}

    	case ECompositeXorType: 

    	{

    		CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

            RPolicyTerms xTerms = normalizedMe->GetTerms();

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

    		{

    			CAndCompositeAssertion* AND = (CAndCompositeAssertion*) xTerms[i];

                RPolicyTerms targetTerms = target->GetTerms();

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

    			{

                    MAssertion* tgtTerm = targetTerms[j];

    				nXOR->AddTerm(AND->MergeL(tgtTerm, NULL)); 

    			}

    			if (target->IsEmpty() && AND->IsEmpty()) { 

    				/*

    				 * " <wsp:ExactlyOne> <wsp:All/>

    				 * </wsp:ExactlyOne>".intersect(" <wsp:ExactlyOne/>")

    				 */

    				nXOR->AddTermCopyL(AND);

    			}

    		}

    		return nXOR;

    	}

    	case ECompositeAndType: 

    	{

    		CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

            RPolicyTerms xTerms = normalizedMe->GetTerms();

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

    		{

    			CAndCompositeAssertion* term = (CAndCompositeAssertion*)xTerms[i];

    			nXOR->AddTerm(term->MergeL(target, NULL)); 

    		}

    		return nXOR;

    	}

    	case EPrimitiveType: 

    	{

    		CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();

            RPolicyTerms xTerms = normalizedMe->GetTerms();

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

    		{

    		    CAndCompositeAssertion*  tgtTerm =  (CAndCompositeAssertion*)xTerms[i];

    		    nXOR->AddTerm(tgtTerm->MergeL(target, NULL)); 

    		}

    		return nXOR;

    	}

    	default: 

    	{

    	}

	}

return NULL;	    

}