// Copyright (c) 2005-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:
// Verification Test SDP
// 
//

#include <btsdp.h>
#include "sdpkey.h"
#include "SDPDatabase.h"
#include <btmanclient.h>

#ifndef __SDPSAS_H__
#define __SDPSAS_H__

#ifndef __ES_SOCK_H__
#include <es_sock.h>
#endif

#ifndef __BT_SOCK_H__
#include <bt_sock.h>
#endif


// Constants
const TInt KMaxRequestableUUIDs	= 12;
const TInt KMaxNumRecordHandles	= 50;
const TInt KMaxNumBrowseUUIDs	= 50;
const TInt KNumSDPServiceTests = 6;
const TInt KNumSDPAttributeTests = 23;
const TInt KNumSDPServiceAttributeTests = 24;
const TInt KMaxAttributeListByteCount = 200;

// SDP test base class. Provides untilities for running raw SDP tests over
// L2CAP. 
class CSdpTestBase : public CBase
	{
public:
	enum TUuidType {EUuid16,
					EUuid32,
					EUuid128,
					EUuidInvalid} ;
	CSdpTestBase(CConsoleBase& aConsole);
	~CSdpTestBase();

	// Utility functions
	//
	void StartSDPServerL();
	void SendCloseL();
	void WaitForCloseL();
	void RegisterDatabaseInServerL(CSdpDatabase& aDb);
	void SdpConnectL();
	virtual	CSdpDatabase* BuildDbL() = 0;	// To be implemented according to test types.

protected:
	// SDP database stuff
	//
	RSdp iSdp;
	RSdpDatabase iSdpDatabase;
	CSdpDatabase* iTheDb;
	CConsoleBase& iConsole;
	RSocket iRawSock;	// Socket for sending raw bytes over L2CAP PSM 1 (SDP).

	TUint16 iRawTransactionId;	// Incremented to provide a unique ID for every query.

	};

// Class to represent the SDP header bytes
class TSDPHeader
{
public:
	TSDPHeader();
	TSDPHeader(TUint8 aPduId, TUint16 aTranId, TUint16 aLen);
	void AppendHeader(TDes8& aBuf);

	inline TUint8 GetPduUd(){return iPduId;}
	inline TUint16 GetTransactionId(){return iTransactionId;}
	inline TUint16 GetParamsLen(){return iParamLen;}
private:
	TUint8  iPduId;
	TUint16  iTransactionId;
	TUint16  iParamLen;
};

// Class to represent the SDP service request bytes
class TServiceRequest	// Note this doesn't contain continuation
	{
public:
	TServiceRequest();
	//TServiceRequest(TUint8* aDes, const TUint8* aUuid128, TUint16 aMaxRecordCount);
	TServiceRequest(TUint8* aDes, TUUID aUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxRecordCount);
	TServiceRequest(TUint8* aDes, CSdpSearchPattern& aSP, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxRecordCount);
	TServiceRequest(TUUID aUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxRecordCount);
	TServiceRequest(CSdpSearchPattern& aSP, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxRecordCount);
	void SetupDES();
	void SetUuidType(CSdpTestBase::TUuidType aUuidType);
	void AppendRequest(TDes8& aBuf);

	inline TUUID Uuid(){return iUuid;}
	inline CSdpSearchPattern* SP(){return iSP;}
	inline CSdpTestBase::TUuidType UuidType(){return iUuidType;}
	inline TUint16 MaxRecordCount(){return iMaxRecordCount;}
	inline TUint8* Des(){return iDes;}
private:
	TUint8  iDes[3];
	//TUint32	iUuid32;
	TUUID iUuid;
	CSdpSearchPattern* iSP;//for multiple uuid requests
	TUint16 iMaxRecordCount;
	CSdpTestBase::TUuidType iUuidType; //inticates which length of Uuid used
	TBool iAutoDes;
	};
	
// Class to represent the SDP attribute request bytes
class TAttributeRequest	
	{
public:
	TAttributeRequest();
	TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint8* aDes, TUint16 aAttributeId);
	TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint8* aDes, TUint32 aAttributeIdRange);
	TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint16 aAttributeId);
	TAttributeRequest(TUint32 aRecordHandle, TUint16 aMaxByteCount, TUint32 aAttributeIdRange);
	void SetupDES();
	void AppendRequest(TDes8& aBuf);

	inline TUint32 RecordHandle(){return iRecordHandle;}
	inline void SetRecordHandle(TUint16 aRecordHandle){iRecordHandle=aRecordHandle;}
	inline TUint16 MaxByteCount(){return iMaxByteCount;}
	inline TUint16 AttributeId(){return iAttributeId;}
	inline TUint32 AttributeIdRange(){return iAttributeIdRange;}
	inline TUint8* Des(){return iDes;}

