/**
 * CRXProxy.cpp
 */

#include "CRXProxy.h"

#include <string.h>

CRXProxy::CRXProxy (void)
	: mClient (0),
	  mServer (0)
{
	/*----------------------------------------------------------------*/
	/*----------------------------------------------------------------*/
}

CRXProxy::~CRXProxy (void)
{
	/*----------------------------------------------------------------*/
	Close ();
	/*----------------------------------------------------------------*/
}

CRXProxy *
CRXProxy::GetNewInstance(void)
{
	/*----------------------------------------------------------------*/
	/*----------------------------------------------------------------*/

	return new(std::nothrow) CRXProxy ();
}

void
CRXProxy::ReleaseInstance (void)
{
	/*----------------------------------------------------------------*/
	delete this;
	/*----------------------------------------------------------------*/
}

void
CRXProxy::SetClientSocket (const int aSocket)
{
	/*----------------------------------------------------------------*/
	if (aSocket <= 0)
		return ;

	mClient = aSocket;
	/*----------------------------------------------------------------*/
}

void
CRXProxy::Close (void)
{
	/*----------------------------------------------------------------*/
	mServer.Close ();
	mClient.Close ();
	/*----------------------------------------------------------------*/
}

int
CRXProxy::GetStatus (void)
{
	/*----------------------------------------------------------------*/
	/*----------------------------------------------------------------*/

	return mProxyStatus;
}

int
CRXProxy::Forward (void)
{
	int		aResult = 0;

	/*----------------------------------------------------------------*/
	aResult = ReceiveRequest ();
	if (aResult < 0)
	{
		aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
		CRX_ERROR (aResult, "Failed to receive from client");
	}

	aResult = SendRequest ();
	if (aResult < 0)
	{
		aResult = ERROR_PROXY_FAILED_TO_SEND_REQUEST;
		CRX_ERROR (aResult, "Failed to send to server");
		return aResult;
	}

	aResult = ReceiveResponse ();
	if (aResult < 0)
	{
		aResult = ERROR_PROXY_FAILED_TO_RECEIVE_RESPONSE;
		CRX_ERROR (aResult, "Failed to receive from server");
	}

	aResult = SendResponse ();
	if (aResult < 0)
	{
		aResult = ERROR_PROXY_FAILED_TO_SEND_RESPONSE;
		CRX_ERROR (aResult, "Failed to send to client");
		return aResult;
	}
	/*----------------------------------------------------------------*/

	return aResult;
}

void
CRXProxy::SetHttpRequest (const char * aHttpRequest)
{
	/*----------------------------------------------------------------*/
	mHttpRequest = aHttpRequest;
	/*----------------------------------------------------------------*/
}

char *
CRXProxy::GetHttpRequest (char		* aBuffer,
						  const int	aBufferSize) const
{
	void * aPtr = static_cast<void *> (aBuffer);

	/*----------------------------------------------------------------*/
	if (aPtr == NULL)
		return NULL;
	
	if (aBufferSize > 0)
		memcpy (aPtr, mHttpRequest.GetHeader ().c_str (), aBufferSize);
	/*----------------------------------------------------------------*/

	return aBuffer;
}

int
CRXProxy::GetHttpRequestLength (void) const
{
	/*----------------------------------------------------------------*/
	/*----------------------------------------------------------------*/

	return mHttpRequest.GetHeader().length ();
}

void
CRXProxy::SetHttpResponse (const char * aHttpResponse)
{
	/*----------------------------------------------------------------*/
	mHttpResponse = aHttpResponse;
	/*----------------------------------------------------------------*/
}

char *
CRXProxy::GetHttpResponse (char			* aBuffer,
						   const int	aBufferSize) const
{
	void	* aPtr = static_cast<void *> (aBuffer);

	int		aRemainLength = aBufferSize;

	/*----------------------------------------------------------------*/
	if (aPtr == NULL)
		return NULL;

	if (aRemainLength > 0)
		memcpy (aPtr, mHttpResponse.GetHeader ().c_str (), aRemainLength);

	aRemainLength -= mHttpResponse.GetHeader ().length ();

	if (aRemainLength > 0)
		memcpy (aPtr, mHttpResponse.GetContentBody (), aRemainLength);
	/*----------------------------------------------------------------*/

	return aBuffer;
}

