/*

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

#include "wspolicyreader.h"

#include "policyassertion.h"

#include "andcompositeassertion.h"

#include "xorcompositeassertion.h"

#include "assertion.h"

#include "primitiveassertion.h"

#include "policyreferenceassertion.h"

using namespace WSPolicy;

using namespace PolicyWriter;    

CWSPolicyWriter* CWSPolicyWriter::NewL()

{

     CWSPolicyWriter* pSelf = CWSPolicyWriter::NewLC();

    CleanupStack::Pop(pSelf);

    return pSelf;

}

CWSPolicyWriter* CWSPolicyWriter::NewLC()

{

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

    CleanupStack::PushL(pSelf);

    pSelf->ConstructL();

    return pSelf;

}

CWSPolicyWriter::~CWSPolicyWriter()

{

    iNamespcaes.Reset();

}

CWSPolicyWriter::CWSPolicyWriter():iNamespcaes(ETrue,ETrue)

{

}

void CWSPolicyWriter::ConstructL()

{

count = 0;    

}

TPtrC8 CWSPolicyWriter::WriteToBufL(CBufBase& aBuf, CPolicyAssertion* aEle)

    {

    RBufWriteStream bufWs(aBuf);

    CleanupClosePushL(bufWs);

    WritePolicyL(aEle, bufWs);

    CleanupStack::PopAndDestroy(); // bufWs.Close();

//    TPtrC8 p = aBuf.Ptr(0);

//    TInt size(p.Length());

    iNamespcaes.Reset();

    return aBuf.Ptr(0);

    }

HBufC8* CWSPolicyWriter::WriteAllAsXMlL(CPolicyAssertion* aPolicy)

{

   if(!aPolicy)

    return NULL;

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

    CleanupStack::PushL(pBuf);

    TPtrC8 p = WriteToBufL(*pBuf, aPolicy);

    TInt size(p.Length());

    HBufC8* pRet = NULL; //p.AllocL();   

    if (size > 0)

    {

        pRet = HBufC8::NewLC(size);

        TPtr8 retP = pRet->Des();

        retP.Copy(p.Ptr(),size);

        CleanupStack::Pop(); //pRet

        WriteToFileAllL(retP);            

    }

    CleanupStack::PopAndDestroy(); // pBuf;

    iNamespcaes.Reset();    

    return pRet;    

}

HBufC8* CWSPolicyWriter::WriteAllAsXmlL(CSenElement* /*aXml*/)

{

return NULL;    

}

TInt CWSPolicyWriter::WritePolicyL(CPolicyAssertion* aEle, RWriteStream& aWriteStream)

{

    aWriteStream.WriteL(KStartElement);

    aWriteStream.WriteL(KWspPolicyPrefix);

    TPtrC8 name(KSenXmlNsAttNamePlusColonWsp);

    if(IsNamespaceAdded(name) == KErrNotFound)

    {

        aWriteStream.WriteL(KSenXmlNsAttNamePlusColonWsp); //namespace

        aWriteStream.WriteL(KSenEqualsDblQuot);

        aWriteStream.WriteL(KWsPolicyNsUri); //namespace

        aWriteStream.WriteL(KSenDblQuot);

        TPtrC8 nameuri(KWsPolicyNsUri);

        AddNameSpaceL(name, nameuri);	//codescannerwarnings

    }

/*

		if (policy.getId() != null) {

			writer.writeNamespace(PolicyConstants.WSU_NAMESPACE_PREFIX,

					PolicyConstants.WSU_NAMESPACE_URI);

			writer.setPrefix(PolicyConstants.WSU_NAMESPACE_PREFIX,

					PolicyConstants.WSU_NAMESPACE_URI);

			writer.writeAttribute("wsu", PolicyConstants.WSU_NAMESPACE_URI,

					"Id", policy.getId());

		}

*/

		RPolicyTerms terms = aEle->GetTerms();

		if(terms.Count() > 0)

		{

		    aWriteStream.WriteL(KSenGreaterThan);		    

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

       		{

			MAssertion* term = terms[i];

			WriteAssertionL(term, aWriteStream);

		    }

		}

		else

		{

		    aWriteStream.WriteL(KSenGreaterThan);

		}

        aWriteStream.WriteL(KSenLessThanSlash);

        aWriteStream.WriteL(KWspPolicyPrefix);

		aWriteStream.WriteL(KSenGreaterThan);

        return KErrNone;

}