private:
	TUint32 iRecordHandle;
	TUint16 iMaxByteCount;
	TUint8  iDes[3];
	TUint16	iAttributeId;
	TUint32	iAttributeIdRange;
	TBool iAutoDes;
	}; 

//
// TServiceAttributeRequest
//
class TServiceAttributeRequest
	{
public:
	TServiceAttributeRequest();

	//TServiceAttributeRequest(TUint8* aServiceDes, TUint16 aServiceUuid, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint16 aAttributeId);
	//TServiceAttributeRequest(TUint8* aServiceDes, TUint32 aServiceUuid, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint16 aAttributeId);
	TServiceAttributeRequest(TUint8* aServiceDes, TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint16 aAttributeId);
	TServiceAttributeRequest(TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint16 aAttributeId);

	//TServiceAttributeRequest(TUint8* aServiceDes, TUint16 aServiceUuid, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint32 aAttributeIdRange);
	//TServiceAttributeRequest(TUint8* aServiceDes, TUint32 aServiceUuid, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint32 aAttributeIdRange);
	TServiceAttributeRequest(TUint8* aServiceDes, TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint8* aAttribDes, TUint32 aAttributeIdRange);
	TServiceAttributeRequest(TUUID aServiceUuid, CSdpTestBase::TUuidType aUuidType, TUint16 aMaxByteCount, TUint32 aAttributeIdRange);

	void SetUuidType(CSdpTestBase::TUuidType aUuidType);
	void AppendRequest(TDes8& aBuf);

	inline TUint16 MaxByteCount(){return iAttributeRequest.MaxByteCount();}

	inline TServiceRequest& ServiceParams(){return iServiceRequest;}
	inline TAttributeRequest& AttributeParams(){return iAttributeRequest;}
private:
	//Have this as a combination of service and attribute requests
	//
	TServiceRequest iServiceRequest;
	TAttributeRequest iAttributeRequest;

	};



