/*

* Copyright (c) 2006-2006 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 FILES

#include <f32file.h>

#include "PolicyNormalizer.h"

#include "SenXmlElement.h"

#include "WSPolicyRegistry.h"

using namespace WSPolicy;

namespace

{

_LIT( KOutPath, "c:\\logs\\out.xml");

_LIT8(KColon, ":");

//_LIT8( KServicePolicyLocalName, "ServicePolicy");

}

CPolicyNormalizer* CPolicyNormalizer::NewL()

    {

    CPolicyNormalizer* pSelf =

        CPolicyNormalizer::NewLC();

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

CPolicyNormalizer* CPolicyNormalizer::NewLC()

    {

    CPolicyNormalizer* pSelf =

                        new (ELeave) CPolicyNormalizer();

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;

    }

CPolicyNormalizer::~CPolicyNormalizer()

{

    delete iXmlReader;

    delete iPath;

    delete iNewPolicy;

    iOrphanElements.ResetAndDestroy();

}

CPolicyNormalizer::CPolicyNormalizer()

    {

    }

void CPolicyNormalizer::ConstructL()

    {

//    BaseConstructL(KServicePolicyLocalName());

    iXmlReader = CSenXmlReader::NewL();

    iNewPolicy = CSenXmlElement::NewL(KWsPolicy);

    count = 0;

    }

CSenElement* CPolicyNormalizer::NormalizeL(CPolicyRegistry* aRegistry)

{

    CSenElement& element = AsElement();

    TPtrC8 name = element.LocalName();

    if (name.Compare(KWsPolicy) == 0)

    {

        iNewPolicy->CopyFromL(element);

        RPointerArray<CSenElement>& children = iNewPolicy->ElementsL();

        CleanupClosePushL(children);

        TInt childCount = children.Count();

        if(childCount > 0)

        {

            CSenElement* pNextChild;   

            TInt i = 0;

            while (i < childCount)

            {   

                pNextChild = children[childCount-1];

                CSenElement* newElement = iNewPolicy->RemoveElement(*pNextChild);

                delete newElement;

                childCount--;

            }

        }

        CleanupStack::PopAndDestroy(); //children

       ProcessPolicyReferenceL(&element, aRegistry);

       ProcessPolicyTermL(&element, iNewPolicy);

       ProcessLogicL(iNewPolicy);

       ProcessAssertionBranchingL(iNewPolicy);

//#ifdef _SENDEBUG       

       WriteL(iNewPolicy);

//#endif

       return iNewPolicy;

    }

    return NULL; //&element;   

}

TPtrC8 CPolicyNormalizer::GetReferenceUriL(CSenElement* aReference)

    {

    RPointerArray<CSenBaseAttribute>& attrs = aReference->AttributesL();

    CSenBaseAttribute* bs = NULL;

    TInt ele_count = attrs.Count();

    for (TInt j=0; j < ele_count; j++)

        {

         bs = (attrs)[j];

         if(bs->Name().Compare(KUri) == 0)

         {

            return bs->Value();

         }

         }

    return KNullDesC8();

    }

TInt CPolicyNormalizer::ReplacePolicyReferenceL(CSenElement* aReferenceElement, CSenElement* aReferredPolicy)

    {

    //get the parent of policy, remove referenceElement and add referred policy there 

    CSenElement* parent = aReferenceElement->Parent();

    if(!parent)

        return KErrNotFound;

    //add all policy child elements here and then copy those element's contents 

    //from referred policy,

    //the referred policy element is owned by SD so do not use it

     RPointerArray<CSenElement>& children = aReferredPolicy->ElementsL();

        TInt childCount = children.Count();

        if(childCount > 0)

        {

            CSenElement* pNextChild;   

            TInt i = 0;

            while (i < childCount)

            {   

                pNextChild = children[i];

                TPtrC8 localName = pNextChild->LocalName();

                TPtrC8 nsUri = pNextChild->NamespaceURI();

                CSenElement& newElement = parent->AddElementL(nsUri, localName);

                newElement.CopyFromL(*pNextChild);                

                i++;

            }

        }

//now we have resolved the reference so we dont need the PolicyReference element    

    CSenElement* removed = parent->RemoveElement(*aReferenceElement);

    if(removed)

        {

        delete removed;

        return KErrNone;

        }

    return KErrNotFound;

    }

CSenElement* CPolicyNormalizer::ProcessPolicyReferenceL(CSenElement* aPolicy, CPolicyRegistry* aRegistry)

{    //Loop for wsp:PolicyReference element and if found then replace

    // it with wsp:All and copy everything from found policy to here

    if(aRegistry == NULL)

        return NULL;

    //Check if there is a reference if yes then resolve it

    RPointerArray<CSenElement> referenceChildren;

    if(aPolicy->ElementsL(referenceChildren, KWsPolicyReference) == KErrNone)

        {

        TInt childCount = referenceChildren.Count();

        TInt i = 0;

        CSenElement* pNextChild;

        while (i < childCount)

            {

            pNextChild = referenceChildren[i];

            TPtrC8 localName = pNextChild->LocalName();

            TPtrC8 uri = GetReferenceUriL(pNextChild);

            _LIT8(KHash, "#");

            HBufC8* aRippedUri = NULL;

            if(uri.Left(1).Compare(KHash) == 0)

               aRippedUri = uri.Right(uri.Length()-1).AllocL();

            if(aRippedUri->Length() > 0)

                {

                CSenElement* referedPolicy = aRegistry->LookupPolicy(aRippedUri->Des());

                if(referedPolicy)

                    {

                    ReplacePolicyReferenceL(pNextChild,referedPolicy);

                    }

                }

                delete aRippedUri;

            i++;

            }

        }

    //Check in all children recursively PolicyReferences and resolve them

    RPointerArray<CSenElement>& children = aPolicy->ElementsL();

    TInt childCount = children.Count();    

    CSenElement* pNextChild;

    TInt i=0;

    while (i < childCount)

    {

        pNextChild = children[i];

        TPtrC8 localName = pNextChild->LocalName();

        ProcessPolicyReferenceL(pNextChild, aRegistry);

        i++;

    }

  return NULL;  

}

TBool CPolicyNormalizer::IsOptionalL(CSenElement* aAssertion)

{

    // 7, 21, 23, 24

    RPointerArray<CSenBaseAttribute>& attrs = aAssertion->AttributesL();

    CSenBaseAttribute* bs = NULL;

    TInt ele_count = attrs.Count();

    for (TInt j=0; j < ele_count; j++)

        {

         bs = (attrs)[j];

         if(bs->Name().Compare(KWspOptinal) == 0)

         {

            if(bs->Value() == KWspOptinalTrue)

                return ETrue;

         }

         }

    return EFalse;

}

CSenElement* CPolicyNormalizer::ProcessOptionalElement(CSenElement* /*aAssertion*/, CSenElement* aNormalAssertion)

    {

    return aNormalAssertion;

    }

