/*

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

#include "HtiPlugin.h"

#include "HtiSoapHandlerInterface.h"

#include "../../htigateway/inc/DllModule.h"

#include <iosfwd>

#include <sstream>

//**********************************************************************************

// CONSTANTS

//

//**********************************************************************************

// commands

const BYTE CMD_STIF_OPEN				= 0x01;

const BYTE CMD_STIF_CLOSE				= 0x02;

const BYTE CMD_STIF_LOAD_MODULE			= 0x03;

const BYTE CMD_STIF_UNLOAD_MODULE		= 0x04;

const BYTE CMD_STIF_LIST_CASES			= 0x05;

const BYTE CMD_STIF_START_CASE			= 0x06;

const BYTE CMD_STIF_CANCEL_CASE			= 0x07;

const BYTE CMD_STIF_PAUSE_CASE			= 0x08;

const BYTE CMD_STIF_RESUME_CASE			= 0x09;

const BYTE CMD_STIF_ADD_CASE_FILE		= 0x0A;

const BYTE CMD_STIF_REMOVE_CASE_FILE	= 0x0B;

const BYTE CMD_STIF_CASE_MESSAGE		= 0x0C;

const BYTE CMD_STIF_SET_DEVICEID		= 0x0D;

const BYTE CMD_STIF_TEST_COMPLETED		= 0x0E;

const BYTE CMD_STIF_ATS_MESSAGE			= 0x0F;

const BYTE CMD_STIF_SET_ATTRIBUTE		= 0x10;

// timeouts

const int TIMEOUT_10_SECONDS = 10000;

// soap-action for this plugin

const char soapAction[] = "HtiStif";

// error codes for handle_received_message()

#define HTI_RECV_ASYNC_CALL_SERVICED      1

#define HTI_RECV_OK                       0

#define HTI_RECV_GEN_ERROR                -1

#define HTI_RECV_ERROR_MESSAGE            -2

#define HTI_RECV_TIMEOUT                  -3

#define HTI_RECV_ASYNC_CALL_SERVICE_ERROR -4

#define HTI_RECV_ROUGUE_MESSAGE           -5

#define HTI_RECV_UNKOWN_MESSAGE           -6

//**********************************************************************************

// FORWARD DECLARATIONS

//

//**********************************************************************************

class HtiStifMsg;

class HtiStifClients;

class HtiStifSenderDll;

//class HtiStifResults

//int GetParameters(char* in, int inLen, char** parameters, int &size);

int handle_received_message(HtiSoapHandlerInterface* handler, BOOL isSoapCallActive);

void SetSoapFaultFromReceivedHtiError(struct soap *soap, BYTE *receivedMsgBody, int receivedMsgBodyLen);

//**********************************************************************************

// GLOBAL VARIABLES

//

//**********************************************************************************

//HtiStifResults g_testCaseResults;

HtiStifSenderDll *g_HtiStifSenderDll;

HtiStifClients *g_HtiStifClients;

//**********************************************************************************

// HELPER FUNCTIONS/CLASSES

//

//**********************************************************************************

//**********************************************************************************

// HtiStifMsg

//**********************************************************************************

class HtiStifMsg

{

public:

	HtiStifMsg(BYTE command);

	BYTE* GetMsgBody() { return msgBody; };

	int GetMsgLen() { return msgBodyLen; };

	void AddString(char* string);

	void AddIntAsString(int value);

	void AddByte(BYTE byte);

	void AddParameterSeparator();

	int CheckResponseCommandCode(struct soap *soap, BYTE commandCode);

	int SendReceiveMsg(struct soap *soap, int timeout);

private:

	void IncBodySize(int size);

	BYTE *msgBody; // NOTE: deleted when sent or by gateway when received

	int msgBodyLen;

};

HtiStifMsg::HtiStifMsg(BYTE command)

{

	msgBody = new BYTE[1];

	msgBody[0] = command;

	msgBodyLen = 1;

}

void HtiStifMsg::IncBodySize(int size)

{

	BYTE *newMsgBody = new BYTE[msgBodyLen+size];

	memcpy(newMsgBody, msgBody, msgBodyLen);

	delete msgBody;

	msgBody = newMsgBody;

	msgBodyLen += size;

}

void HtiStifMsg::AddString(char* string)

{

	int stringLen = (int) strlen(string);

	int writePos = msgBodyLen;

	IncBodySize(stringLen);

	memcpy(msgBody+writePos, string, stringLen);

}

void HtiStifMsg::AddIntAsString(int value)

{

	char buf[50];

	_itoa(value, buf, 10);

	AddString(buf);

}

void HtiStifMsg::AddByte(BYTE byte)

{

	int writePos = msgBodyLen;

	IncBodySize(1);

	msgBody[writePos] = byte;

}

void HtiStifMsg::AddParameterSeparator()

{

	AddByte('|');

}

int HtiStifMsg::SendReceiveMsg(struct soap* soap, int timeout)

{

	//dump(msgBody, msgBodyLen);

	BYTE commandCode = msgBody[0];

	// Send the message to symbian side

	HtiSoapHandlerInterface* handler = static_cast<HtiSoapHandlerInterface*>(soap->user);

	handler->SendHtiMessage(HTI_STIF_UID, msgBody, msgBodyLen);

	// Clean these up for received HTI message

	delete msgBody;

	msgBody = NULL;

	msgBodyLen = 0;

	while(1)

	{

		if (handler->WaitForHtiMessage(timeout))

		{

			int err = handle_received_message(handler, TRUE);

			// NOTE: this will be destroyed by gateway

			msgBody = (BYTE*) handler->ReceivedHtiMessageBody();

			msgBodyLen = handler->ReceivedHtiMessageBodySize();

			// Received a HTI initiated msg

			// Start waiting again

			if( (err == HTI_RECV_ASYNC_CALL_SERVICED) || 

				(err == HTI_RECV_ASYNC_CALL_SERVICE_ERROR) )

			{

                continue;

			}

			if( err == HTI_RECV_ERROR_MESSAGE )

				SetSoapFaultFromReceivedHtiError(soap, msgBody, msgBodyLen);

			return err;

		}

		else

		{

			// timeout

			soap->error = soap_receiver_fault(soap, "HtiGateway", "No response from symbian side");

			return HTI_RECV_TIMEOUT;

		}

	}

}

int HtiStifMsg::CheckResponseCommandCode(struct soap *soap, BYTE commandCode)

{

	int result = SOAP_OK;

	if( msgBody[0] != commandCode )

	{

		char msg[] = "incorrect response CommandCode (expected 0x%x, got 0x%x)";

		int msgLen = _scprintf(msg, commandCode, msgBody[0])+1; // +1 for nul char

		char *buf = new char[msgLen];

		sprintf(buf, msg, commandCode, msgBody[0]);

		soap->error = soap_receiver_fault(soap, "HtiError", buf);

		delete buf;

		result = SOAP_FAULT;

	}

	return result;

}

//**********************************************************************************

// HtiStifClients

//**********************************************************************************

class HtiStifClients

{

public:

	HtiStifClients() {m_size = 0; m_clients = NULL;};

	~HtiStifClients();

	int Add(char* host);

	int Remove(char* host);

	int NrOfClients() {return m_size;};

	const char* Get(int index) {return m_clients[index];};

private:

	int m_size;

	char **m_clients;

};

HtiStifClients::~HtiStifClients()

{

	for(int i=0; i<m_size; i++)

		delete m_clients[i];

	free(m_clients);

	m_size = 0;

}

int HtiStifClients::Add(char* host)

{

	// check if host already exist

	for(int i=0; i<m_size; i++)

	{

		if(!strcmp(m_clients[i], host))

			return -1;

	}

	// alloc space for new pointer array

	char **new_clients = (char**) malloc(sizeof(char*)*(m_size+1));

	// copy data

	for(int i=0; i<m_size; i++)

		new_clients[i] = m_clients[i];

	// free previous pointer array & set new one

	free(m_clients);

	m_clients = new_clients;

	// alloc space for host

	char* buf = new char[strlen(host)+1]; // +1 for nul

	strcpy(buf, host);

	new_clients[m_size] = buf;

	// update size

	m_size += 1;

	return 0;

}

int HtiStifClients::Remove(char* host)

{

	int err = -1;

	// alloc a smaller pointer array

	char **new_clients = (char**) malloc(sizeof(char*)*(m_size-1));

	// copy data except removed

	int j=0;

	for(int i=0; i<m_size; i++)

	{

		if(!strcmp(m_clients[i],host))

		{

			delete m_clients[i]; // delete removed host

			err = 0;

			continue;

		}

		new_clients[j] = m_clients[i];

		j++;

	}

	// did not find host?

	if(err != 0)

	{

		free(new_clients);

		return err;

	}

	// free previous pointer array & set new one

	free(m_clients);

	m_clients = new_clients;

	// update size

	m_size -= 1;

	return err;

}

//**********************************************************************************

// HtiStifSenderDll

//**********************************************************************************

class HtiStifSenderDll : public CDLLModule

{

public:

	DECLARE_DLL_FUNCTION(int, __cdecl,

						soap_send_ns1__stifMessage, (soap *, const char *, const char *, char *, void *))

	DECLARE_DLL_FUNCTION(int, __cdecl,

						soap_send_ns1__stifResult, (soap *, const char *, const char *, ns1__HtiStifResult, void *))

    BEGIN_DLL_INIT()

		INIT_DLL_FUNCTION(int, __cdecl,

			 soap_send_ns1__stifMessage, (soap *, const char *, const char *, char *, void *), "soap_send_ns1__stifMessage")

		INIT_DLL_FUNCTION(int, __cdecl,

			 soap_send_ns1__stifResult, (soap *, const char *, const char *, ns1__HtiStifResult, void *), "soap_send_ns1__stifResult")

	END_DLL_INIT()

};

void SetSoapFaultFromReceivedHtiError(struct soap *soap, BYTE *receivedMsgBody, int receivedMsgBodyLen)

{

	if( receivedMsgBodyLen == 10 )

	{

		// This is a standard error message

		// (eg. not authenticated)

		HtiSoapHandlerInterface* handler =

			static_cast<HtiSoapHandlerInterface*>(soap->user);

		handler->SendSoapFaultFromReceivedHtiError();

		return;

	}

	// Get error codes

	int frameworkErrorCode = *((BYTE*)(receivedMsgBody + 1));

	int serviceErrorCode = *((DWORD*)(receivedMsgBody + 2));

	// Get error description

	// NOTE: first byte is skipped because it contains the command code

	int serviceErrorDescLen = receivedMsgBodyLen - 11;

	char* serviceErrorDesc = new char[receivedMsgBodyLen - 11 + 1];

	memcpy(serviceErrorDesc, receivedMsgBody+11, serviceErrorDescLen);

	serviceErrorDesc[serviceErrorDescLen] = 0x0;

	// Fill the xml struct

	std::stringstream s;

	s<<"<htiError xmlns=\'urn:hti/fault\'><frameworkErrorCode>";

	s<<frameworkErrorCode;

	s<<"</frameworkErrorCode><serviceErrorCode>";

	s<<serviceErrorCode;

	s<<"</serviceErrorCode><serviceErrorDescription>";

	s<<serviceErrorDesc;

    s<<"</serviceErrorDescription>";

	s<<"</htiError>";

	soap->error = soap_receiver_fault(soap, "HtiError", s.str().c_str() );

	delete serviceErrorDesc;

}

//**********************************************************************************

// handle_received_message

//**********************************************************************************

int handle_received_message(HtiSoapHandlerInterface* handler, BOOL isSoapCallActive)

{

	if(handler->IsReceivedHtiError())

		return HTI_RECV_ERROR_MESSAGE;

	// Get message

	BYTE *msgBody = (BYTE*) handler->ReceivedHtiMessageBody();

	int msgBodyLen = handler->ReceivedHtiMessageBodySize();

	switch(msgBody[0])

	{

	// Initiated by SOAP

	case CMD_STIF_OPEN:

	case CMD_STIF_CLOSE:		

	case CMD_STIF_LOAD_MODULE:

	case CMD_STIF_UNLOAD_MODULE:

	case CMD_STIF_LIST_CASES:

	case CMD_STIF_START_CASE:

	case CMD_STIF_CANCEL_CASE:

	case CMD_STIF_PAUSE_CASE:

	case CMD_STIF_RESUME_CASE:

	case CMD_STIF_ADD_CASE_FILE:

	case CMD_STIF_REMOVE_CASE_FILE:

	case CMD_STIF_CASE_MESSAGE:

	case CMD_STIF_SET_DEVICEID:

	case CMD_STIF_SET_ATTRIBUTE:

		if(isSoapCallActive)

			return HTI_RECV_OK;

		else

		{

			printf("HtiStif: Received a known but unexpected message (command code 0x%x)\n", msgBody[0]);

			return HTI_RECV_ROUGUE_MESSAGE;

		}

        break;

	// Initiated by HTI

	case CMD_STIF_TEST_COMPLETED:

		{

			// Make copy of parameters

			char *params = new char[msgBodyLen];

			memcpy(params, msgBody+1, msgBodyLen-1);

			params[msgBodyLen-1] = 0x0; // add nul to make strtok easier

			// Get data from params

			char *testCaseId = strtok(params, "|");

			char *testResult = strtok(NULL, "|");

			char *testExecutionResult = strtok(NULL, "|");

			char *resultDescription = strtok(NULL, "|");

			// Check if all is there

			if( !testCaseId || !testResult || !testExecutionResult)

			{

				printf("HtiStif: Received incomplete testcase result\n" );

				delete params;

				return HTI_RECV_ASYNC_CALL_SERVICE_ERROR;

			}

			// Get soap env

			struct soap soap;

			soap_init(&soap);

			soap.namespaces = namespaces;

			// Fill HtiStifResult

			struct ns1__HtiStifResult result;

			result.caseId = atoi(testCaseId);

			result.caseResult = atoi(testResult);

			result.executionResult = atoi(testExecutionResult);

			if(resultDescription)

			{

				result.resultDescription = (char*) soap_malloc( &soap, strlen(resultDescription)+1 );

				strcpy(result.resultDescription, resultDescription);

			}

			else

				result.resultDescription = NULL;

			delete params; // not needed anymore

			// Send the HtiStifResult to registered clients

			for(int i=0; i<g_HtiStifClients->NrOfClients(); i++)

			{

				if(g_HtiStifSenderDll->soap_send_ns1__stifResult(&soap, g_HtiStifClients->Get(i), soapAction, result, NULL) != SOAP_OK)

					printf("HtiStif: error sending stifResult to %s\n", g_HtiStifClients->Get(i) );

			}

			soap_destroy(&soap);

			soap_end(&soap);

			soap_done(&soap);

			return HTI_RECV_ASYNC_CALL_SERVICED;

		}

		break;

	case CMD_STIF_ATS_MESSAGE:

		{

			// Get soap env

			struct soap soap;

			soap_init(&soap);

			soap.namespaces = namespaces;

			// Get message

			// NOTE: messages are in string format so they don't have nul-characters

			// This might change in the future and then xsd__string will no do for this task.

			char* msg = (char*) soap_malloc(&soap, msgBodyLen);

			memcpy(msg, msgBody+1, msgBodyLen-1);

			msg[msgBodyLen-1] = 0x0; // add nul

			// Send the HtiStifResult to registered clients

			for(int i=0; i<g_HtiStifClients->NrOfClients(); i++)

			{

				if(g_HtiStifSenderDll->soap_send_ns1__stifMessage(&soap, g_HtiStifClients->Get(i), soapAction, msg, NULL) != SOAP_OK)

					printf("HtiStif: error sending stifMessage to %s\n", g_HtiStifClients->Get(i) );

			}

			soap_destroy(&soap);

			soap_end(&soap);

			soap_done(&soap);

			return HTI_RECV_ASYNC_CALL_SERVICED;

		}

		break;

	default:

		printf("HtiStif: Received an unkown message (command code 0x%x, sync call active %d)\n", msgBody[0], isSoapCallActive);

		return HTI_RECV_UNKOWN_MESSAGE;

		break;

	}

	// Should never come here

	return HTI_RECV_GEN_ERROR;

}

//**********************************************************************************

// SOAP FUNCTIONS

//

//**********************************************************************************

//**********************************************************************************

// ns1__openStif()

//**********************************************************************************

int ns1__openStif(struct soap* soap, char *iniFile, struct ns1__openStifResponse *out)

{

	// Assemble HTI message