/*
* 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:
*   This file contains implementation of SOAPHandler class
*/

#include "stdsoap2.h" //should be first because of WinSock2.h errors

#include "SOAPHandler.h"
#include "HtiMessage.h"

#include "datagateway.h" //for htidispatcher
#include "util.h"

#include <sstream>

SOAP_NMAC struct Namespace namespaces_l[] =
{
	{"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/", "http://www.w3.org/*/soap-envelope", NULL},
	{"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/", "http://www.w3.org/*/soap-encoding", NULL},
	{"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance", NULL},
	{"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema", NULL},
	{"ns1", "urn:hti", NULL, NULL},
	{NULL, NULL, NULL, NULL}
};

//**********************************************************************************
// Class SOAPHandler
//
// This class is used to handle SOAP requests, send HtiMessages 
// and handle HTI responses by using loaded HtiPluginDll
//**********************************************************************************
SoapHandler::SoapHandler(const string& pluginName)
	: m_PluginName(pluginName),
	  m_Running(false),
	  m_HtiDispatcher(NULL),
	  m_SoapEnv(NULL),
	  m_ReceiveHtiMsg(NULL)
{
	m_hReceiveHtiEvent = CreateEvent(NULL, //sec att
								  FALSE, //not manual-reset
								  FALSE, //initial state non-signaled
								  NULL //name
								  );
	m_hReceiveSoapEvent = CreateEvent(NULL, //sec att
								  FALSE, //not manual-reset
								  FALSE, //initial state non-signaled
								  NULL //name
								  );

	m_hHandlerCanAcceptSoapRequest = CreateEvent(NULL, //sec att
								  TRUE, //manual-reset
								  TRUE, //initial state signaled
								  NULL //name
								  );

	m_hHandlerCanAcceptHtiMessage = CreateEvent(NULL, //sec att
								  TRUE, //manual-reset
								  TRUE, //initial state signaled
								  NULL //name
								  );

	m_hHandlerWaitsHtiMessage = CreateEvent(NULL, //sec att
								  TRUE, //manual-reset
								  FALSE, //initial state non-signaled
								  NULL //name
								  );


	m_HtiPlugin = new HtiPluginDll();
}

SoapHandler::~SoapHandler()
{
	Stop();
	CloseHandle(m_hHandlerWaitsHtiMessage);
	CloseHandle(m_hHandlerCanAcceptSoapRequest);
	CloseHandle(m_hHandlerCanAcceptHtiMessage);
	CloseHandle(m_hReceiveHtiEvent);
	CloseHandle(m_hReceiveSoapEvent);
	CleanSoapEnv();
	delete m_HtiPlugin;
}

void SoapHandler::CleanSoapEnv()
{
	if ( m_SoapEnv )
	{
		soap_destroy(m_SoapEnv); // dealloc C++ data 
		soap_end(m_SoapEnv); // dealloc data and clean up 
		soap_done(m_SoapEnv); // detach soap struct 
		free(m_SoapEnv);
		m_SoapEnv = NULL;
	}
}

/**
 * This loop waits until either a SOAP request or HTI response event has arrived
 * When one of them arrives, it is handled and the loop starts again to wait
 * for a new request or response
 */
void SoapHandler::Run()
{
	Util::Debug("SoapHandler::Run()");
	HANDLE events[2];
	events[0] = m_hReceiveSoapEvent;
	events[1] = m_hReceiveHtiEvent;
	m_Running = true;
	while (m_Running)
	{
		Util::Debug("SoapHandler::Run::WaitForMultipleObjects");
		DWORD r = WaitForMultipleObjects(
						2,
						events,
                        FALSE, //don't wait all
						LOOP_WAIT_INTERVAL);
		switch (r)
		{
		case WAIT_OBJECT_0:
			{
				//process soap request
				ResetEvent(m_hHandlerCanAcceptSoapRequest);
				ResetEvent(m_hHandlerCanAcceptHtiMessage);
				DoServeSoap();
				SetEvent(m_hHandlerCanAcceptSoapRequest);
				SetEvent(m_hHandlerCanAcceptHtiMessage);
			}
			break;
		case WAIT_OBJECT_0+1:
			{
				//process HTI response
				ResetEvent(m_hHandlerCanAcceptSoapRequest);
				ResetEvent(m_hHandlerCanAcceptHtiMessage);
				ProcessHtiResponse();
				SetEvent(m_hHandlerCanAcceptSoapRequest);
				SetEvent(m_hHandlerCanAcceptHtiMessage);
			}
			break;
		case WAIT_TIMEOUT:
			{
				//do nothing
				//just check for m_Running and waits again
			}
			break;
		default:
			{
			}
		}
	}
}

void SoapHandler::Stop()
{
	m_Running = false;
}

/**
 * wait for hti message
 * Suspend thread until HtiMessage for the loaded plug-in is received
 * Return true if hti message is received or false if timeout
 */
