// LocalProxy.cpp : ÄÜ¼Ö ÀÀ¿ë ÇÁ·Î±×·¥¿¡ ´ëÇÑ ÁøÀÔÁ¡À» Á¤ÀÇÇÕ´Ï´Ù.
//

#ifdef _WIN32
# define _CRT_SECURE_NO_WARNINGS
# include <process.h>
#else
# include <errno.h>
#endif

#include "CRXSocket.h"
#include "CRXHttpRequest.h"
#include "CRXHttpResponse.h"

#include <iostream>
#include <iomanip>
#include <sstream>

#include <stdio.h>
#include <string.h>

using namespace std;

/*-----------------------------------------------------------------*/
int CRXCreateThread	(int (* aThreadFunc) (void *), void * aThreadArg);
int CRXProxyThread	(void * aThreadArg);

/* error */
#ifdef _WIN32
# define CRX_ERROR()		GetLastError ()
# ifndef __func__
#  define __func__			__FUNCTION__
# endif
#else
# define CRX_ERROR()		errno
#endif

#define CRX_PRINT_ERROR(__code, __message)																\
	do {																								\
		char __error[4096] = {0x00, };																	\
		ostringstream __stream;																			\
		__stream << __message;																			\
		string __string = __stream.str ();																\
		sprintf (__error, "[%s][%d] (%d) %s\n", __func__, __LINE__, __code, __string.c_str ());			\
		cout << __error;																				\
	} while (0)

typedef struct __crx_proxy_thread_argument__
{
	int mSocket;
} CRXProxyThreadArgs;
/*----------------------------------------------------------------*/

int main (int argc, char* argv[])
{
	int						aResult	= 0;
	const unsigned short	aPort	= 8080;

	CRXSocket			aSocket;
	CRXProxyThreadArgs	* aThreadArg;

	/*----------------------------------------------------------------*/
	/*----------------------------------------------------------------
	 * Initialize
	 *----------------------------------------------------------------*/
	aResult = aSocket.CreateServer (aPort);
	if (aResult < 0)
	{
		CRX_PRINT_ERROR (aResult, "failed to create server");
		return aResult;
	}

	for (;;)
	{
		aResult = aSocket.Accept ();
		if (aResult < 0)
		{
			CRX_PRINT_ERROR (aResult, "failed to accept");
			break;
		}

		if ((aThreadArg = new(std::nothrow) CRXProxyThreadArgs) == NULL)
		{
			aResult = -1;
			break;
		}

		memset (aThreadArg, 0x0, sizeof (CRXProxyThreadArgs));
		aThreadArg->mSocket = aResult;

		aResult = CRXCreateThread (CRXProxyThread, aThreadArg);
		if (aResult < 0)
		{
			aResult = CRX_ERROR ();
			CRX_PRINT_ERROR (aResult, "failed to create thread");
			break;
		}
	}

	/*----------------------------------------------------------------*/
	aSocket.Close ();

	return aResult;
}

int
CRXCreateThread	(int (* aThreadFunc) (void *), void * aThreadArg)
{
#ifdef _WIN32
	return _beginthread ((void (*) (void *))aThreadFunc, 0, aThreadArg);
#else
	pthread_t aThreadID = 0;

	return pthread_create (&aThreadID, NULL, (void * (*) (void *))aThreadFunc, aThreadArg);
#endif
}

int
CRXProxyThread (void * aThreadArg)
{
	int					aResult			= 0;
	int					aReceivedSize	= 0;

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

	CRXHttpRequest		aHttpRequest;
	CRXHttpResponse		aHttpResponse;

	CRXSocket			aWebServer;
	CRXSocket			aWebBrowser	= ((CRXProxyThreadArgs *)aThreadArg)->mSocket;

	bool				aIsMoreRequest = false;

	/*----------------------------------------------------------------*/
	delete (CRXProxyThreadArgs *)aThreadArg;

	do
	{
		/* BROWSER --- request ---> [PROXY]                  SERVER */
		aReceivedSize = aWebBrowser.Receive (aBuffer, aBufferSize);
		if (aReceivedSize < 0)
		{
			CRX_PRINT_ERROR (aReceivedSize, "failed to receive from client (" << CRX_ERROR () << ")");
			return aReceivedSize;
		}

		/* BROWSER ?--- waiting --- [PROXY] --- connect ---> SERVER */
		if (!aWebServer)
		{
			/* parse http request */
			aHttpRequest = aBuffer;

			/* connect */
			aResult = aWebServer.Connect (aHttpRequest.GetHost (), aHttpRequest.GetPort (), 1);
			if (aResult < 0)
			{
				CRX_PRINT_ERROR (aResult, "failed to connect to server ("
										  << CRX_ERROR ()
										  << ") <"
										  << aHttpRequest.GetHost ()
										  << ":"
										  << aHttpRequest.GetPort ()
										  << "><"
										  << aHttpRequest.GetURL ()
										  << ">");
				return aResult;
			}
		}

		/* BROWSER ?--- waiting --- [PROXY] --- request ---> SERVER */
		aResult = aWebServer.Send (aBuffer, aReceivedSize);
		if (aResult != aReceivedSize)
		{
			CRX_PRINT_ERROR (aResult, "failed to send to server <"
										  << aHttpRequest.GetHost ()
										  << ":"
										  << aHttpRequest.GetPort ()
										  << CRX_ERROR ()
										  << ")");
			return aResult;
		}

		/* BROWSER <--- response--- [PROXY] <--- response--- SERVER */
		for (;;)
		{
			memset (aBuffer, 0x00, aBufferSize);

			aResult = aWebServer.Receive (aBuffer, aBufferSize);
			if (aResult < 0)
			{
				CRX_PRINT_ERROR (aResult, "failed to receive ("
										  << CRX_ERROR ()
										  << ") <"
										  << aHttpRequest.GetURL ()
										  << ">");
				break;
			}
			else if (aResult == 0)
			{
				break;
			}
			aReceivedSize = aResult;

			aResult = aWebBrowser.Send (aBuffer, aReceivedSize);
			if (aResult != aReceivedSize)
			{
				CRX_PRINT_ERROR (aResult, "failed to send ("
										  << CRX_ERROR ()
										  << ") <"
										  << aHttpRequest.GetURL ()
										  << ">");
				break;
			}
		}
	} while (aIsMoreRequest);

	/*----------------------------------------------------------------*/
	aWebBrowser.Close ();
	aWebServer.Close ();

	return aResult;
}