/*
* 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;	    
}