TInt CWSPolicyWriter::WriteAndAssertionL(CAndCompositeAssertion* aEle, RWriteStream& aWriteStream)

{

    aWriteStream.WriteL(KStartElement);

    aWriteStream.WriteL(KWspAndPrefix);

    aWriteStream.WriteL(KSenGreaterThan);

	RPolicyTerms terms = aEle->GetTerms();

	if(terms.Count() > 0)

	{

    	WriteTermsL(terms, aWriteStream);

	}

    aWriteStream.WriteL(KSenLessThanSlash);

    aWriteStream.WriteL(KWspAndPrefix);

    aWriteStream.WriteL(KSenGreaterThan);  

    return KErrNone; 

}

TInt CWSPolicyWriter::WriteXorAssertionL(CXorCompositeAssertion* aEle, RWriteStream& aWriteStream)

{

    aWriteStream.WriteL(KStartElement);

    aWriteStream.WriteL(KWspXorPrefix);

    aWriteStream.WriteL(KSenGreaterThan);

	RPolicyTerms terms = aEle->GetTerms();

	if(terms.Count() > 0)

	{

    	WriteTermsL(terms, aWriteStream);

	}

    aWriteStream.WriteL(KSenLessThanSlash);

    aWriteStream.WriteL(KWspXorPrefix);

    aWriteStream.WriteL(KSenGreaterThan);  

    return KErrNone; 

}

TInt CWSPolicyWriter::WriteAssertionL(MAssertion* aEle, RWriteStream& aWriteStream)

{

    if(!aEle)

        return KErrNone; 

		if (aEle->Type() == EPrimitiveType)

		{

			WritePrimitiveAssertionL((CPrimitiveAssertion*) aEle, aWriteStream);

		}

		else if (aEle->Type() == ECompositeXorType)

		{

			WriteXorAssertionL((CXorCompositeAssertion*) aEle,	aWriteStream);

		}

		else if (aEle->Type()== EPolicyReferenceType ) 

		{

			WritePolicyReferenceL((CPolicyReferenceAssertion*)aEle, aWriteStream);

		} 

		else if (aEle->Type() == ECompositePolicyType)

		{

			WritePolicyL((CPolicyAssertion*) aEle, aWriteStream);

		}

		else if (aEle->Type() == ECompositeAndType)

		{

			WriteAndAssertionL((CAndCompositeAssertion*) aEle,aWriteStream);

		} 

		else 

		{

		}

        return KErrNone;

}

TInt CWSPolicyWriter::WritePolicyReferenceL(CPolicyReferenceAssertion* aAssertion, RWriteStream& aWriteStream)

{

    aWriteStream.WriteL(KStartElement);

    aWriteStream.WriteL(KWspPolicyReferencePrefix);

    aWriteStream.WriteL(KSenSpace);

    aWriteStream.WriteL(KWspPolicyReferenceUri);

    aWriteStream.WriteL(KSenEqualsDblQuot);

    aWriteStream.WriteL(aAssertion->PolicyUri());

    aWriteStream.WriteL(KSenDblQuot);

    aWriteStream.WriteL(KSenGreaterThan);

    aWriteStream.WriteL(KSenLessThanSlash);

    aWriteStream.WriteL(KWspPolicyReferencePrefix);

    aWriteStream.WriteL(KSenGreaterThan);  

    return KErrNone;

}

TInt CWSPolicyWriter::WritePrimitiveAssertionL(CPrimitiveAssertion* aAssertion, RWriteStream& aWriteStream)

