// Copyright (c) 2008-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:

//

// System includes

#include <e32std.h>

#include <http/thttptable.h>

#include <upnp/tupnptable.h>

// Local includes

#include "CHeaderField.h"

#include "CHeaders.h"

#include "rhttpheaders.h"

#include "tupnpmessagepanic.h"

CHeaders* CHeaders::NewL(CHeaderCodec& aCodec)

	{

	CHeaders* me = new(ELeave)CHeaders(aCodec);

	return me;

	}

CHeaders::~CHeaders()

	{

	PurgeFields();

	iFields.Close();

	}

RHTTPHeaders CHeaders::Handle()

	{	

	RHTTPHeaders handle;

	handle.iImplementation = this; 

	return handle;

	}

// create or append a field part for the named field and assigned value

void CHeaders::SetFieldL(RStringF aFieldName, THTTPHdrVal aFieldValue)

	{

	CHeaderField& field = CreateOrLookupFieldL(aFieldName);

	// Create a part for the value supplied

	CHeaderFieldPart* part = CHeaderFieldPart::NewL(aFieldValue);

	CleanupStack::PushL(part);

	field.AddPartL(part);

	CleanupStack::Pop(part);

	}

// create or append a field part with parameter, for the specified field, parameter and associated values

void CHeaders::SetFieldL(RStringF aFieldName, THTTPHdrVal aFieldValue,

						 RStringF aParamName, THTTPHdrVal aParamValue)

	{

	CHeaderField& field = CreateOrLookupFieldL(aFieldName);

	// Check whether a part with the supplied value already exists, if so then the API semantics are that

	// an additional parameter should be set on that part. Otherwise a new part will be created.

	THeaderFieldPartIter iter = field.PartsL();

	iter.First();

	CHeaderFieldPart* part = NULL;

	while (!iter.AtEnd())

		{

		const CHeaderFieldPart* pt = iter();

		if (pt->Value() == aFieldValue)

			part = CONST_CAST(CHeaderFieldPart*, pt);

		++iter;

		}

	// Create a part only if the match didn't occur

	if (!part)

		{

		part = CHeaderFieldPart::NewL(aFieldValue);

		CleanupStack::PushL(part);

		field.AddPartL(part);

		CleanupStack::Pop(part);

		}

	// Create a parameter for the value supplied

	CHeaderFieldParam* param = CHeaderFieldParam::NewL(aParamName, aParamValue);

	CleanupStack::PushL(param);

	part->AddParamL(param);

	CleanupStack::Pop(param);

	}

// Set a named field in the header to contain the supplied Raw data. Any existing header field of

// this name will be lost.

void CHeaders::SetRawFieldL(RStringF aFieldName, const TDesC8& aRawFieldData, const TDesC8& aFieldSeparator)

	{

	// See if field exists

	TInt idx = LocateFieldName(aFieldName);

	if (idx == KErrNotFound)

		{

		// create a new one using the field name

		CHeaderField* hdr = CHeaderField::NewL(aFieldName, *this, aRawFieldData);

		CleanupStack::PushL(hdr);

		DoInsertInNameOrderL(hdr, aFieldName);

		CleanupStack::Pop(hdr); 

		}

	else

		{

		CHeaderField* field = iFields[idx].iField;

		TPtrC8 originalRawData;

		field->RawDataL(originalRawData);

		// add the new raw data to the existing field using the aFieldSeparator param as a separator

		HBufC8* newRawDataBuf = HBufC8::NewLC(originalRawData.Length() + aFieldSeparator.Length() + aRawFieldData.Length());

		TPtr8 newRawDataPtr = newRawDataBuf->Des();

		newRawDataPtr.Append(originalRawData);

		newRawDataPtr.Append(aFieldSeparator);

		newRawDataPtr.Append(aRawFieldData);

		field->BeginRawDataL();

		field->WriteRawDataL(*newRawDataBuf);

		field->CommitRawData();

		CleanupStack::PopAndDestroy(newRawDataBuf);

		}	

	}

// Remove, entirely, the named header field from the header collection. All its parts and

// associated parameters (where they exist) are also removed

