/*
* 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 "policyassertion.h"
#include "xorcompositeassertion.h"
#include "andcompositeassertion.h"
#include "wspolicywriter.h"
#include "sendebug.h"
CPolicyAssertion* CPolicyAssertion::NewL()
{
    CPolicyAssertion* pSelf = CPolicyAssertion::NewLC();
    CleanupStack::Pop(pSelf);
    return pSelf;

}
CPolicyAssertion* CPolicyAssertion::NewLC()
{
    CPolicyAssertion* pSelf = new (ELeave) CPolicyAssertion();
    CleanupStack::PushL(pSelf);
    pSelf->ConstructL();
    return pSelf;

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

CPolicyAssertion::~CPolicyAssertion()
{
    delete iName;
    delete iId;
    delete iMetadataEndpoint;
}
CPolicyAssertion::CPolicyAssertion():
iName(NULL),
iId(NULL),
iMetadataEndpoint(NULL)
{

}
void CPolicyAssertion::ConstructL()
{

}

void CPolicyAssertion::ConstructL(CPolicyAssertion* aValue)
{
    ConstructL();

    RPolicyTerms terms = aValue->GetTerms();
    
    if(terms.Count() > 0)
        AddTermsCopyL(terms);
    
}
TAssertionType CPolicyAssertion::Type()
{
    return ECompositePolicyType;
}
MAssertion* CPolicyAssertion::NormalizeL()
{
    return NormalizeL(NULL);
}
MAssertion*	CPolicyAssertion::NormalizeL(CPolicyRegistry* aRegistry)
{
    if (IsNormalized()) 
    {
    	return this;
    }
//	TPtrC8 xmlBase = Name();
//	TPtrC8 id = Id();
	CPolicyAssertion* policy = CPolicyAssertion::NewL(); //new Policy(xmlBase, id);

	CXorCompositeAssertion* XOR = CXorCompositeAssertion::NewL();
	CAndCompositeAssertion* AND = CAndCompositeAssertion::NewL();	
	
    RPolicyTerms childXorTermList;
    
	RPointerArray<MAssertion> terms = GetTerms();
	MAssertion* term = NULL;
	MAssertion* result = NULL;
    TInt termCount = terms.Count();
	for (TInt i = 0; i< termCount; i++)
	{
		term = terms[i];
		result = term->NormalizeL(aRegistry);

		if(dynamic_cast<CPolicyAssertion*>(result))
		{
			CXorCompositeAssertion* tempXor = (CXorCompositeAssertion*) result->GetTerms()[0];

			if (tempXor->Size() != 1)
			{
			//result is Policy and have an XOR
			//delete the policy and put XOR as result
//				result = Xor;
                
			    CPolicyAssertion* ele = (CPolicyAssertion*)result;
			    result = NULL;
			    result = CXorCompositeAssertion::NewL();
			    
			    RPolicyTerms xorTerms = tempXor->GetTerms();
			    result->AddTermsCopyL(xorTerms);
			    
			    delete ele;
			    ele = NULL;
            } 
			else 
			{
			    MAssertion* tempTerm = tempXor->GetTerms()[0];
			    if(tempTerm)
			    {
                    RPolicyTerms terms2 = tempTerm->GetTerms();
    				AND->AddTermsCopyL(terms2);
//    				terms2.Close();
			    }
    				CPolicyAssertion* eleToDel = (CPolicyAssertion*)result;
    				delete eleToDel;
    				eleToDel = NULL;
    				result = NULL;
		
				continue;
			}
		}

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

			if (((CXorCompositeAssertion*) result)->IsEmpty())
			{
//				CXorCompositeAssertion* emptyXor = CXorCompositeAssertion::NewL();
//				emptyXor->SetNormalized(ETrue);
//                result->AddTermL(AND);
				policy->AddTerm(result);
				policy->SetNormalized(ETrue);
                delete AND;
                delete XOR;
                childXorTermList.Close();
				return policy;
			}

			childXorTermList.Append(result);
			continue;
		}

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

			if (result->IsEmpty()) 
			{
				CAndCompositeAssertion* emptyAnd = CAndCompositeAssertion::NewL();
				XOR->AddTerm(emptyAnd);

			} 
			else 
			{
			    RPolicyTerms terms3 = result->GetTerms();
				AND->AddTermsCopyL(terms3);
			}
                CAndCompositeAssertion* eletoDel = (CAndCompositeAssertion*)result;
				delete eletoDel;			
			
			continue;
		}
		
		AND->AddTerm(result);
	}

////////////////////////////////////////////////////	
////////////////////////////////////////////////////
	// processing child-XORCompositeAssertions
	if (childXorTermList.Count() > 1) {

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

			for (TInt j = i; j < childXorTermList.Count(); j++) {

				if (i != j) {
					CXorCompositeAssertion* xorTermA = (CXorCompositeAssertion*) childXorTermList[i];
					CXorCompositeAssertion* xorTermB = (CXorCompositeAssertion*) childXorTermList[j];

					RPolicyTerms iterA = xorTermA->GetTerms();

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

    					for (TInt l = 0; l< iterB.Count(); l++)
    					{
							MAssertion* andTermB = iterB[l];
							CAndCompositeAssertion* anAndTerm = CAndCompositeAssertion::NewL();
							RPolicyTerms termsAA = andTermA->GetTerms();
							RPolicyTerms termsBB = andTermB->GetTerms();
							anAndTerm->AddTermsCopyL(termsAA);
							anAndTerm->AddTermsCopyL(termsBB);
//							termsBB.Close();
//							termsAA.Close();
							XOR->AddTerm(anAndTerm);
						}
//    						iterB.Close();
					}
//    					iterA.Close();
				}
			}
		}
		for (TInt x = 0; x < childXorTermList.Count(); x++) 
	    {
	        CXorCompositeAssertion* xorTermTemp = (CXorCompositeAssertion*)childXorTermList[x];
	        if(xorTermTemp)
	            delete xorTermTemp;	        
	    }
	}
	else if (childXorTermList.Count() == 1) 
	{
		CXorCompositeAssertion* xorTerm = (CXorCompositeAssertion*)childXorTermList[0];
		XOR->AddTermsCopyL(xorTerm->GetTerms());
        delete xorTerm;
	}

	else if (childXorTermList.Count() == 0)
	{
        if(AND->Size() > 0)
            XOR->AddTerm(AND);
        else
            delete AND;
        policy->AddTerm(XOR);
		policy->SetNormalized(ETrue);
		
        childXorTermList.Close();
    	return policy;
	}

    childXorTermList.Close();
	
////////////////////////////////////////////////////	
////////////////////////////////////////////////////
	RPolicyTerms primTerms = AND->GetTerms();
	RPolicyTerms andTerms = XOR->GetTerms();
    for(TInt p = 0; p < andTerms.Count(); p++)
    {
		MAssertion* anAndTerm = andTerms[p];
		anAndTerm->AddTermsCopyL(primTerms);
	}
	
    delete AND;
	policy->AddTerm(XOR);
	policy->SetNormalized(ETrue);
	
	return policy;

}         
MAssertion* CPolicyAssertion::IntersectL(MAssertion* aAssertion, CPolicyRegistry* aRegistry)
{
	MAssertion* normalizedMe = (IsNormalized()) ? this : NormalizeL(aRegistry);
	if (!(dynamic_cast<CPolicyAssertion*>(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();
		CXorCompositeAssertion* norm1 = (CXorCompositeAssertion*) normalizedMe->GetTerms()[0];
		nPOLICY->AddTerm(norm1->IntersectL((CXorCompositeAssertion*) target->GetTerms()[0], NULL));
		return nPOLICY;
	}
	case ECompositeXorType:
	case ECompositeAndType:
	case EPrimitiveType: 
	{
		CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();
		nPOLICY->AddTerm((normalizedMe->GetTerms()[0])->IntersectL(target, NULL));
		return nPOLICY;
	}

	default: 
	{
	}

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

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

	CPolicyAssertion* nPOLICY = CPolicyAssertion::NewL();

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

    RPolicyTerms terms = normalizedMe->GetTerms();
    if(terms.Count() > 0)
    {
        CXorCompositeAssertion* xorTerm = (CXorCompositeAssertion*)terms[0];
            
    	switch (type) 
    	{

        	case ECompositePolicyType: 
        	{
        	    RPolicyTerms tgtTerms = target->GetTerms();
        	    if(tgtTerms.Count() > 0)
        	    {
                    CXorCompositeAssertion* tgtTerm = (CXorCompositeAssertion*)tgtTerms[0];
                    MAssertion* result = xorTerm->MergeL(tgtTerm, NULL);
                    nPOLICY->AddTerm(result);
        	    }
        		return nPOLICY;
        	}
        	case ECompositeXorType:
        	case ECompositeAndType:
        	case EPrimitiveType:
            {
                MAssertion* result = xorTerm->MergeL(target, NULL);            
        		nPOLICY->AddTerm(result);
        		return nPOLICY;
        	}

        	default: 
        	{
        	}

    	}
    }
    return NULL;    
}

void CPolicyAssertion::SetNameL(TDesC8& aName)
{
    iName = aName.AllocL();
}          
void CPolicyAssertion::SetIdL(TDesC8& aId)
{
    iId = aId.AllocL();
}
TPtrC8 	CPolicyAssertion::Name()
{
    return iName->Des();
}     
TPtrC8 	CPolicyAssertion::Id()
{
    return iId->Des();
}
TPtrC8 CPolicyAssertion::PolicyURI()
{
    return iName->Des();
}