/*

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

#include <f32file.h>

#include <SenXmlUtils.h>

#include "senguidgen.h"

#include "SenXmlElement.h"

#include "SenDateUtils.h"

#include "wspolicywriter.h"

#include "senxmldebug.h"

using namespace WSPolicy;

namespace

{

    _LIT8(KIntersect, " intersect ");

    _LIT8(KMerge, " merge ");

    _LIT8(KValidUntil, "ValidUntil");

    const TUint KValidityTime = +7;

    const TUint KFlatBufSize = 128;

}

EXPORT_C CWSPolicy* CWSPolicy::NewL()

    {

    CWSPolicy* pSelf = CWSPolicy::NewLC();

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

EXPORT_C CWSPolicy* CWSPolicy::NewLC()

    {

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

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;

    }

EXPORT_C CWSPolicy* CWSPolicy::NewL(TDesC8& aPolicyUri, TDesC8& aPolicy)

    {

    CWSPolicy* pSelf = CWSPolicy::NewLC(aPolicyUri, aPolicy);

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

EXPORT_C CWSPolicy* CWSPolicy::NewLC(TDesC8& aPolicyUri, TDesC8& aPolicy)

    {

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

    CleanupStack::PushL(pSelf);

    pSelf->BaseConstructL(aPolicyUri, aPolicy);

    return pSelf;

    }

EXPORT_C CWSPolicy* CWSPolicy::NewL(CSenElement* aPolicy)

    {

     CWSPolicy* pSelf = CWSPolicy::NewLC(aPolicy);

    CleanupStack::Pop(pSelf);

    return pSelf;

    }

EXPORT_C CWSPolicy* CWSPolicy::NewLC(CSenElement* aPolicy)

    {

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

    CleanupStack::PushL(pSelf);

    pSelf->BaseConstructL(aPolicy);

    return pSelf;   

    }

CWSPolicy::~CWSPolicy()

    {

    delete iReader;

    delete iWriter;

    delete iInDoc;

    delete iOutDoc;

    delete iNormaPolicyAssert; //owned

    delete iPolicyId;

    delete iPolicyName;

    delete iPolicyUri;

    }

EXPORT_C CWSPolicy::CWSPolicy()

: iNormPolicy(NULL),

iNormaPolicyAssert(NULL),

iNormalized(EFalse),

iExpired(ETrue)

    {

    }

EXPORT_C void CWSPolicy::ConstructL()

    {

    iReader = CWSPolicyReader::NewL();

    iWriter = CWSPolicyWriter::NewL();

    iInDoc= CMyXml::NewL();

    iOutDoc = CMyXml::NewL();

    iNormPolicy = NULL;

    count = 0;

    iExpiry.UniversalTime();

    TTimeIntervalDays interval(KValidityTime);

    iExpiry+=interval;

    }

EXPORT_C TInt CWSPolicy::SetPolicyL(TDesC8& aPolicyUri, TDesC8& aPolicy)

    {

    TRAPD (error , BaseConstructL(aPolicyUri, aPolicy));

    return error;

    }

void CWSPolicy::BaseConstructL(TDesC8& aPolicyUri, TDesC8& aPolicy)

    {

    ConstructL();

    if(aPolicyUri.Length() > 0 && aPolicy.Length() > 0)

    {

        TInt error = iInDoc->ReadFromDescL(aPolicy);

        if(error != KErrNone)

            return;

        CSenElement* policy = iInDoc->XMLDocL();

        if(policy)

        {

    //        CSenElement* policy = Policy();

            TPtrC8 policyUri = CWSPolicyUtils::PolicyUriL(policy);

            if(policyUri == KNullDesC8())

            {

                iPolicyUri = aPolicyUri.AllocL();            

                AddPolicyMetadatEndpointL(policy);

            }

            else

            {

                iPolicyUri = policyUri.AllocL();

            }

            TPtrC8 name = CWSPolicyUtils::PolicyNameL(policy);

            if(name == KNullDesC8())

            {

                iPolicyName = aPolicyUri.AllocL();

                AddPolicyNameL(policy);    

            }

            else

            {

                iPolicyName = name.AllocL();

            }

            TPtrC8 id = PolicyIdL(policy);

            iPolicyId = id.AllocL();

            CSenElement* expiry = GetExpiryTagL();	//codescannerwarnings 

            if(EvaluateExpiryL(expiry))	//codescannerwarnings 

            {

               AddPolicyValidityL(policy);

            }

            else

            {

                AddPolicyValidityL(policy);

            }

            //We have modifed the original XMLElement. Now its safe to 

            //convert this element into PolicyAssertion

        }        

    }

    }

void CWSPolicy::BaseConstructL(CSenElement* aPolicy)

    {

    if(aPolicy)

        {

        TPtrC8 name = CWSPolicyUtils::PolicyNameL(aPolicy);

        TPtrC8 uri = CWSPolicyUtils::PolicyUriL(aPolicy);

        TPtrC8 id = PolicyIdL(aPolicy);

        if(id != KNullDesC8())

            iPolicyId = id.AllocL();

        HBufC8* policy = aPolicy->AsXmlL();

        CleanupStack::PushL(policy);

        BaseConstructL(uri, *policy);

        CleanupStack::PopAndDestroy(policy);

        }

    }

EXPORT_C TBool CWSPolicy::Normalized()

    { 

    return iNormalized;

    }

//returns the descriptor of NON-NORMALIZED/NORMALIZED Policy

EXPORT_C HBufC8* CWSPolicy::PolicyAsXmlL()

    {

    CSenElement* policy = iOutDoc->XMLDocL();

    if(policy && Normalized())

    {

        return policy->AsXmlL();

    }

    else

    {

        policy = iInDoc->XMLDocL();

        if(policy)

        {

            return policy->AsXmlL();

        }

    }

    return NULL;    

    }

//returns the xml element of NON-NORMALIZED/NORMALIZED Policy    

EXPORT_C    CSenElement* CWSPolicy::PolicyL()	//codescannerwarnings

    {

    CSenElement* policy = iOutDoc->XMLDocL();

    if(policy && Normalized())

    {

        return policy;

    }

    else

    {

        policy = iInDoc->XMLDocL();

        if(policy)

        {

            return policy;

        }

    }

    return NULL;    

    }

EXPORT_C CSenElement* CWSPolicy::NonNormalizedPolicyL()	//codescannerwarnings

{

    if(iInDoc)

    {

        CSenElement* policy = iInDoc->XMLDocL();

        if(policy)

        {

            return policy;

        }

    }

    return NULL;    

}

MAssertion* CWSPolicy::NormaAssertion()

{

    if(iNormaPolicyAssert)

        return iNormaPolicyAssert;

    else

        return NULL;

}

EXPORT_C TBool CWSPolicy::NormalizePolicyL(CPolicyRegistry* aRegistry)

    {

    TBool retval = EFalse;

    TRAPD(error, retval = NormalizePL(aRegistry));

    if(error ==KErrNone)

        return retval;

    else

        return EFalse;

    }

TInt CWSPolicy::NormalizePL(CPolicyRegistry* aRegistry)

    {

        CPolicyAssertion* poolicy = iReader->GetPolicyL(PolicyL());	//codescannerwarnings

    if(!poolicy)

        {

        return EFalse;

        }

    if(poolicy->IsNormalized())

        {

        return iNormalized;

        }

    TInt error = KErrNone;    

    MAssertion* normalized = NULL;

    TRAP(error, normalized = poolicy->NormalizeL(aRegistry));

	if(error == KErrNone && normalized)

	    {

        iNormalized = ETrue;

        iNormaPolicyAssert = (CPolicyAssertion*)normalized;

        delete poolicy;

//        delete iInDoc;

//        iInDoc = NULL;

        CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

        CleanupStack::PushL(pBuf);

        TPtrC8 p = iWriter->WriteToBufL(*pBuf, iNormaPolicyAssert);

        TInt error = iOutDoc->ReadFromDescL(p);

        CleanupStack::PopAndDestroy(pBuf);

        if(error == KErrNone)

            {

            iNormPolicy = iOutDoc->XMLDocL();

            if(iNormPolicy)

                {

                TPtrC8 policyUri = CWSPolicyUtils::PolicyUriL(iNormPolicy);

                if(policyUri == KNullDesC8())

                    {

                    AddPolicyMetadatEndpointL(iNormPolicy);

                    }

                TPtrC8 name = CWSPolicyUtils::PolicyNameL(iNormPolicy);

                if(name == KNullDesC8())

                    {

                    AddPolicyNameL(iNormPolicy); 

                    AddPolicyIdL(iNormPolicy);

                    }

                }

            }

        else

            {

            iNormPolicy = NULL;

            }

	    return ETrue;

	    }

	else

	    {

	    return EFalse;      

	    }

    }

EXPORT_C CWSPolicy* CWSPolicy::IntersectPolicyL(CWSPolicy* aPolicy)

    {

    CWSPolicy* intersectedPolicy = NULL; 

    TRAPD(error, intersectedPolicy = IntersectPL(aPolicy));	//codescannerwarnings

    if(error ==KErrNone)    

        return intersectedPolicy;

    else

        {

        delete intersectedPolicy;

        return NULL;

        }

    }

CWSPolicy* CWSPolicy::IntersectPL(CWSPolicy* aPolicy)	//codescannerwarnings

    {

    MAssertion* pol1 = NormaAssertion();

    MAssertion* pol2 = aPolicy->NormaAssertion();

//Only normalized policies can be intersected so if we provide a non normalized policy we will get NULL    

    if(pol1->IsNormalized() && pol2->IsNormalized())    

    {

        MAssertion* result = pol1->IntersectL(pol2);

        if(result)

        {

            CPolicyAssertion* intersected = (CPolicyAssertion*)result;

            CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

            CleanupStack::PushL(pBuf);

            TPtrC8 p = iWriter->WriteToBufL(*pBuf, intersected);

            delete intersected; //we dont need it any more

            CWSPolicy* intersectedPolicy = NULL;            

            if(p.Length() > 0)

            {

                TPtrC8 policy2Uri = CWSPolicyUtils::PolicyUriL(aPolicy->PolicyL());  //codescannerwarnings

                HBufC8* nameBuf = HBufC8::NewLC(iPolicyUri->Length()+ policy2Uri.Length()+11);

                TPtr8 name = nameBuf->Des();

                name.Append(iPolicyUri->Des());

                name.Append(KIntersect);

                name.Append(policy2Uri);

                intersectedPolicy = CWSPolicy::NewL(name, p);

                CleanupStack::PopAndDestroy(nameBuf);

                if(intersectedPolicy)

                {

                    if(intersectedPolicy->NormalizePolicyL(NULL))

                    {

                        //return intersectedPolicy;

                    }

                    else //cannot normalize intersected so return NULL

                    {

                        delete intersectedPolicy;

                        intersectedPolicy = NULL;

                    }

                }

                else

                {

                    delete intersectedPolicy;

                    intersectedPolicy = NULL;

                }

            }

            CleanupStack::PopAndDestroy(pBuf);

            return intersectedPolicy;

        }

    }

    return NULL;

    }

EXPORT_C CWSPolicy* CWSPolicy::MergePolicyL(CWSPolicy* aPolicy)

    {

    CWSPolicy* mergedPolicy = NULL; 

    TRAPD(error, mergedPolicy = MergePL(aPolicy));

    if(error ==KErrNone)    

        return mergedPolicy;

    else

        {

        delete mergedPolicy;

        return NULL;

        }

    }

CWSPolicy* CWSPolicy::MergePL(CWSPolicy* aPolicy)

    {

    MAssertion* pol1 = NormaAssertion();

    MAssertion* pol2 = aPolicy->NormaAssertion();

//Only normalized policies can be merged so if we provide a non normalized policy we will get NULL    

    if(pol1->IsNormalized() && pol2->IsNormalized())    

    {

        MAssertion* result = pol1->MergeL(pol2);

        if(result)

        {

            CPolicyAssertion* merged = (CPolicyAssertion*)result;

            CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

            CleanupStack::PushL(pBuf);

            TPtrC8 p = iWriter->WriteToBufL(*pBuf, merged);

            delete merged; //we dont need it any more

            CWSPolicy* mergedPolicy = NULL;            

            if(p.Length() > 0)

            {

                TPtrC8 policy2Uri = CWSPolicyUtils::PolicyUriL(aPolicy->PolicyL());  //codescannerwarnings

                HBufC8* nameBuf = HBufC8::NewLC(iPolicyUri->Length()+ policy2Uri.Length()+7);

                TPtr8 name = nameBuf->Des();

                name.Append(iPolicyUri->Des());

                name.Append(KMerge);

                name.Append(policy2Uri);

                mergedPolicy = CWSPolicy::NewL(name, p);

                CleanupStack::PopAndDestroy(nameBuf);                

                if(mergedPolicy)

                {

                    if(mergedPolicy->NormalizePolicyL(NULL))

                    {

//                        return mergedPolicy;

                    }

                    else //cannot normalize merged so return NULL

                    {

                        delete mergedPolicy;

                        mergedPolicy = NULL;

                    }

                }

                else

                {

                    delete mergedPolicy;

                    mergedPolicy = NULL;

                }

            }

            CleanupStack::PopAndDestroy(pBuf);

            return mergedPolicy;

        }

    }

    return NULL;

    }

CSenElement* CWSPolicy::NormalizePolicy2L(CSenElement& aPolicy, CPolicyRegistry* aRegistry)

{

    CPolicyAssertion* poolicy = iReader->GetPolicyL(&aPolicy);

    if(!poolicy)

        {

        return NULL;

        }

    if(poolicy->IsNormalized())

        {

        return iNormPolicy;

        }

    TInt error = KErrNone;    

    MAssertion* normalized = NULL;

    TRAP(error, normalized = poolicy->NormalizeL(aRegistry));

	if(error == KErrNone && normalized)

	    {

        iNormalized = ETrue;

        iNormaPolicyAssert = (CPolicyAssertion*)normalized;

        delete poolicy;

//        delete iInDoc;

//        iInDoc = NULL;

        CBufFlat *pBuf = CBufFlat::NewL(KFlatBufSize);

        CleanupStack::PushL(pBuf);

        TPtrC8 p = iWriter->WriteToBufL(*pBuf, iNormaPolicyAssert);        

        delete iNormaPolicyAssert;

        iNormaPolicyAssert = NULL;

        TInt error = iOutDoc->ReadFromDescL(p);

        CleanupStack::PopAndDestroy(pBuf);

        if(error == KErrNone)

            {

            iNormPolicy = iOutDoc->XMLDocL();

            if(iNormPolicy)

                {

                iNormPolicy = iOutDoc->ExtractElement();

                }

            }

        else

            {

            iNormPolicy = NULL;