bool SoapHandler::WaitForHtiMessage(DWORD timeout)
{
	SetEvent(m_hHandlerCanAcceptHtiMessage);
	SetEvent(m_hHandlerWaitsHtiMessage);
	//delete m_ReceiveHtiMsg;
	Util::Debug("SoapHandler::WaitForHtiMessage");
	DWORD r = WaitForSingleObject(m_hReceiveHtiEvent, timeout);

	ResetEvent(m_hHandlerCanAcceptHtiMessage);
	ResetEvent(m_hHandlerWaitsHtiMessage);
	switch ( r )
	{
	case WAIT_OBJECT_0:
		{
			return true;
		}
		break;
	case WAIT_TIMEOUT:
		{
		}
		break;
	default:
		{
		}
	}
	Util::Debug("WaitForHtiMessage OK");
	return false;
}

/**
 * This method is used to init HtiPluginDll
 */
bool SoapHandler::LoadPlugin()
{
	//code to load and init plugin dll m_PluginName
	return m_HtiPlugin->Init( m_PluginName.c_str() );
}

/**
 * This method tells whether or not this handler is currently busy processing request
 */
bool SoapHandler::IsBusyForSoapRequest()
{
	DWORD r = WaitForSingleObject(m_hHandlerCanAcceptSoapRequest, LOOP_CHECK_INTERVAL);
	switch ( r )
	{
	case WAIT_OBJECT_0:
		{
			return false;
		}
		break;
	case WAIT_TIMEOUT:
		{
		}
		break;
	default:
		{
		}
	}
	return true;
}

/**
 * This method tells whether or not this handler is currently busy processing hti message
 */
bool SoapHandler::IsBusyForHtiMessage()
{
	DWORD r = WaitForSingleObject(m_hHandlerCanAcceptHtiMessage, LOOP_CHECK_INTERVAL);
	switch ( r )
	{
	case WAIT_OBJECT_0:
		{
			return false;
		}
		break;
	case WAIT_TIMEOUT:
		{
		}
		break;
	default:
		{
		}
	}
	return true;
}

/*
 * This method is used to check if SoapHandler is currently waiting for Hti Message
 */
bool SoapHandler::IsWaitsForHtiMessage()
{
	DWORD r = WaitForSingleObject(m_hHandlerWaitsHtiMessage, LOOP_CHECK_INTERVAL);
	switch ( r )
	{
	case WAIT_OBJECT_0:
		{
			return true;
		}
		break;
	case WAIT_TIMEOUT:
		{
		}
		break;
	default:
		{
		}
	}
	return false;
}

/**
 * Just a wrapper around soap_serve() created by gSOAP
 * called by DataGatewaySOAPServerThread for a new SOAP request
 * return true if request can be processed
 * This method sets m_hReceiveSoapEvent to signaled state
 * Run method waits this event object and then handles the soap request when the event switches to signaled state
 */
bool SoapHandler::ServeSoap(struct soap* soapEnv)
{
	Util::Debug("SoapHandler::ServeSoap");
	//check can this handler process request in soapEnv
	if ( !IsBusyForSoapRequest() )
	{
		CleanSoapEnv();
		m_SoapEnv = soap_copy(soapEnv);
		//soap_free( soapEnv );
		m_SoapEnv->user = dynamic_cast<HtiSoapHandlerInterface*>( this );
		SetEvent(m_hReceiveSoapEvent);
		Util::Debug("SoapHandler::ServeSoap OK");
		return true;
	}
	else
	{
		Util::Debug("SoapHandler::ServeSoap NOK");
		return false;
	}
}

/**
 * This method is called when incoming Hti message has been read from CommChannelPlugin
 * The method sets m_hReceiveHtiEvent to signaled state(Run method waits this event object to become signaled)
 */
bool SoapHandler::ReceiveHtiMessage(HtiMessage* htiMessage)
{
	Util::Debug("SoapHandler::ReceiveHtiMessage");
	//_RPT0(_CRT_WARN, "SoapHandler::ReceiveHtiMessage");
	//check can this handler process HTI response
	if ( !IsBusyForHtiMessage() )
	{
		//_RPT1(_CRT_WARN, "delete %x\n", m_ReceiveHtiMsg);
		//_RPT1(_CRT_WARN, "received %x\n", htiMessage);
		ResetEvent(m_hHandlerCanAcceptHtiMessage);
		delete m_ReceiveHtiMsg;
		m_ReceiveHtiMsg = htiMessage;
		SetEvent(m_hReceiveHtiEvent);
		Util::Debug("SoapHandler::ReceiveHtiMessage OK");
		return true;
	}
	Util::Debug("SoapHandler::ReceiveHtiMessage NOK");
	return false;
}

