/*

* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:   ?Description

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include <LbsRequestor.h>

#include <LiwServiceHandler.h>

#include <LiwCommon.h>

#include <lbs.h>

#include "Tcomplugin.h"

using namespace LIW;

_LIT(LogFileName , "C:\\Notifications.txt") ;

//----------------------------------------------------------------------------

// CTestProvider :: Delete()

//----------------------------------------------------------------------------

void CTestProvider::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// CTestProvider::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt CTestProvider::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

        ENTRY("GetLocation" , CTestProvider :: GetLocation),

        ENTRY("LocationUpdates" , CTestProvider :: LocationUpdates),

        ENTRY("GetLocationAsynch" , CTestProvider :: GetLocationAsynch),

        ENTRY("ServiceFailed" , CTestProvider :: ServiceFailed),

        ENTRY("ServiceNotAvailable" , CTestProvider :: ServiceNotAvailable),

        ENTRY("StraySignalTrace" , CTestProvider :: StraySignal),

       	ENTRY("StraySignalGetLoc" , CTestProvider :: StraySignalGetLoc),

       	ENTRY("ConcurrentCallsGetLoc" , CTestProvider:: ConcurrentCallsGetLoc),

       	ENTRY("ConcurrentCallsTrace" , CTestProvider:: ConcurrentCallsTrace),

       	ENTRY("EmptyCancelTraceTest" , CTestProvider:: EmptyCancelTraceTest),

       	ENTRY("EmptyCancelGetLocTest" , CTestProvider:: EmptyCancelGetLocTest),

       	ENTRY("CancelWrongNotification1" , CTestProvider:: CancelWrongNotification1),

       	ENTRY("CancelWrongNotification2" , CTestProvider:: CancelWrongNotification2),

       	ENTRY("GetLocationCancel" , CTestProvider:: GetLocationCancel),

       	ENTRY("TraceLocationCancel" , CTestProvider:: TraceLocationCancel),

       	ENTRY("GetLocationTimedOut" , CTestProvider :: GetLocationTimedOut ),

       	ENTRY("BearingToTest" , CTestProvider :: BearingToTest),

       	ENTRY("FindDistance" , CTestProvider :: FindDistance),

       	ENTRY("FindDistanceAgain" , CTestProvider :: FindDistanceAgain),

       	ENTRY("GetLocationUpdateOpts" , CTestProvider :: GetLocationUpdateOpts),

       	ENTRY("MoveCoordinates" , CTestProvider :: MoveCoordinates),

       	ENTRY("GetLocationSynchWrongUpdateMapType" , CTestProvider :: GetLocationSynchWrongUpdateMapType),

       	ENTRY("CancelWithInvalidTransId" , CTestProvider ::CancelWithInvalidTransId),

       	ENTRY("getlocationPostionbased" , CTestProvider :: getlocationPostionbased),

       	ENTRY("getlocationPostionbasedwithupdateoption" , CTestProvider ::getlocationPostionbasedwithupdateoption),

       	ENTRY("getlocationPostionbasedpdateoption" , CTestProvider :: getlocationPostionbasedpdateoption),

       	ENTRY("GetLocationWrongInfoClass" , CTestProvider :: GetLocationWrongInfoClass),

       	ENTRY("TraceWrongInfoClass" , CTestProvider :: TraceWrongInfoClass),

       	ENTRY("GetLocNegativeUpdateoption" , CTestProvider :: GetLocNegativeUpdateoption),

       	ENTRY("TraceNegativeUpdateoption" , CTestProvider :: TraceNegativeUpdateoption),

       	ENTRY("TestWrongInterfaceName" , CTestProvider :: TestWrongInterfaceName),

       	ENTRY("TestAllApi" , CTestProvider :: TestAllApi),

       	ENTRY("CancelTwice" , CTestProvider :: CancelTwice),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

 class ASyncLocCBF : public MLiwNotifyCallback

{

	public :

	TInt iRetStatus ;

		TInt HandleNotifyL(

            TInt aCmdId,

            TInt aEventId,

            CLiwGenericParamList& aEventParamList,

            const CLiwGenericParamList& aInParamList) ;

		ASyncLocCBF() : iRetStatus(KErrGeneral)  //Default constructor 

			{

				;

			}

};

TInt ASyncLocCBF::HandleNotifyL(

            TInt aCmdId,

            TInt aEventId,

            CLiwGenericParamList& aEventParamList,

            const CLiwGenericParamList& aInParamList) 

{

	return 0;

}

TInt CTestProvider :: CancelTwice( CStifItemParser& /*aItem*/ )