{

	TPtrC8 qname = aAssertion->Name();

	aWriteStream.WriteL(KStartElement);

    aWriteStream.WriteL(qname);

    TBuf8<200> name(KSenXmlNsAttNamePlusColon);

    name.Append(aAssertion->iQname->Prefix());

//    if(IsNamespaceAdded(name) == KErrNotFound)

    {

        aWriteStream.WriteL(name); //namespace

        aWriteStream.WriteL(KSenEqualsDblQuot);

        aWriteStream.WriteL(aAssertion->iQname->Uri()); //namespace

        aWriteStream.WriteL(KSenDblQuot);

        TPtrC8 nameuri(aAssertion->iQname->Uri());

        AddNameSpaceL(name, nameuri);	//codescannerwarnings

    }

	WriteAttributesL(aAssertion, aWriteStream);

    aWriteStream.WriteL(KSenGreaterThan);	

    TPtrC8 strValue = aAssertion->StrValue();    

	if (strValue != KNullDesC8()) {

		aWriteStream.WriteL(strValue);

	}

	RPolicyTerms terms = aAssertion->GetTerms();

	if(terms.Count() > 0)

	{

    	WriteTermsL(terms, aWriteStream);

	}

	aWriteStream.WriteL(KSenLessThanSlash);

    aWriteStream.WriteL(qname);

    aWriteStream.WriteL(KSenGreaterThan);   

    return KErrNone; 

}

TInt CWSPolicyWriter::WriteTermsL(RPointerArray<MAssertion>& aTerms, RWriteStream& aWriteStream)

{

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

    {

        CAssertion* obj = (CAssertion*)aTerms[i];

        if(obj)

        {

            WriteAssertionL(obj, aWriteStream);

        }

    }

    return KErrNone;

}

void WriteAttrToL(RWriteStream& aWriteStream, TDesC8& aName, TDesC8& aValue)

{

    aWriteStream.WriteL(KSenSpace);

    aWriteStream.WriteL(aName);

    aWriteStream.WriteL(KSenEqualsDblQuot);

    aWriteStream.WriteL(aValue);

    aWriteStream.WriteL(KSenDblQuot);    

}

void CWSPolicyWriter::WriteAttributesL(CPrimitiveAssertion* aAssertion, RWriteStream& aWriteStream)

{

	RAttributeMap& attributes = aAssertion->Attributes();

	TInt attCount = attributes.Count();

	for (TInt i=0; i<attCount; i++ )

    {

        const TDesC8* nameptr= attributes.KeyAt(i);

        const TDesC8* valptr= attributes.ValueAt(i);

        HBufC8* tt = nameptr->AllocL();

        HBufC8* tt2 = valptr->AllocL();

        TPtrC8 name =  tt->Des();   

        TPtrC8 value =  tt2->Des();

        WriteAttrToL(aWriteStream, name, value);

        delete tt;

        delete tt2;

    }

}

TPtrC8 CWSPolicyWriter::GetAttrib(TPtrC8 /*aReference*/, CSenElement* /*aEle*/)

{

    return KNullDesC8();

}

TBool CWSPolicyWriter::IsNamespaceAdded(TPtrC8 aName)

{

    return iNamespcaes.Find(aName);

}

TInt CWSPolicyWriter::AddNameSpaceL(TPtrC8 aName, TPtrC8 aUri)	//codescannerwarnings

{

    if(IsNamespaceAdded(aName) == KErrNotFound)

    {

        return iNamespcaes.Append(aName.AllocL(),aUri.AllocL());            

    }

    return KErrGeneral;

}

//#ifdef _SENDEBUG  

void CWSPolicyWriter::WriteToFileAllL(CSenElement* aXml)

{

  RFs fss;

  User::LeaveIfError(fss.Connect());

  CleanupClosePushL(fss);

  TBuf<255> file;

  _LIT( KFileName, "c:\\logs\\normalizer%d.xml");

  file.Format(KFileName, count);

  count++;

  TPtrC OutputFile(file);

   RFile  xmlFile;

   xmlFile.Replace(fss , OutputFile, EFileWrite );

   HBufC8* temp = aXml->AsXmlL();

   CleanupStack::PushL(temp);

   xmlFile.Write(temp->Des());

   xmlFile.Close();

   CleanupStack::PopAndDestroy(temp);

   CleanupStack::PopAndDestroy(1); // fss

}

void CWSPolicyWriter::WriteToFileAllL(TDesC8& aXml)

{

  RFs fss;

  User::LeaveIfError(fss.Connect());

  CleanupClosePushL(fss);

  TBuf<255> file;

  _LIT( KFileName, "c:\\logs\\normalizer%d.xml");

  file.Format(KFileName, count);

  count++;

  TPtrC OutputFile(file);

   RFile  xmlFile;

   xmlFile.Replace(fss , OutputFile, EFileWrite );

   xmlFile.Write(aXml);

   xmlFile.Close();

   CleanupStack::PopAndDestroy(1); // fss

}

//#endif