int
CRXProxy::GetHttpResponseLength (void) const
{
	/*----------------------------------------------------------------*/
	/*----------------------------------------------------------------*/

	return mHttpResponse.GetHeader ().length ()
		 + mHttpResponse.GetContentLength ();
}

int
CRXProxy::ReceiveRequest (void)
{
	int					aResult		= 0;

	const unsigned int	aBufferSize	= 1024 * 56;
	char				aBuffer[aBufferSize + 1] = {0x00, };

	/*----------------------------------------------------------------*/
	aResult = mClient.Receive (aBuffer, aBufferSize);
	if (aResult < 0)
	{
		aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
		CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
		CRX_ERROR (aResult, "Failed to receive from client");
		return aResult;
	}

	/* parse http request */
	mHttpRequest = aBuffer;
	/*----------------------------------------------------------------*/

	return aResult < 0 ? aResult : 0;
}

int
CRXProxy::SendRequest (void)
{
	int		aResult	= 0;
	int		aSize	= mHttpRequest.GetHeader ().length ();

	/*----------------------------------------------------------------*/
	if (!mServer)
	{
		/* connect */
		aResult = mServer.Connect (mHttpRequest.GetHost (), mHttpRequest.GetPort (), 1);
		if (aResult < 0)
		{
			aResult = ERROR_PROXY_FAILED_TO_CONNECT_TO_SERVER;
			CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
			CRX_ERROR (aResult, "Failed to connect to server <%s>", mHttpRequest.GetURL ().c_str ());
			return aResult;
		}
	}

	aResult = mServer.Send (mHttpRequest.GetHeader ().c_str (), aSize);
	if (aResult != aSize)
	{
		CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
		CRX_ERROR (aResult, "Failed to send to server <%s>", mHttpRequest.GetURL ().c_str ());
	}
	/*----------------------------------------------------------------*/

	return aResult < 0 ? aResult : 0;
}

int
CRXProxy::ReceiveResponse (void)
{
	int					aResult			= 0;

	const unsigned int	aBufferSize		= 1024 * 64;
	char				aBuffer[aBufferSize + 1] = {0x00, };

	std::string			aHttpResponse;

	/*----------------------------------------------------------------*/
	for (;;)
	{
		memset (aBuffer, 0x00, sizeof (aBuffer));

		aResult = mServer.Receive (aBuffer, aBufferSize);
		if (aResult < 0)
		{
			aResult = ERROR_PROXY_FAILED_TO_RECEIVE_REQUEST;
			CRX_ERROR_ADD (mServer.GetErrorMessage ().c_str ());
			CRX_ERROR (aResult, "Failed to receive from server");
			return aResult;
		}
		else if (aResult == 0)
		{
			break;
		}

		aResult = mHttpResponse.SetResponse (aBuffer, aResult);
		if (aResult)
		{
			aResult = ERROR_PROXY_FAILED_TO_SET_RESPONSE;
			CRX_ERROR (aResult, "Failed to set response");
			return aResult;
		}
	}
	/*----------------------------------------------------------------*/

	return aResult < 0 ? aResult : 0;
}

int
CRXProxy::SendResponse (void)
{
	int		aResult	= 0;
	int		aSize	= 0;

	/*----------------------------------------------------------------*/
	aSize = mHttpResponse.GetHeader ().length ();;
	aResult = mClient.Send (mHttpResponse.GetHeader ().c_str (), aSize);
	if (aResult != aSize)
	{
		CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
		CRX_ERROR (aResult, "Failed to send to client");
		return aResult;
	}

	aSize = mHttpResponse.GetContentLength ();
	aResult = mClient.Send (mHttpResponse.GetContentBody (), aSize);
	if (aResult != aSize)
	{
		CRX_ERROR_ADD (mClient.GetErrorMessage ().c_str ());
		CRX_ERROR (aResult, "Failed to send to client");
	}
	/*----------------------------------------------------------------*/

	return aResult < 0 ? aResult : 0;
}