{

__UHEAP_MARK ;

	CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

	// Input and output parameter list

	CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());

	CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;

	a.AppendL(crit);

	ServiceHandler->AttachL(a) ;

	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

	TInt pos = 0;

	const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

	if(!errorprm)

	{

		return KErrGeneral ;

	}

	_LIT8(KDataSource, "ILocation");

	 pos = 0 ;

	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

	if(!genericparm)

	{

		return KErrGeneral ;

	}

	MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

	TBuf8<20>CmdBuf(KCmdGetLocation) ;

	outputlist->Reset() ;

	inputlist->Reset() ;

	ASyncLocCBF* callBack = new(ELeave) ASyncLocCBF;

	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptASyncronous, callBack);

	pos = 0 ;

	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

	if(!ErrorParm)

	{

		return KErrGeneral ;

	}

	TInt reqerror = (ErrorParm->Value()).AsTInt32();

	pos = 0;

	_LIT8(KTransactionId, "TransactionID");

	const TLiwGenericParam *transid =  outputlist->FindFirst(pos ,KTransactionId ) ;

	if(!transid)

	{

		return KErrGeneral;

	}

	TInt32 trid = (transid->Value()).AsTInt32();

	outputlist->Reset() ;

	inputlist->Reset() ;

	inputlist->AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(trid)));

	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptCancel);

	ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

	if(!ErrorParm)

	{

		return KErrGeneral ;

	}

	reqerror = (ErrorParm->Value()).AsTInt32();

	/*if( SErrNotFound == reqerror )

		{

		reqerror = 0;	

		}*/

	//Call cancel again with same transaction id

	outputlist->Reset() ;

	inputlist->Reset() ;

	inputlist->AppendL(TLiwGenericParam(KTransactionId,TLiwVariant(trid-2)));

	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist,KLiwOptCancel);

	ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

	if(!ErrorParm)

	{

		return KErrGeneral ;

	}

	reqerror = (ErrorParm->Value()).AsTInt32();

	if( SErrNotFound == reqerror )

		{

		reqerror = 0;	

		}

	locinterface->Close() ;

	inputlist->Reset();

	outputlist->Reset();

	delete callBack;

	delete ServiceHandler ;

	a.ResetAndDestroy() ;

	a.Close() ;

	__UHEAP_MARKEND ;

	return reqerror ;

}