/**
* Actual SOAP request processing in the thread
* if it was accepted in ServeSoap()
* The request is processed using HtiPluginDll
*/
void SoapHandler::DoServeSoap()
{
	Util::Debug("SoapHandler::DoServeSoap");
	soap_set_namespaces( m_SoapEnv, m_HtiPlugin->serviceNamespaces()); 
	//soap_set_namespaces( m_SoapEnv, namespaces_l);

	if (soap_envelope_begin_in(m_SoapEnv)
		|| soap_recv_header(m_SoapEnv)
		|| soap_body_begin_in(m_SoapEnv) )
	{
		//soap_set_namespaces( m_SoapEnv, namespaces_l);
		soap_send_fault(m_SoapEnv);
		Util::Debug("SoapHandler::DoServeSoap NOK");
		return;
	}

	//call soap_serve(soap_server_request) from the dll plug-in
	//m_HtiPlugin->soap_serve( m_SoapEnv );
	
	if (m_HtiPlugin->soap_serve_request(m_SoapEnv)
		|| (m_SoapEnv->fserveloop && m_SoapEnv->fserveloop(m_SoapEnv)))
	{
		//soap_set_namespaces( m_SoapEnv, namespaces_l);
		soap_send_fault(m_SoapEnv);
		Util::Debug("SoapHandler::DoServeSoap NOK");
		return;
	}
	
	CleanSoapEnv();
	Util::Debug("SoapHandler::DoServeSoap OK");
}

/*
 * HtiPluginDll's call this method
 * It creates a HtiMessage of the data given as parameters and sends it using HtiDispatcher
 */
void SoapHandler::SendHtiMessage( DWORD serviceId, void* body, DWORD len )
{
	Util::Debug("SoapHandler::SendHtiMessage");
	HtiMessage* msg = new HtiMessage(serviceId, body, len);
	//_RPT2(_CRT_WARN, "send msg %x <%d>\n", msg, sizeof(HtiMessage));
	m_HtiDispatcher->SendHtiMessage( msg );
	//_RPT2(_CRT_WARN, "del send msg %x <%d>\n", msg, sizeof(HtiMessage));
	delete msg;
	Util::Debug("SoapHandler::SendHtiMessage OK");
}

/*
 * HtiPluginDll's call this method
 * It creates a HtiMessage of the data given as parameters and sends it using HtiDispatcher
 */
void SoapHandler::SendHtiMessage( DWORD serviceId, void* body, DWORD len, BYTE priority )
{
	Util::Debug("SoapHandler::SendHtiMessage");
	//delegate function to dispatcher
	HtiMessage* msg = new HtiMessage(serviceId, body, len, priority);
	//_RPT2(_CRT_WARN, "send msg %x <%d>\n", msg, sizeof(HtiMessage));
	m_HtiDispatcher->SendHtiMessage( msg );
	//_RPT2(_CRT_WARN, "del send msg %x <%d>\n", msg, sizeof(HtiMessage));
	delete msg;
	Util::Debug("SoapHandler::SendHtiMessage OK");
}

int SoapHandler::ReceivedHtiMessageBodySize()
{
	if ( m_ReceiveHtiMsg )
	{
		return m_ReceiveHtiMsg->GetBodySize();
	}
	return -1;
}

void* SoapHandler::ReceivedHtiMessageBody()
{
	if ( m_ReceiveHtiMsg )
	{
		return m_ReceiveHtiMsg->GetBody();
	}
	return NULL;
}

bool SoapHandler::IsReceivedHtiError()
{
	if ( m_ReceiveHtiMsg )
	{
		return m_ReceiveHtiMsg->IsErrorMessage();
	}
	return false;
}

int SoapHandler::HtiErrorCode()
{
	if ( m_ReceiveHtiMsg )
	{
		return m_ReceiveHtiMsg->HtiErrorCode();
	}
	return -1;
}

int SoapHandler::HtiServiceErrorCode()
{
	if ( m_ReceiveHtiMsg )
	{
		return m_ReceiveHtiMsg->ServiceErrorCode();
	}
	return -1;
}

char* SoapHandler::HtiServiceErrorDerscription()
{
	if ( m_ReceiveHtiMsg )
	{
		return m_ReceiveHtiMsg->ErrorDescription();
	}
	return NULL;
}

void SoapHandler::SendSoapFaultFromReceivedHtiError()
{
	if ( m_SoapEnv && IsReceivedHtiError() )
	{
        stringstream s;
		s<<"<htiError xmlns=\'urn:hti/fault\'><frameworkErrorCode>";
        s<<m_ReceiveHtiMsg->HtiErrorCode();
		s<<"</frameworkErrorCode><serviceErrorCode>";
		s<<m_ReceiveHtiMsg->ServiceErrorCode();
		s<<"</serviceErrorCode><serviceErrorDescription>";
		s<<m_ReceiveHtiMsg->ErrorDescription();
		s<<"</serviceErrorDescription>";
		s<<"</htiError>";
		
		soap_receiver_fault(m_SoapEnv,
			"HtiError", s.str().c_str() );
	}
}

/**
 * This method makes HtiPluginDll process HTI response 
 */
void SoapHandler::ProcessHtiResponse()
{
	m_HtiPlugin->hti_serve( dynamic_cast<HtiSoapHandlerInterface*>( this ) );
}