// Copyright (c) 2000-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 <es_sock.h>
#include <btsdp.h>
#include <e32des8.h>
#include <bluetooth/logger.h>

#include "SDPDatabase.h"
#include "DataEncoder.h"
#include "EncoderVisitor.h"

#ifdef __FLOG_ACTIVE
_LIT8(KLogComponent, LOG_COMPONENT_SDPDATABASE);
#endif

void Panic(TSdpDatabasePanics aCode)
	{
	User::Panic(KSdpDatabasePanicName, aCode);
	}

// Class CSdpDatabase 

EXPORT_C CSdpDatabase* CSdpDatabase::NewLC()
/**
Creates a CSdpDatabase object, but leaves on the cleanup stack.

@return Pointer to the created CSdpDatabase object
*/
	{
	LOG_STATIC_FUNC
	CSdpDatabase* self = new(ELeave) CSdpDatabase;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

EXPORT_C CSdpDatabase* CSdpDatabase::NewL()
/**
Creates a CSdpDatabase object.(Does NOT leave it on the cleanup stack.)

@return Pointer to the created CSdpDatabase object
*/
	{
	LOG_STATIC_FUNC
	CSdpDatabase* self = CSdpDatabase::NewLC();
	CleanupStack::Pop();
	return self;
	}

CSdpDatabase::CSdpDatabase()
: iCanAddRecord(ETrue), 
  iRecords(CSdpServRecord::LinkOffset()), 
  iNextFreeHandle(KSdpMinServRecordHandle)
	{
	CONNECT_LOGGER
	}

void CSdpDatabase::ConstructL()
	{
	LOG_FUNC
	}

EXPORT_C CSdpDatabase::~CSdpDatabase()
/** Destructor
*/
	{
	LOG_FUNC
	// Delete all records on the record list
	iRecords.ResetAndDestroy();
	CLOSE_LOGGER
	}

/** Adds a service record to this database.
@param aRecord The record being added
*/
EXPORT_C void CSdpDatabase::AddRecord(CSdpServRecord* aRecord)
	{
	LOG_FUNC
	iRecords.AddInOrder(*aRecord); //Panics if aRecord's handle is already bagged.
	//Must do this AFTER adding latest record...hence need for 'iCanAddRecord'
	iCanAddRecord = ReviseNextFreeHandle();
	}

/** Creates a new record on this database
@leave KErrSdpDatabaseFull implies no more spare handles
*/
EXPORT_C CSdpServRecord* CSdpDatabase::NewRecordL()
	{
	LOG_FUNC
	// Add a new record only if we have spare handles...
	// ...there are 2^32 - 0x10000 to choose from!
	if(!iCanAddRecord)
		{
		User::Leave(KErrSdpDatabaseFull);
		}

	CSdpServRecord* record = CSdpServRecord::NewL();
	CleanupStack::PushL(record);

	record
		->BuildUintL(TSdpIntBuf<TUint16>(0))
		->BuildUintL(TSdpIntBuf<TSdpServRecordHandle>(NextFreeHandle()));

	AddRecord(record);
	CleanupStack::Pop(); //record
	return record;
	}

/** Encodes complete database. */
EXPORT_C void CSdpDatabase::EncodeDbL()
	{
	LOG_FUNC
	for(TServRecordIter recIter(RecordIter()); recIter; recIter++)
		{// Iterate through records in Db
		for (TServAttrIter attrIter((*recIter).AttributeIter()); attrIter; attrIter++)
			{// iterate through attributes in record
			CSdpAttr* theAttr = &(*attrIter);
			CSdpAttrValue* theAttrValue = &(theAttr->Value());
			TUint size = TElementEncoder::EncodedSize(theAttrValue->Type(), 
													  theAttrValue->DataSize());

			HBufC8* outbuf = HBufC8::NewLC(size);
			TPtr8 writePtr = outbuf->Des();
			TElementEncoder theEncoder(writePtr);
			CAttrEncoderVisitor::EncodeAttributeL(theEncoder, (*attrIter).Value());
			theAttr->BuildEncodedL(writePtr);
			CleanupStack::PopAndDestroy(); //outbuf
			}
		}
	}

/** Dead function. Space filler for .def file (left in for BC)
*/
EXPORT_C void CSdpDatabase::ParseDbL_Obscelete_DoesNothing()
	{
	LOG_FUNC
	return;
	}

/** Returns the 'TSdpServRecordHandle' iNextFreeHandle.
@return the next free handle 
*/
EXPORT_C TSdpServRecordHandle CSdpDatabase::NextFreeHandle()
	{
	LOG_FUNC
	return iNextFreeHandle;
	}

/**	Finds a handle not used by any record in database.
	Starts at current next free handle value, and discovers if
	it is used by a record in the database. If so cycles it on one in
	in the allowed range, and checks again. This algorithm continues
	until an unused handle is found (=>return ETrue) or all handles
	have been checked and are found to be in use. (=>return EFalse)
	NB. We start by looking for the next available handle going upwards
	in value. Only if none are found do we return to the lower limit and
	search for "holes" below the last claimed handle. This should
	reduce processing time. We could have gone further and incremented
	iNextFreeHandle value before doing anything else, because it is likely
	that the current iNextFreeHandle will have just been used when this
	function is called
*/
TBool CSdpDatabase::ReviseNextFreeHandle()
	{
	LOG_FUNC
	if(iNextFreeHandle>KSdpMaxServRecordHandle||
		iNextFreeHandle<KSdpMinServRecordHandle)
		{
		iNextFreeHandle = KSdpMinServRecordHandle;
		}

	TSdpServRecordHandle origNextFreeHandle(iNextFreeHandle);
	for(TServRecordIter recIter(RecordIter()); recIter; recIter++)
		{// Iterate thru records in iDatabase
		if((*recIter).Handle()==iNextFreeHandle)
			{
			if(++iNextFreeHandle>KSdpMaxServRecordHandle)
				iNextFreeHandle = KSdpMinServRecordHandle;
			//We've run out of handles
			if(iNextFreeHandle==origNextFreeHandle)
				return EFalse;
			//Run through all records again to check for new incremented handle.
			recIter.SetToFirst();
			}
		}
	return ETrue;
	}


EXPORT_C CAttrUuidVisitor* CAttrUuidVisitor::NewL()
	{
	LOG_STATIC_FUNC
	CAttrUuidVisitor* self = new(ELeave)CAttrUuidVisitor();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
	}
	
EXPORT_C CAttrUuidVisitor::~CAttrUuidVisitor()
	{
	LOG_FUNC
	iUuidContainer.Close();
	}
	
EXPORT_C RUUIDContainer& CAttrUuidVisitor::GetUuids()
	{
	LOG_FUNC
	return iUuidContainer;
	}

void CAttrUuidVisitor::EncodeAttributeL(CSdpAttrValue& /*aSrcAttr*/)
	{
	LOG_FUNC
	__ASSERT_DEBUG(ETrue, User::Panic(_L("EncodeAttributeL() erroneously called"), KErrArgument));
	}
	
CAttrUuidVisitor::CAttrUuidVisitor()
	{
	LOG_FUNC
	iUuidContainer.Reset();
	}
	
void CAttrUuidVisitor::ConstructL()
	{
	LOG_FUNC
	}

// Implementation of MAttributeVisitor interface
void CAttrUuidVisitor::VisitAttributeL(CSdpAttr& /*aAttribute*/)
	{
	LOG_FUNC
	__ASSERT_DEBUG(ETrue, Panic(ESdpDatabaseVisitAttributeLErroneouslyCalled));
	}
	
void CAttrUuidVisitor::VisitAttributeValueL(CSdpAttrValue &aValue, TSdpElementType aType)
	{
	LOG_FUNC
	switch (aType)
		{
		case ETypeUUID:
			iUuidContainer.Add(aValue.UUID());
			break;
		case ETypeEncoded:
			{
			TPtrC8 ptr = aValue.Des();
			if(ptr.Length() == KSdpElemHdrTypeShift + KSizeOf16BitUUID)
				{
				// 16-bit UUID
				TUUID uuid = TUUID(BigEndian::Get16(&ptr[KSdpElemHdrTypeShift]));
				iUuidContainer.Add(uuid);
				}
			else if(ptr.Length() == KSdpElemHdrTypeShift + KSizeOf32BitUUID)
				{
				// 32-bit UUID
				TUUID uuid = TUUID(BigEndian::Get32(&ptr[KSdpElemHdrTypeShift]));
				iUuidContainer.Add(uuid);
				}
			else if(ptr.Length() == KSdpElemHdrTypeShift + KSizeOf128BitUUID)
				{
				// 128-bit UUID
				TUUID uuid = TUUID(BigEndian::Get32(&ptr[KSdpElemHdrTypeShift]),
								   BigEndian::Get32(&ptr[KSdpElemHdrTypeShift+sizeof(TUint32)]),
								   BigEndian::Get32(&ptr[KSdpElemHdrTypeShift+2*sizeof(TUint32)]),
								   BigEndian::Get32(&ptr[KSdpElemHdrTypeShift+3*sizeof(TUint32)]));
				iUuidContainer.Add(uuid);
				}
			else
				{
				// We don't support other UUIDs
				}
			}
			break;
		default:
			__ASSERT_DEBUG(ETrue, Panic(ESdpDatabaseUnexpectedAttributeType));
			break;
		}
	}

void CAttrUuidVisitor::StartListL(CSdpAttrValueList& /*aList*/)
	{
	LOG_FUNC
	}

void CAttrUuidVisitor::EndListL()
	{
	LOG_FUNC
	}