TInt CTestProvider :: TestAllApi( CStifItemParser& /*aItem*/ )

	{

	__UHEAP_MARK ;

	TInt start = User::CountAllocCells();

	RFile LogFile ;

	RFs LogSession ;

	TBuf8<50> data ;

	TRealFormat format ;

	 if(LogSession.Connect() != KErrNone)

	 {

	 	_LIT(KLog , "Failed to connect to file server") ;

	 	iLog->Log(KLog) ;

	 	return KErrGeneral ;

	 }

	if(LogFile.Open(LogSession ,LogFileName , EFileWrite | EFileShareAny )  == KErrNotFound)

	{

		if(LogFile.Create(LogSession ,LogFileName , EFileWrite | EFileShareAny ) != KErrNone)

		{

		 	_LIT(KLog , "Failed to create notifications log file") ;

		 	iLog->Log(KLog) ;

		 	return KErrGeneral ;

		}

	}

	_LIT(KLog , "In CTGetLocation") ;

	iLog->Log(KLog) ;

    CLiwServiceHandler* ServiceHandler = CLiwServiceHandler::NewL();

    // Input and output parameter list

    CLiwGenericParamList* inputlist = &(ServiceHandler->InParamListL());

    CLiwGenericParamList* outputlist = &(ServiceHandler->OutParamListL());

	CLiwCriteriaItem* crit = CLiwCriteriaItem::NewL(1, KDataSource , KService);

	crit->SetServiceClass(TUid::Uid(KLiwClassBase));

	RCriteriaArray a;

	a.AppendL(crit);

	ServiceHandler->AttachL(a) ;

	ServiceHandler->ExecuteServiceCmdL(*crit, *inputlist, *outputlist);

	TInt pos = 0;

	const TLiwGenericParam *errorprm = outputlist->FindFirst(pos , KErrorCode) ;

	if(!errorprm)

	{

		_LIT(Klog , "Success/Failure error code missing from outputlist") ;

		iLog->Log(Klog) ;

		return KErrGeneral ;

	}

	_LIT8(KDataSource, "ILocation");

	 pos = 0 ;

 	const TLiwGenericParam *genericparm = outputlist->FindFirst(pos,KLocationInterface);

	if(!genericparm)

	{

		_LIT(KLog , "Interface not found");

		iLog->Log(KLog) ;

		return KErrGeneral ;

	}

   MLiwInterface* locinterface = (genericparm->Value()).AsInterface();

    TBuf8<20>CmdBuf(KCmdGetLocation) ;

    outputlist->Reset() ;

    inputlist->Reset() ;

    _LIT(KClass,"GenericLocationInfo");

    inputlist->AppendL( TLiwGenericParam( KNullDesC8,TLiwVariant(KClass  )  ) );

    //inputlist->AppendL(TLiwGenericParam(NULL));

    CLiwDefaultMap* updatemap = CLiwDefaultMap::NewL();

	_LIT8(KInterval,"UpdateInterval");

	_LIT8(KTimeout,"UpdateTimeOut");

	_LIT8(KAge,"UpdateMaxAge");

	_LIT8(KPartial,"PartialUpdates");

	const TInt KTime = 1000000;

    updatemap->InsertL(KInterval , TLiwVariant(TInt32(2*KTime)));

    updatemap->InsertL(KTimeout , TLiwVariant(TInt32(30*KTime)));

    updatemap->InsertL(KAge , TLiwVariant(TInt32(0)));

    updatemap->InsertL(KPartial , TLiwVariant(TBool(FALSE)));

    inputlist->AppendL(TLiwGenericParam(KNullDesC8,TLiwVariant(updatemap)));

    updatemap->DecRef();

	locinterface->ExecuteCmdL(CmdBuf , *inputlist , *outputlist);

	pos = 0 ;

	const TLiwGenericParam *ErrorParm =  outputlist->FindFirst(pos ,KErrorCode ) ;

	if(!ErrorParm)

	{

		_LIT(Klog, "Success/Failure state not known") ;

		iLog->Log(Klog) ;

		return KErrGeneral ;

	}

	if((ErrorParm->Value()).AsTInt32() )

	{

		_LIT(KLog , "ExecutecmdL failed ");

		iLog->Log(KLog) ;

		return (ErrorParm->Value()).AsTInt32() ;	

	}

	    TInt index = 0 ;

		const TLiwGenericParam *GenericParam  = outputlist->FindFirst(index , KLocationMap);

		if(!GenericParam)

		{

			_LIT(Klog, "Out Param not found") ;

	    	iLog->Log(Klog) ;

			return KErrGeneral ; //Param Error

		}	

		TLiwVariant Variant ;

		Variant = GenericParam->Value() ;

		const	CLiwMap *LocMap = Variant.AsMap() ;

		TLiwVariant PosVariant ;

		LocMap->FindL(KLongitudeKey , PosVariant) ;

		TReal64 LongData = (TReal64)PosVariant.AsTReal() ; //Longitude

		data.Num(LongData , format) ;

		LogFile.Write(_L8("\n")) ;

		LogFile.Write(_L8("Logitude = ")) ;

		LogFile.Write(data) ;

		LocMap->FindL(KLatitudeKey ,PosVariant) ; //Latitude 

		TReal64 LatData = (TReal64)PosVariant.AsTReal() ;

		data.Num(LatData , format) ;

		LogFile.Write(_L8("   Latitude = ")) ;

		LogFile.Write(data) ;

		LocMap->FindL(KAltitudeKey , PosVariant) ; //Altitude

		TReal32 AltData = PosVariant.AsTReal() ;

		data.Num(AltData , format) ;

		LogFile.Write(_L8("   Altitude = "))	 ;

		LogFile.Write(data) ;

	//Test Calculate

		//TBuf8<20>CmdBufSet(KRequestCalculate) ;

        outputlist->Reset() ;

        inputlist->Reset() ;

        //CLiwGenericParamList *InputList = CLiwGenericParamList :: NewL() ;

        TLiwGenericParam requesttype(KMathRequest , TLiwVariant(KRequestDistance)) ;

        inputlist->AppendL(requesttype) ;

        //Inserting first input param

        CLiwMap* SourceCoordinate = CLiwDefaultMap::NewL();

        TReal64 slongitude = 71.03;

        SourceCoordinate->InsertL(KLongitudeKey,TLiwVariant(slongitude));

        TReal64 slatitude = 42.37;

        SourceCoordinate->InsertL(KLatitudeKey,TLiwVariant(slatitude));

        TReal64 saltitude = 1;

        SourceCoordinate->InsertL(KAltitudeKey,TLiwVariant(saltitude));

        TLiwGenericParam scoordinate(KDistanceParmSource,TLiwVariant(SourceCoordinate));

        inputlist->AppendL(scoordinate) ;

        SourceCoordinate->DecRef() ;

        //Inserting 2nd input param

        CLiwMap* DestCoordinate = CLiwDefaultMap::NewL();

        TReal64 dlongitude = 83.02;

        DestCoordinate->InsertL(KLongitudeKey,TLiwVariant(dlongitude));

        TReal64 dlatitude = 42.42;

        DestCoordinate->InsertL(KLatitudeKey,TLiwVariant(dlatitude));

        TReal64 daltitude = 1;

        DestCoordinate->InsertL(KAltitudeKey,TLiwVariant(daltitude));

        TLiwGenericParam dcoordinate(KDistanceParmDestination,TLiwVariant(DestCoordinate));

        inputlist->AppendL(dcoordinate) ;

        DestCoordinate->DecRef() ;  

        //CLiwGenericParamList *OutParmList = CLiwGenericParamList :: NewL() ;

        TBuf8<20>CmdBufSet(KRequestCalculate) ;

        locinterface->ExecuteCmdL(CmdBufSet , *inputlist , *outputlist);

        pos = 0;

        const TLiwGenericParam* param = outputlist->FindFirst(pos, KErrorCode);

		if((param->Value()).AsTInt32() )

			{

			_LIT(KLog , "Calculate failed ");

			iLog->Log(KLog) ;

			return (ErrorParm->Value()).AsTInt32() ;	

			}

		pos = 0;

        const TLiwGenericParam* paramb = outputlist->FindFirst(pos, KErrorCode);

		if((paramb->Value()).AsTInt32() )

			{

			_LIT(KLog , "Calculate failed ");