TInt CHeaders::RemoveField(RStringF aFieldName)

	{

	// Locate the name first - give up straight away if the field isn't found

	TInt idx = LocateFieldName(aFieldName);

	if (idx < 0)

		return idx;

	__ASSERT_DEBUG(idx < iFields.Count(), TUPnPMessagePanic::Panic(TUPnPMessagePanic::EHeaderFieldMissing));

	// destroy the header field

	CHeaderField* field = iFields[idx].iField;

	iFields.Remove(idx);

	delete field;

	return KErrNone;

	}

TInt CHeaders::RemoveFieldPartL(RStringF aFieldName, TInt aIndex)

	{

	TInt idx = LocateFieldName(aFieldName);

	if (idx == KErrNotFound)

		return idx;

	CHeaderField* field = iFields[idx].iField;

	field->RemovePartL(aIndex);

	if (field->NumPartsL() == 0)

		{

		iFields.Remove(idx);

		delete field;

		}

	return KErrNone;

	}

void CHeaders::RemoveAllFields()

	{

	PurgeFields();

	iFields.Reset();

	}

// Obtain the number of parts in the named header field's value, Simple headers are created with a single part

// following one call to SetFieldL. Subsequent calls to SetFieldL create additional parts with the field exists

// already

TInt CHeaders::FieldPartsL(RStringF aFieldName) const

	{

	TInt idx = LocateFieldName(aFieldName);

	if (idx == KErrNotFound)

		return 0;

	CHeaderField* field = iFields[idx].iField;

	return field->NumPartsL();

	}

// Obtain the named header field's value.  Optionally, the index of a part within the field

// may be specified. Parts are indexed from zero

TInt CHeaders::GetField(RStringF aFieldName, TInt aPartIdx, THTTPHdrVal& aHeaderValue) const

	{

	TInt error = KErrNone;

	CHeaderFieldPart* part = NULL;

	TRAPD(err, part = GetFieldPartL(aFieldName, aPartIdx));

	if (err)

		return err;

	if (part)

		aHeaderValue = part->Value();

	else

		error = KErrNotFound;

	return error;

	}

// Obtain the raw representation of the named header field's value.

TInt CHeaders::GetRawField(RStringF aFieldName, TPtrC8& aRawFieldData) const

	{

	TInt idx = LocateFieldName(aFieldName);

	if (idx < 0)

		return idx;

	CHeaderField* field = iFields[idx].iField;

	TRAPD(err,field->RawDataL(aRawFieldData));

	if (err == KErrNone)

		{

		TInt newLinePos = aRawFieldData.Locate('\n');

		if (newLinePos != KErrNotFound)

			{

			aRawFieldData.Set(aRawFieldData.Left(newLinePos));

			}

		}

	return err;

	}

// Obtain the value of a named parameter, associated with the named header field.  An optional index to a part

// within the header field may be supplied, if not it is assumed that it is the first part

THTTPHdrVal CHeaders::GetParam(RStringF aFieldName, RStringF aParamName, 

							   THTTPHdrVal& aValue, TInt aPartIdx) const

	{

	CHeaderFieldParam* param = GetFieldParameter(aFieldName, aParamName, aPartIdx);

	if (param == NULL)

		return KErrNotFound;

	aValue =  param->Value();

	return 0;

	}

// Set a param, overwriting one if it exists

void CHeaders::SetParamL(RStringF aFieldName, RStringF aParamName,THTTPHdrVal aParamValue,  TInt aPartIdx)

	{

	// Locate the name first

	TInt idx = LocateFieldName(aFieldName);

	User::LeaveIfError(idx);

	CHeaderField* field = iFields[idx].iField;

	CHeaderFieldPart* part = field->PartL(aPartIdx);

	CHeaderFieldParam* param = CHeaderFieldParam::NewL(aParamName, aParamValue);

	CleanupStack::PushL(param);

	part->AddParamL(param);

	CleanupStack::Pop(param);

	}

// create an iterator initialised for this header collection

THTTPHdrFieldIter CHeaders::Fields() const

	{

	return THTTPHdrFieldIter(this);

	}

