/*
* 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 "andcompositeassertion.h"
#include "xorcompositeassertion.h"
#include "primitiveassertion.h"
#include "policyassertion.h"

CAndCompositeAssertion* CAndCompositeAssertion::NewL()
{
    CAndCompositeAssertion* pSelf = CAndCompositeAssertion::NewLC();
    CleanupStack::Pop(pSelf);
    return pSelf;
   
}
CAndCompositeAssertion* CAndCompositeAssertion::NewLC()
{
    CAndCompositeAssertion* pSelf = new (ELeave) CAndCompositeAssertion();
    CleanupStack::PushL(pSelf);
    pSelf->ConstructL();
    return pSelf;
 
}
CAndCompositeAssertion* CAndCompositeAssertion::NewL(CAndCompositeAssertion* aValue)
{
    CAndCompositeAssertion* pSelf = CAndCompositeAssertion::NewLC(aValue);
    CleanupStack::Pop(pSelf);
    return pSelf;
    
}
CAndCompositeAssertion* CAndCompositeAssertion::NewLC(CAndCompositeAssertion* aValue)
{
    CAndCompositeAssertion* pSelf = new (ELeave) CAndCompositeAssertion();
    CleanupStack::PushL(pSelf);
    pSelf->ConstructL(aValue);
    return pSelf;
    
}

CAndCompositeAssertion::~CAndCompositeAssertion()
{
    
}
CAndCompositeAssertion::CAndCompositeAssertion()
{
    
}
void CAndCompositeAssertion::ConstructL()
{
    
} 
void CAndCompositeAssertion::ConstructL(CAndCompositeAssertion* aValue)
{
    ConstructL();

    RPolicyTerms terms = aValue->GetTerms();
    
    if(terms.Count() > 0)
        AddTermsCopyL(terms);
    
 //   terms.Close();    
}

TAssertionType CAndCompositeAssertion::Type()
{
  return ECompositeAndType;  
}
void  CAndCompositeAssertion::AddTerm(MAssertion* aAssertion)
{
	if ((IsNormalized() && (aAssertion->Type() == EPrimitiveType))) 
	{
			SetNormalized(EFalse);
	}
	
	CAssertion::AddTerm(aAssertion);    
}
void CAndCompositeAssertion::AddTermCopyL(MAssertion* aAssertion)
{
 	if ((IsNormalized() && (aAssertion->Type() == EPrimitiveType))) 
	{
			SetNormalized(EFalse);
	}
	
	CAssertion::AddTermCopyL(aAssertion);    
}
MAssertion*	CAndCompositeAssertion::NormalizeL(CPolicyRegistry* aRegistry){

	if (IsNormalized()) 
	{
		return this;
	}

	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();

	if (IsEmpty()) 
	{
		AND->SetNormalized(ETrue);
		return AND;
	}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
	RPolicyTerms XORs;

	RPointerArray<MAssertion> terms1 = GetTerms();
	MAssertion* term = NULL;
    TInt termCount = terms1.Count();

    for (TInt i = 0; i< termCount; i++)
    {
        
		term = terms1[i];
		MAssertion* result = term;
		if(!dynamic_cast<CPolicyAssertion*>(term))
		{
		    //term has new value object, no need to copy
		    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;
			//term has new value object, no need to copy
			result = wrapper->NormalizeL(aRegistry);
			delete wrapper;
//			termsPol1.Close(); //not needed any more
		}

		if (dynamic_cast<CXorCompositeAssertion*>(result)) 
		{

			if (result->IsEmpty()) 
			{
                result->SetNormalized(true);
				delete AND;
                return result;
			}
			XORs.Append(result);
			continue;

		}

		if (dynamic_cast<CAndCompositeAssertion*>(result)) 
		{
  			if (result->IsEmpty()) 
			{
			    CAndCompositeAssertion* eleToDel = (CAndCompositeAssertion*)result;
			    delete eleToDel;
			}
			else
			{
    		    RPolicyTerms termsPol2 = result->GetTerms();
    			AND->AddTermsCopyL(termsPol2);

			    CAndCompositeAssertion* eleToDel = (CAndCompositeAssertion*)result;
			    delete eleToDel;
    			
//    			termsPol2.Close();
			}
			continue;
		}

		AND->AddTerm(result);
    }
    
	// processing child-XORCompositeAssertions

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
    
    CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();
	
	if (XORs.Count() > 1) 
	{
		for (int i = 0; i < XORs.Count(); i++) 
		{

			for (int j = i; j < XORs.Count(); j++) 
			{

				if (i != j) 
				{
					CXorCompositeAssertion* XOR_A = (CXorCompositeAssertion*) XORs[i];
					CXorCompositeAssertion* XOR_B = (CXorCompositeAssertion*) XORs[j];

					RPolicyTerms iterA = XOR_A->GetTerms();
					for (TInt k = 0; k< iterA.Count(); k++) 
					{
					    MAssertion* anAND_A = iterA[k];
						RPolicyTerms iterB = XOR_B->GetTerms();

						for (TInt l = 0; l< iterB.Count(); l++)
						{

							MAssertion* anAND_B = iterB[l];
							CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
							RPolicyTerms termsAA = anAND_A->GetTerms();
							RPolicyTerms termsBB = anAND_B->GetTerms();
							nAND->AddTermsCopyL(termsAA);
							nAND->AddTermsCopyL(termsBB);
//                            termsAA.Close();
  //                          termsBB.Close();
							XOR->AddTerm(nAND);
						}
//						iterB.Close();
					}
//					iterA.Close();
				}
			}
		}

	} 
	else if (XORs.Count() == 1) 
	{	
		CXorCompositeAssertion* XORterm = (CXorCompositeAssertion*)XORs[0];
	    RPolicyTerms termsPol3 = XORterm->GetTerms();
		XOR->AddTermsCopyL(termsPol3);
		delete XORterm;
//		termsPol3.Close();
	}

	XORs.Close();

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
	
	if (XOR->IsEmpty())
	{
	    delete XOR;
		AND->SetNormalized(true);
		return AND;
	}

	if (AND->IsEmpty()) 
	{
	    delete AND;
		XOR->SetNormalized(true);
		return XOR;
	}

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

	RPolicyTerms primTerms = AND->GetTerms();
	RPolicyTerms xTerms = XOR->GetTerms();

	for (TInt x = 0; x< xTerms.Count(); x++) 
	{
		MAssertion* rAND = xTerms[x];
		rAND->AddTermsCopyL(primTerms);
	}

    delete AND; //we have copied everythign from AND so now we dont need it
    
	XOR->SetNormalized(ETrue);
	return XOR;
    
}         
MAssertion* CAndCompositeAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
{
    MAssertion* normalizedMe = ((IsNormalized()) ? this : NormalizeL(aRegistry));

    if (!(dynamic_cast<CAndCompositeAssertion*>(normalizedMe))) 
    {
    	return normalizedMe->IntersectL(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->IntersectL(target->GetTerms()[0], NULL));
        	return nPOLICY;
        }

        case ECompositeXorType: 
        {
        	CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
        	RPointerArray<MAssertion> terms = target->GetTerms();

            TInt termCount = terms.Count();

           	for (TInt i = 0; i< termCount; i++)
        	{
        		MAssertion* asser = normalizedMe->IntersectL(terms[i]);

        		if (asser->Type() == ECompositeAndType) 
        		{
        			nXOR->AddTerm(asser);
        		}
        		else
        		{
        		    DeleteAssertion(asser);
        		}
        		
        	}
        	return nXOR;
        }

        case ECompositeAndType: 
        {
        	RPolicyTerms PRIMITIVES_A = ((normalizedMe->Size() > target->Size()) ? normalizedMe->GetTerms() : target->GetTerms());
        	RPolicyTerms PRIMITIVES_B = ((normalizedMe->Size() > target->Size()) ? target->GetTerms() : normalizedMe->GetTerms());

        	CPrimitiveAssertion* PRIMITIVE_A = NULL;
        	CPrimitiveAssertion* PRIMITIVE_B = NULL;

        	for (int i = 0; i < PRIMITIVES_A.Count(); i++) 
        	{
        		PRIMITIVE_A = (CPrimitiveAssertion*) PRIMITIVES_A[i];

        		TBool flag = false;

        		for (int j = 0; j < PRIMITIVES_B.Count(); j++) 
        		{
        			PRIMITIVE_B = (CPrimitiveAssertion*) PRIMITIVES_B[j];

        			if (PRIMITIVE_A->Name().Compare(PRIMITIVE_B->Name()) == 0) 
        			{
        				flag = true;
        				break;
        			}

        		}

        		if (!flag) 
        		{
        			return CXorCompositeAssertion::NewL();
        		}

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

        		if (dynamic_cast<CXorCompositeAssertion*>(a)) 
        		{
        		    DeleteAssertion(a);
        			return CXorCompositeAssertion::NewL();
        		}
                else
                {
                    DeleteAssertion(a);
                }
        		
        	}
        	CAndCompositeAssertion* result = CAndCompositeAssertion::NewL();
        	result->AddTermsCopyL(PRIMITIVES_A);
        	result->AddTermsCopyL(PRIMITIVES_B);
        	return result;
        }

        case EPrimitiveType: 
        {
        	CQName* name = ((CPrimitiveAssertion*) target)->QName();
        	TBool isMatch = false;

        	CQName* targetName = NULL;
        	RPolicyTerms terms = normalizedMe->GetTerms();
            for (TInt j = 0; j < terms.Count(); j++) 
        	{
        		targetName = ((CPrimitiveAssertion*) terms[j])->QName();

        		if (name->Uri().Compare(targetName->Uri()) == 0) 
        		{
        			isMatch = true;
        			break;
        		}
        	}

        	if (isMatch) {
        		CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
        	    RPolicyTerms tgtTerm = normalizedMe->GetTerms();
        		nAND->AddTerms(tgtTerm);
        		nAND->AddTerm(target);
        		return nAND;
        	}

        	return CXorCompositeAssertion::NewL();
        }

        default: 
        {
        }

    }
    return NULL;    
}
MAssertion*	CAndCompositeAssertion::MergeL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
{
	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);

	if (!(dynamic_cast<CAndCompositeAssertion*>(normalizedMe))) 
	{
		return normalizedMe->MergeL(aAssertion, aRegistry);
	}

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

	switch (target->Type()) 
	{

    	case ECompositePolicyType: 
    	{
    		CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
    		RPolicyTerms xTerms = target->GetTerms();
    		if(xTerms.Count() > 0)
    		{
    		    CXorCompositeAssertion* term = (CXorCompositeAssertion*)xTerms[0];		    
    		    nPOLICY->AddTerm(normalizedMe->MergeL(term));		   
    		}		
    		return nPOLICY;
    	}

    	case ECompositeXorType: 
    	{

    		CXorCompositeAssertion* nXOR = CXorCompositeAssertion::NewL();
            RPolicyTerms xTerms = target->GetTerms();
    		for (TInt i=0; i< xTerms.Count(); i++)
    		{
    			CAndCompositeAssertion* AND = (CAndCompositeAssertion*) xTerms[i];
    			nXOR->AddTerm(normalizedMe->MergeL(AND));
    		}

    		return nXOR;
    	}

    	case ECompositeAndType: 
    	{
    		CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
            RPolicyTerms terms = normalizedMe->GetTerms();
    		nAND->AddTermsCopyL(terms);
    		RPolicyTerms targeterms = target->GetTerms();
    		nAND->AddTermsCopyL(targeterms);

    		return nAND;
    	}

    	case EPrimitiveType: 
    	{
    		CAndCompositeAssertion* nAND = CAndCompositeAssertion::NewL();
            RPolicyTerms terms = normalizedMe->GetTerms();
    		nAND->AddTermsCopyL(terms);
    		nAND->AddTermCopyL(target);

    		return nAND;
    	}

	}
    
    return NULL;	
}