CSenElement* CPolicyNormalizer::ProcessAssertionTermL(CSenElement* aAssertion, CSenElement* aNormalAssertion)

{

    TPtrC8 assertionName = aAssertion->LocalName();

    TPtrC8 assertionNsUri = aAssertion->NamespaceURI();

    TPtrC8 nsPrefix = aAssertion->NsPrefix();

    TBuf8<255> qname(nsPrefix);

    qname.Append(':');

    qname.Append(assertionName);

    CSenElement& newNormalForm = aNormalAssertion->AddElementL(assertionNsUri,assertionName, qname);

    if(IsOptionalL(aAssertion))

    {

        if (CopySenElementWithoutOptionL(aAssertion, &newNormalForm))

        {

            CSenElement* parent = aNormalAssertion->Parent();

            AddAndElementL(parent);

        }

    }

    else

    {

        CopySenElementL(aAssertion, &newNormalForm);    

    }

    RPointerArray<CSenElement>& children = aAssertion->ElementsL();

    TInt childCount = children.Count();  

    if (childCount > 0)

    {

        CSenElement* pNextChild;

        TInt i =0;

        while (i < childCount)

        {

            pNextChild = children[i]; 

            TPtrC8 localName = pNextChild->LocalName();

            if(localName.Compare(KXorCompositeAssertion) == 0)

            {

            }

            else if (localName.Compare(KAndCompositeAssertion) == 0)

            {

            }

            else if (localName.Compare(KWsPolicy) == 0 )

            {

                CSenElement* aNewElement = AddPolicyElementL(&newNormalForm);

                aNewElement = ProcessPolicyTermL(pNextChild,aNewElement);

            }

            else

            {//if asserion is not well defined and dont have  apolicy object here 

               //then it should add one and then add XOR and AND

//                 CSenElement* aNewElement = AddPolicyElementL(&newNormalForm);

//                 CSenElement* pChildXor = AddXorElementL(aNewElement);

//                 CSenElement* pChildAnd = AddAndElementL(pChildXor);

                 aNormalAssertion = ProcessAssertionTermL(pNextChild, &newNormalForm);

            }

            i++;    

        }

    }

  	return aNormalAssertion;

}

CSenElement* CPolicyNormalizer::ProcessPolicyTermL(CSenElement* aAssertion, CSenElement* aNormalAssertion)