// Obtain the index in the CHeaderField/RStringF arrays for the named header

TInt CHeaders::LocateFieldName(RStringF aHeaderName) const

	{

	// Locate the name first in the array of field names

	const TInt count = iFields.Count();

	for (TInt ii = 0; ii < count; ++ii)

		{

		if (iFields[ii].iFieldName == aHeaderName)

			return ii;

		}

	return KErrNotFound;

	}

// Check if a named header field exists. If so, return it. If not, create it.

CHeaderField& CHeaders::CreateOrLookupFieldL(RStringF aFieldName)

	{

	// Locate the name first

	TInt idx = LocateFieldName(aFieldName);

	// If the header was found, return it.  If no header matched, create

	// one for that field name

	CHeaderField* found = NULL;

	if (idx != KErrNotFound)

		{

		found = iFields[idx].iField;

		}

	else

		{

		CHeaderField* hdr = CHeaderField::NewL(aFieldName, *this);

		CleanupStack::PushL(hdr);

		DoInsertInNameOrderL(hdr, aFieldName);

		CleanupStack::Pop(hdr);

		found = hdr;

		}

	return *found;

	}

// Get the indexed part of the named field, if it exists

CHeaderFieldPart* CHeaders::GetFieldPartL(RStringF aFieldName, TInt aPartIdx) const

	{

	// check the field really exists

	TInt idx = LocateFieldName(aFieldName);

	User::LeaveIfError(idx);

	CHeaderField* field = iFields[idx].iField;

	CHeaderFieldPart* part = field->PartL(aPartIdx);

	return part;

	}

// Get the named parameter from the named field, if it exists

CHeaderFieldParam* CHeaders::GetFieldParameter(RStringF aFieldName, RStringF aParamName, TInt aPartIdx) const

	{

	// get the part and look up the named parameter

	CHeaderFieldPart* part = NULL;

	TRAPD(err, part = GetFieldPartL(aFieldName, aPartIdx));

	if (part && !err)

		return part->Parameter(aParamName);

	if (err == KErrNotFound)

		return NULL;

	else

		{

		// find out what circumstances this might occur in.  non-existent field is fine;

		// however if GetFieldPartL left then there might be a decoding error that should

		// be reported somehow.

		__DEBUGGER();

		return NULL;

		}

	}

void CHeaders::DoInsertInNameOrderL(CHeaderField* aHeader, RStringF aHeaderName)

	{

	THeaderFieldNamePair field;

	field.iFieldName = aHeaderName;

	field.iField = aHeader;

	TLinearOrder<THeaderFieldNamePair> sortKey(THeaderFieldNamePair::CompareFieldNames);

	User::LeaveIfError(iFields.InsertInOrder(field,sortKey));

	}

