#ifdef _WIN32
# define _CRT_SECURE_NO_WARNINGS
#endif

#include "CRXSocket.h"
#include "CRXProxy.h"

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

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

using namespace std;

#ifdef _WIN32
# include <process.h>
# define THREAD_TYPE							void *
# define THREAD_FUNCTION_RETURN					unsigned int
# define THREAD_FUNCTION_CALLING_CONVENTION		WINAPI
#else
# include <pthread.h>
# define THREAD_TYPE							pthread_t
# define THREAD_FUNCTION_RETURN					void *
# define THREAD_FUNCTION_CALLING_CONVENTION
#endif

#define PROXY_CONNECTION	"Proxy-Connection"
#define CONNECTION			"Connection"

THREAD_FUNCTION_RETURN
THREAD_FUNCTION_CALLING_CONVENTION
CRXProxyMTWrapper (void * aThreadArg);

int ThreadPool (CRXSocket	* aProxySocket,
				const int	aThreadPoolCount);

bool	gViewRequest	= true;
bool	gViewResponse	= false;

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

	CRXSocket	aProxySocket;

	/*----------------------------------------------------------------*/
	/* 1. create proxy server */
	aResult = aProxySocket.CreateServer (aPort);
	if (aResult < 0)
	{
		cout << "Failed to create server." << endl;
		return aResult;
	}

	/* 2. ready proxy servers */
	aResult = ThreadPool (&aProxySocket, aThreadPoolCount);
	if (aResult)
	{
		cout << "Failed to create thread pool." << endl;
		return aResult;
	}

	/* 3. keep process */
	while (true);

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

	return aResult;
}

int ThreadPool (CRXSocket	* aProxySocket,
				const int	aThreadPoolCount)
{
	int				aResult = 0;
	int				aIter = 0;
	THREAD_TYPE		aThreadID = (THREAD_TYPE)0;

	/*----------------------------------------------------------------*/
	for (aIter = 0 ; aIter < aThreadPoolCount ; aIter++)
	{
#ifdef _WIN32
		aThreadID = (void *)_beginthreadex (0, 0, CRXProxyMTWrapper, aProxySocket, 0, 0);
		if (aThreadID == NULL)
		{
			aResult = -1;
			break;
		}
		CloseHandle (aThreadID);
#else
		aResult = pthread_create (&aThreadID, NULL, CRXProxyMTWrapper, aProxySocket);
		if (aResult < 0)
		{
			break;
		}
#endif
		cout << "Thread(" << aIter + 1 << ") is created successfully." << endl;
	}
	/*----------------------------------------------------------------*/

	return aResult;
}

THREAD_FUNCTION_RETURN
THREAD_FUNCTION_CALLING_CONVENTION
CRXProxyMTWrapper (void * aThreadArg)
{
	int			aResult = 0;

	CRXSocket	& aProxySocket = *((CRXSocket *)aThreadArg);
	CRXProxy	* aProxy = NULL;

	const char	aFilterFileExtension[] = "exe|gif|jpg|png|css|js|ico|swf|";

	/*----------------------------------------------------------------*/
	for (;;)
	{
		aResult = aProxySocket.Accept ();
		if (aResult < 0)
		{
			cout << aProxySocket.GetErrorMessage () << endl;
			aResult = -1;
			break;
		}

		aProxy = new(std::nothrow) CRXProxy (aResult);
		if (aProxy == NULL)
		{
			cout << "Failed to get proxy." << endl;
			aResult = -1;
			break;
		}
		aProxy->SetServerTimeout (2);

		CRXFilter		& aFilter	= aProxy->GetFilter ();
		CRXHttpRequest	& aRequest	= aProxy->GetHttpRequest ();
		CRXHttpResponse	& aResponse	= aProxy->GetHttpResponse ();

		aFilter.SetRequestFilter (CRX_FILTER_REQUEST_FILE_EXTENSION,
								  CRX_FILTER_MATCHED,
								  aFilterFileExtension);

		aResult = aProxy->ReceiveRequest ();
		if (aResult < 0)
		{
			cout << aProxy->GetErrorMessage () << endl;
		}

		if (gViewRequest && !aFilter.CheckRequestFilter (CRX_FILTER_REQUEST_FILE_EXTENSION, aRequest))
		{
			string aRequestHeader = aRequest.GetHeader ();
			aRequestHeader.replace (aRequest.GetHeader ().find (PROXY_CONNECTION), strlen (PROXY_CONNECTION), CONNECTION);
			aRequest.SetHeader (aRequestHeader.c_str ());

			CRX_DEBUG_TRACE ("== Request:  \n%s\n", aRequest.GetHeader ().c_str ());
		}

		aResult = aProxy->SendRequest ();
		if (aResult < 0)
		{
			cout << aProxy->GetErrorMessage () << endl;
		}

		aResult = aProxy->ReceiveResponse ();
		if (aResult < 0)
		{
			cout << aProxy->GetErrorMessage () << endl;
		}

		if (gViewResponse && !aFilter.CheckRequestFilter (CRX_FILTER_REQUEST_FILE_EXTENSION, aRequest))
		{
			CRX_DEBUG_TRACE ("== Response: \n%s\n", aResponse.GetHeader ().c_str ());
			CRX_DEBUG_TRACE_BIN (aResponse.GetContentBody (),
								 aResponse.GetContentLength (),
								 "== Content-Body: \n");
		}

		aResult = aProxy->SendResponse ();
		if (aResult < 0)
		{
			cout << aProxy->GetErrorMessage () << endl;
		}

		delete aProxy;
	}

	cout << " thread exit." << endl;
	/*----------------------------------------------------------------*/

	return (THREAD_FUNCTION_RETURN)0;
}