// Class for the SDP verification test group.
class CSdpVerificationTests : public CSdpTestBase , public MSdpElementBuilder
	{
public:
	static void RunTestL(CConsoleBase& aConsole);
	CSdpVerificationTests(CConsoleBase& aConsole);
	~CSdpVerificationTests();

	// Master 
	void RunMasterTestL();
	CSdpDatabase* BuildDbL();
	void PrintDb(CSdpDatabase& aDb, CConsoleBase& aConsole);
private:

	// Test functions
	void DoTestsL();
	void SDPQueryL();
	void RunSDPSearchL();
	void SDPServiceSearchL();
	void SDPAttributeSearchL();
	void SDPServiceAttributeSearch();
	void SDPBrowseTestL(TUuidType aUuidType);
	TBool AnotherQuery();
	TBool Continue();
	TInt GetUuidSize();
	void UpdateTestString();
	void FlogTestId();
	TInt MaxCountFoundAfterServiceSearchPatternOrWhatYouWill(TDesC8& aString);
	void FlogParsedPDUHeader(TDesC8& aString);
	void FlogString(const TText* aLineStart, TDesC8& aString);
	void FlogReadString(TDesC8& aString);
	void FlogContinuationString(TDesC8&aString);
	void FlogWriteString(TDesC8& aString);
	void WaitForStartSignalL();
	void SendStartSignalL();
	void PromptedGetch();

	// Browse tests
	//
	void BuildBrowseDbL(CConsoleBase&  aConsole);

	// Initialisation
	void SetUpServiceTestParams();
	void SetUpAttributeTestParams();
	void SetUpServiceAttributeTestParams();

	// Process results
	TInt ProcessSearchResults(TDesC8& aResult1, TDesC8& aResult2);
	TInt ProcessServiceSearchResults(TDesC8& aResult1, TDesC8& aResult2);
	TInt ProcessAttributeSearchResults(TDesC8& aResult1, TDesC8& aResult2);
	TInt ProcessServiceAttributeSearchResults(TDesC8& aResult1, TDesC8& aResult2);

	// MSdpElementBuilder implementations
	MSdpElementBuilder* BuildUintL(const TDesC8& aUint);
	MSdpElementBuilder* BuildUUIDL(const TUUID& aUUID);
	MSdpElementBuilder* BuildStringL(const TDesC8& aString);
	MSdpElementBuilder* BuildDESL();  // Must not return NULL
	MSdpElementBuilder* BuildURLL(const TDesC8& aURL);
	MSdpElementBuilder* StartListL();
	MSdpElementBuilder* EndListL();
	MSdpElementBuilder* BuildNilL();


	// Private data
	//
	TServiceRequest iServiceTests[KNumSDPServiceTests + KNumSDPAttributeTests];	// Holds the service test params.
																				// Attribute tests involve a service query as well.
	TAttributeRequest iAttributeTests[KNumSDPAttributeTests];	//Holds the attribute test params
	TServiceAttributeRequest iServiceAttributeTests[KNumSDPServiceAttributeTests];
	
	CSdpSearchPattern* iSP;

	
	TUint8 iContinuationBuffer[KSdpContinuationStateMaxLength];	// Buffer for continuation state
	TUint8 iContLength;	// Continuation state length
	TBuf8<14000>	iContinuationStore;	// Holds the growing buffer while the requests 
									// are returning one by one
	TUint32 iAttributeTestServiceRecordHandle;
	TUint32 iBrowseTestServiceRecordHandle[KMaxNumRecordHandles];
	TUint32 iBrowseTestNumRecordHandlesStored;
	TUUID iBrowseUUID[KMaxNumBrowseUUIDs];
	TInt iNumBrowseUUIDs;

	enum TTestType {EServiceRequest,
					EServiceAttributeRequest,
					EServiceSearchAttributeRequest} ;

	TTestType iType;	// The type of test currently being run
	TInt8 iQueryIndex;	// For the tests that have 2 queries.
	TTestType	iQueryState;
	TUint iTestNum;		// THe number of test running.
	TBool iNeedAttributeId;
	TInt iBuildingList;
	TInt iBrowseIter;
	TInt iIndent;
	TInt iRequestMaxCount;
	TInt iRequestMaxCount1;
	TInt iRequestMaxCount2;
	TInt iRequestTransId;
	TInt iRequestTransId1;
	TInt iRequestTransId2;
	TBool iNeedMoreRecordHandles;
	CSdpTestBase::TUuidType iUuidType; //indicates which length of Uuid to be used
	TBuf<77> iTestName;
	};

class CBrowseResponseBuilder : public CBase, public MSdpElementBuilder
	{
public:
		CBrowseResponseBuilder(TDes& aTestName, TInt aBrowseIter, CSdpSearchPattern& aBrowseSP);
		~CBrowseResponseBuilder();
		MSdpElementBuilder* BuildUintL(const TDesC8& aUint);
		MSdpElementBuilder* BuildUUIDL(const TUUID& aUUID);
 		MSdpElementBuilder* BuildDESL();  // Must not return NULL
		MSdpElementBuilder* StartListL();
		MSdpElementBuilder* EndListL();
private:
	TDes& iTestName;
	TInt iBrowseIter;
	TBool iNeedAttributeId;
	TInt iBuildingList;
	CSdpSearchPattern& iBrowseSP;
	};


class CPrintBuilder : public CBase, public MSdpElementBuilder
	{
public:
	CPrintBuilder(CConsoleBase& aConsole);
	~CPrintBuilder();

	void HexDumpVT(const TDesC8& aDes);
	MSdpElementBuilder* BuildUnknown(TUint8 aType, TUint8 aSizeDesc, const TDesC8& aData);
	MSdpElementBuilder* BuildUintL(const TDesC8& aUint);
	MSdpElementBuilder* BuildIntL(const TDesC8& aUint);
	MSdpElementBuilder* BuildUUIDL(const TUUID& aUUID);
	MSdpElementBuilder* BuildBooleanL(TBool aBool);
	MSdpElementBuilder* BuildStringL(const TDesC8& aString);
	MSdpElementBuilder* BuildDESL();  // Must not return NULL
	MSdpElementBuilder* BuildDEAL();  // Must not return NULL
	MSdpElementBuilder* BuildURLL(const TDesC8& aURL);
	MSdpElementBuilder* StartListL();
	MSdpElementBuilder* EndListL();
	MSdpElementBuilder* BuildNilL();

private:
	TInt iIndent;
	CConsoleBase& iConsole;
	};
#endif