TInt CHeaders::THeaderFieldNamePair::CompareFieldNames(const THeaderFieldNamePair& aField1, 

													   const THeaderFieldNamePair& aField2)

	{

	TInt val1 = KErrNone;

	TInt val2 = KErrNone;

	RStringF header1 = aField1.iFieldName;

	RStringPool pool1 = aField1.iFieldName.Pool();

	RStringF nts1 = pool1.StringF(UPnP::ENTS, TUPnPTable::Table());

	RStringF nt1 = pool1.StringF(UPnP::ENT, TUPnPTable::Table());

	RStringF usn1 = pool1.StringF(UPnP::EUSN, TUPnPTable::Table());

	RStringF mx1 = pool1.StringF(UPnP::EMX, TUPnPTable::Table());

	RStringF st1 = pool1.StringF(UPnP::EST, TUPnPTable::Table());

	RStringF timeout1 = pool1.StringF(UPnP::ETimeout, TUPnPTable::Table());

	RStringF seq1 = pool1.StringF(UPnP::ESEQ, TUPnPTable::Table());

	RStringF man1 = pool1.StringF(UPnP::EMAN, TUPnPTable::Table());

	RStringF soapaction1 = pool1.StringF(UPnP::ESoapAction, TUPnPTable::Table());

	RStringF ext1 = pool1.StringF(UPnP::EExt, TUPnPTable::Table());

	RStringF sid1 = pool1.StringF(UPnP::ESID, TUPnPTable::Table());

	RStringF callback1 = pool1.StringF(UPnP::ECallback, TUPnPTable::Table());

	RStringF header2 = aField2.iFieldName;

	RStringPool pool2 = aField2.iFieldName.Pool();

	RStringF nts2 = pool2.StringF(UPnP::ENTS, TUPnPTable::Table());

	RStringF nt2 = pool2.StringF(UPnP::ENT, TUPnPTable::Table());

	RStringF usn2 = pool2.StringF(UPnP::EUSN, TUPnPTable::Table());

	RStringF mx2 = pool2.StringF(UPnP::EMX, TUPnPTable::Table());

	RStringF st2 = pool2.StringF(UPnP::EST, TUPnPTable::Table());

	RStringF timeout2 = pool2.StringF(UPnP::ETimeout, TUPnPTable::Table());

	RStringF seq2 = pool2.StringF(UPnP::ESEQ, TUPnPTable::Table());

	RStringF man2 = pool2.StringF(UPnP::EMAN, TUPnPTable::Table());

	RStringF soapaction2 = pool2.StringF(UPnP::ESoapAction, TUPnPTable::Table());

	RStringF ext2 = pool2.StringF(UPnP::EExt, TUPnPTable::Table());

	RStringF sid2 = pool2.StringF(UPnP::ESID, TUPnPTable::Table());

	RStringF callback2 = pool2.StringF(UPnP::ECallback, TUPnPTable::Table());

	if(

	   ((header1.DesC().Compare(nts1.DesC()) == 0)||(header1.DesC().Compare(nt1.DesC()) == 0)||

	   (header1.DesC().Compare(usn1.DesC()) == 0)||(header1.DesC().Compare(mx1.DesC()) == 0)||

	   (header1.DesC().Compare(st1.DesC()) == 0)||(header1.DesC().Compare(timeout1.DesC()) == 0)||

	   (header1.DesC().Compare(seq1.DesC()) == 0)||(header1.DesC().Compare(man1.DesC()) == 0)||

	   (header1.DesC().Compare(soapaction1.DesC()) == 0)||(header1.DesC().Compare(ext1.DesC()) == 0)||

	   (header1.DesC().Compare(sid1.DesC()) == 0)||(header1.DesC().Compare(callback1.DesC()) == 0))&&

	   ((header2.DesC().Compare(nts2.DesC()) == 0)||(header2.DesC().Compare(nt2.DesC()) == 0)||

	   (header2.DesC().Compare(usn2.DesC()) == 0)||(header2.DesC().Compare(mx2.DesC()) == 0)||

	   (header2.DesC().Compare(st2.DesC()) == 0)||(header2.DesC().Compare(timeout2.DesC()) == 0)||

	   (header2.DesC().Compare(seq2.DesC()) == 0)||(header1.DesC().Compare(man2.DesC()) == 0)||

	   (header2.DesC().Compare(soapaction2.DesC()) == 0)||(header2.DesC().Compare(ext2.DesC()) == 0)||

	   (header2.DesC().Compare(sid2.DesC()) == 0)||(header2.DesC().Compare(callback2.DesC()) == 0))

	  )

		{

		val1 = aField1.iFieldName.Index(TUPnPTable::Table());

		val2 = aField2.iFieldName.Index(TUPnPTable::Table());

		}

	else

		{

		val1 = aField1.iFieldName.Index(THTTPTable::Table());

		val2 = aField2.iFieldName.Index(THTTPTable::Table());

		}

	if (val1 != KErrNotFound && val2 != KErrNotFound)

		return val1 - val2;

	else if (val1 != KErrNotFound)

		return -1;

	else if (val2 != KErrNotFound)

		return 1;

	else

		return aField1.iFieldName.DesC().Ptr() - 

			aField2.iFieldName.DesC().Ptr();

	}

void CHeaders::PurgeFields()

	{

	const TInt count = iFields.Count();

	for (TInt ii = 0; ii< count; ++ii)

		{

		delete iFields[ii].iField;

		}

	}