{

    RPointerArray<CSenElement>& children = aAssertion->ElementsL();

    TInt childCount = children.Count();    

    CSenElement* pNextChild;

    if(childCount == 0)

    {

      CSenElement* pXor = AddXorElementL(aNormalAssertion);

      CSenElement* pAnd = AddAndElementL(pXor);

      return aNormalAssertion;

    }

    TInt i=0;

    CSenElement* assertionParent = aNormalAssertion;

    while (i < childCount)

    {

        pNextChild = children[i];

        TPtrC8 localName = pNextChild->LocalName();

        if(localName.Compare(WSPolicy::KXorCompositeAssertion) == 0)

        {

            TPtrC8 nt = aNormalAssertion->LocalName();

            if(nt.Compare(WSPolicy::KWsPolicy)== 0) //PERFECT we need it

            {

            //        aNormalAssertion = 

                ProcessXORTermL(pNextChild,aNormalAssertion);

            }

            else if(nt.Compare(WSPolicy::KXorCompositeAssertion)== 0)

            {

               CSenElement* NewXorParent =  aNormalAssertion->Parent();

               ProcessXORTermL(pNextChild,NewXorParent); 

            }

            else if(nt.Compare(WSPolicy::KAndCompositeAssertion)== 0)

            {

               CSenElement* NewXorParent =  aNormalAssertion->Parent()->Parent();

               ProcessXORTermL(pNextChild,NewXorParent);

            }

            else

            {

                //SHOULDNT BE  A CASE CAZ then we have XOR in some assertion

                //It should always be in a POLICY tag

            }

        }

        else if (localName.Compare(WSPolicy::KAndCompositeAssertion) == 0)

        {

            CSenElement* pNormChild = AddXorElementL(aNormalAssertion);

    //        aNormalAssertion = 

            ProcessANDTermL(pNextChild, pNormChild);

        }

        else if (localName.Compare(WSPolicy::KWsPolicy) == 0 )

        {

            TPtrC8 parentName = aNormalAssertion->LocalName();

            if(parentName.Compare(WSPolicy::KXorCompositeAssertion) == 0)

            {

                CSenElement* pChildXor = AddXorElementL(aNormalAssertion);

                CSenElement* pChildAnd = AddAndElementL(pChildXor);

            }

            else if(parentName.Compare(WSPolicy::KAndCompositeAssertion) == 0)

            {

            }

            else if(parentName.Compare(WSPolicy::KWsPolicy) == 0)

            {

                CSenElement* pChildXor = AddXorElementL(aNormalAssertion);

                CSenElement* pChildAnd = AddAndElementL(pChildXor);

            }

            else

            {

                CSenElement* pChildXor = AddXorElementL(aNormalAssertion);

                CSenElement* pChildAnd = AddAndElementL(pChildXor);                

            }

        }

        else    //its an Assertion

        {

            TPtrC8 parentName = assertionParent->LocalName();

            //if parent is Policy -> add XOR and AND and then process 

            //assertion- >new parent for same level is AND

            //if parent is XOR -> Add AND and then process assertion. at this level the parent will be AND

            //if parent is AND just process assertion

            if(IsOptionalL(pNextChild))

            {

                if(parentName.Compare(WSPolicy::KWsPolicy) == 0)

                {

                    CSenElement* pXor = AddXorElementL(assertionParent);

                    CSenElement* pAnd = AddAndElementL(pXor);

    //                aNormalAssertion = 

                    ProcessAssertionTermL(pNextChild, pAnd);

                }

                else if(parentName.Compare(WSPolicy::KAndCompositeAssertion) == 0)

                {

                    CSenElement* parentNow = assertionParent;

                    assertionParent = assertionParent->Parent();

                    CSenElement* policyParent= assertionParent->Parent();

                    CSenElement* pXor = AddXorElementL(policyParent);

                    CSenElement* pAnd = AddAndElementL(pXor);

    //              aNormalAssertion = 

                    ProcessAssertionTermL(pNextChild, pAnd);   

                    assertionParent = parentNow;  

                }   

                else if(parentName.Compare(WSPolicy::KXorCompositeAssertion) == 0)

                {

                }

                else

                {

                    //probably error   

                }

            }

            else

            {

                if(parentName.Compare(WSPolicy::KWsPolicy) == 0)

                {

                    CSenElement* pXor = AddXorElementL(assertionParent);

                    CSenElement* pAnd = AddAndElementL(pXor);

                    assertionParent = pAnd;

    //                assertionParent =  ProcessAssertionTermL(pNextChild, pAnd);

                }

                else if(parentName.Compare(WSPolicy::KXorCompositeAssertion) == 0)

                {

                    CSenElement* pXor = AddXorElementL(assertionParent);

                    CSenElement* pAnd = AddAndElementL(pXor);

    //            aNormalAssertion = ProcessAssertionTermL(pNextChild, pAnd);

                }

                else if(parentName.Compare(WSPolicy::KAndCompositeAssertion) == 0)

                {

    //            aNormalAssertion = ProcessAssertionTermL(pNextChild, assertionParent);

                }

                else 

                {

                    CSenElement* pXor = AddXorElementL(assertionParent);

                    CSenElement* pAnd = AddAndElementL(pXor);

                    assertionParent = pAnd;

      //            aNormalAssertion =  ProcessAssertionTermL(pNextChild, pAnd);

                }

                ProcessAssertionTermL(pNextChild, assertionParent);

            }

        }

     i++;   

    }

    return assertionParent;

}

CSenElement* CPolicyNormalizer::ProcessXORTermL(CSenElement* aAssertion, CSenElement* aNormalAssertion)

{

    CSenElement* pNormChild = AddXorElementL(aNormalAssertion);

    RPointerArray<CSenElement>& children = aAssertion->ElementsL();

    TInt childCount = children.Count();

    TInt i = 0;

     while (i < childCount)

    {

        CSenElement* pChild = children[i];

        CSenElement* pNewChild = NULL;

//        CSenElement* newChild = NULL;

        TPtrC8 childName = pChild->LocalName();