#include <iostream>
#include <boost/asio.hpp>
#include <boost/lexical_cast.hpp>
#include <thread>
#include <array>
#include <iomanip>

#include <boost/bind.hpp>

#include <boost/thread.hpp>


#if 0
#define SSL_R_SHORT_READ 219
#include "ssl/ssl_locl.h"
#include <boost/asio/ssl.hpp>
#endif

#if defined(close)
#undef close
#endif

enum AddressType
{
	AT_IPV4 = 0,
	AT_HOST = 3,
	AT_IPV6 = 4
};

class ConnectResponseRecord
{
public:
	std::vector<unsigned char> rawData;

	enum ConnectResponseType
	{
		CRT_SUCCESS = 0,
		CRT_GENERAL_SOCKS_SERVER_FAILURE = 1,
		CRT_CONNECTION_NOT_ALLOWED_BY_RULESET = 2,
		CRT_NETWORK_UNREACHABLE = 3,
		CRT_HOST_UNREACHABLE = 4,
		CRT_CONNECTION_REFUSED = 5,
		CRT_TTL_EXPIRED = 6,
		CRT_COMMAND_NOT_SUPPORTED = 7,
		CRT_ADDRESS_TYPE_NOT_SUPPORTED = 8,
		CRT_TO_FF_UNASSIGNED = 9
	};

	ConnectResponseType connectResponseType;

	AddressType addressType;

	std::string address;

	uint16_t port;
};

class ConnectRequestRecord
{
public:
	std::string address;
	uint16_t port;

	std::string getRequestData();
};

std::string ConnectRequestRecord::getRequestData()
{
	std::string data = "";
	data += 0x05;
	data += 0x01;
	data += char(0x00);
	data += 0x03;
	data += static_cast<unsigned char>(address.size());
	data += address;
	data += port / 256;
	data += port % 256;
	return data;
}



class ProxySession :
	public std::enable_shared_from_this<ProxySession>
{
public:
	ProxySession(boost::asio::ip::tcp::socket inSocket, boost::asio::io_service& inIoService)
		: ioService(inIoService)
		, mSocket(std::move(inSocket))
		, outsideConnectSocket(ioService)
	{
		std::cout << "ProxySession Create" << std::endl;
	}

	~ProxySession()
	{
		std::cout << "ProxySession Destroy" << std::endl;
	}

	void start()
	{
		std::cout << "ProxySession::start" << std::endl;
		//asyncHandshake();
		readClientVersion();
	}


private:

	boost::asio::ip::tcp::socket& socket()
	{
		return mSocket;
	}


	std::array<unsigned char, 3> clientVersion;
	
	void readClientVersion()
	{
		std::cout << "ProxySession::readClientVersion" << std::endl;
		auto self(shared_from_this());

		boost::asio::async_read(socket(),
			boost::asio::buffer(clientVersion.data(), clientVersion.size()),
			[this, self](boost::system::error_code ec, std::size_t /*length*/)
		{
			std::cout << "ProxySession::readClientVersion inner" << std::endl;
			if (!ec)
			{
				if (clientVersion[0] == 0x05 && clientVersion[1] == 0x01 && clientVersion[2] == 0x02)
				{
					sendServerVersion();
				}
				else if (clientVersion[0] == 0x05 && clientVersion[1] == 0x01 && clientVersion[2] == 0x00)
				{
					sendServerVersionNoAuth();
				}
				else
				{
					std::string msg = ec.message();
					std::cout << msg << std::endl;
					socket().close();
				}
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});
	}


	void sendServerVersion()
	{

		std::cout << "ProxySession::sendServerVersion" << std::endl;

		auto self(shared_from_this());
	
		std::array<char, 2> version = { 0x05, 0x02 };

		boost::asio::async_write(socket(),
			boost::asio::buffer(version.data(), version.size()),
			[this, self](boost::system::error_code ec, std::size_t length)
		{
			std::cout << "ProxySession::sendServerVersion inner" << std::endl;
			if (!ec)
			{
				readLoginPassword();
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});
	}

	void sendServerVersionNoAuth()
	{

		std::cout << "ProxySession::sendServerVersionNoAuth" << std::endl;

		auto self(shared_from_this());

		std::array<char, 2> version = { 0x05, 0x00 };

		boost::asio::async_write(socket(),
			boost::asio::buffer(version.data(), version.size()),
			[this, self](boost::system::error_code ec, std::size_t length)
		{
			std::cout << "ProxySession::sendServerVersionNoAuth inner" << std::endl;
			if (!ec)
			{
				//readLoginPassword();
				readConnectRequest();
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();

			}
		});
	}


	void readLoginPassword()
	{
		std::string login = "telegram-proxy-user";
		std::string password = "telegram-telegram-999112";
		std::string expectedData = "";
		expectedData += 0x01;
		expectedData += static_cast<unsigned char>(login.size());
		expectedData += login;
		expectedData += static_cast<unsigned char>(password.size());
		expectedData += password;

		std::shared_ptr<std::string> clientLoginPasswordPtr = std::make_shared<std::string>();


		clientLoginPasswordPtr->resize(expectedData.size());


		auto self(shared_from_this());


		boost::asio::async_read(socket(),
			boost::asio::buffer(&((*clientLoginPasswordPtr)[0]), clientLoginPasswordPtr->size()),
			[this, self, expectedData, clientLoginPasswordPtr](boost::system::error_code ec, std::size_t /*length*/)
		{
			if (!ec)
			{
				if (*clientLoginPasswordPtr == expectedData)
				{
					sendAuthStatus();
				}
				else
				{
					std::string msg = ec.message();
					std::cout << msg << std::endl;
					socket().close();
				}
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});

	}

	std::array<unsigned char, 2> authStatus = std::array<unsigned char, 2>{ (unsigned char)0x01, (unsigned char)0x00 };

	void sendAuthStatus()
	{
		auto self(shared_from_this());

		

		boost::asio::async_write(socket(),
			boost::asio::buffer(authStatus.data(), authStatus.size()),
			[this, self](boost::system::error_code ec, std::size_t length)
		{

			if (!ec)
			{
				readConnectRequest();
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});
	}

	void readConnectRequest()
	{

		std::cout << "ProxySession::readConnectRequest" << std::endl;

		std::shared_ptr<std::array<unsigned char, 5>> firstPartPtr = std::make_shared<std::array<unsigned char, 5>>();


		auto self(shared_from_this());


		boost::asio::async_read(socket(),
			boost::asio::buffer(firstPartPtr->data(), firstPartPtr->size()),
			[this, self, firstPartPtr](boost::system::error_code ec, std::size_t /*length*/)
		{
			std::cout << "ProxySession::readConnectRequest iner" << std::endl;

			if (!ec)
			{
				if ((*firstPartPtr)[0] == 0x05 && (*firstPartPtr)[1] == 0x01 && (*firstPartPtr)[2] == 0x00)
				{
					if ((*firstPartPtr)[3] == 0x03)
					{
						readConnectRequestPart2(firstPartPtr);
					}
					else if ((*firstPartPtr)[3] == 0x01)
					{
						readConnectRequestPart2IpAddress(firstPartPtr);
					}

				}
				else
				{
					std::string msg = ec.message();
					std::cout << msg << std::endl;
					socket().close();
				}
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});

	}


	void readConnectRequestPart2(std::shared_ptr<std::array<unsigned char, 5>> firstPartPtr)
	{
		unsigned int len = (*firstPartPtr)[4];

		std::shared_ptr<std::vector<unsigned char>> secondPartPtr = std::make_shared<std::vector<unsigned char>>();


		secondPartPtr->resize(len + 2);

		auto self(shared_from_this());


		boost::asio::async_read(socket(),
			boost::asio::buffer(secondPartPtr->data(), secondPartPtr->size()),
			[this, self, firstPartPtr, secondPartPtr, len](boost::system::error_code ec, std::size_t /*length*/)
		{
			if (!ec)
			{

				ConnectRequestRecord connectRequestRecord;

				connectRequestRecord.address = std::string(&((*secondPartPtr)[0]), &((*secondPartPtr)[0]) + len);
				connectRequestRecord.port = (*secondPartPtr)[len] * 256 + (*secondPartPtr)[len + 1];

				boost::asio::ip::tcp::resolver resolver(this->ioService);
				auto endpointIterator = resolver.resolve({ connectRequestRecord.address, boost::lexical_cast<std::string>(connectRequestRecord.port) });


				doConnectOutput(endpointIterator, connectRequestRecord);

			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});

	}


	void readConnectRequestPart2IpAddress(std::shared_ptr<std::array<unsigned char, 5>> firstPartPtr)
	{
		unsigned int ip1st = (*firstPartPtr)[4];

		std::shared_ptr<std::array<unsigned char, 5>> secondPartPtr = std::make_shared<std::array<unsigned char, 5>>();


		auto self(shared_from_this());


		boost::asio::async_read(socket(),
			boost::asio::buffer(secondPartPtr->data(), secondPartPtr->size()),
			[this, self, firstPartPtr, secondPartPtr, ip1st](boost::system::error_code ec, std::size_t /*length*/)
		{
			if (!ec)
			{

				ConnectRequestRecord connectRequestRecord;

				connectRequestRecord.address = boost::lexical_cast<std::string>(static_cast<unsigned int>(ip1st)) + "."
					+ boost::lexical_cast<std::string>(static_cast<unsigned int>((*secondPartPtr)[0])) + "."
					+ boost::lexical_cast<std::string>(static_cast<unsigned int>((*secondPartPtr)[1])) + "."
					+ boost::lexical_cast<std::string>(static_cast<unsigned int>((*secondPartPtr)[2]));

				connectRequestRecord.port = (*secondPartPtr)[3] * 256 + (*secondPartPtr)[4];

				boost::asio::ip::tcp::resolver resolver(this->ioService);
				auto endpointIterator = resolver.resolve({ connectRequestRecord.address, boost::lexical_cast<std::string>(connectRequestRecord.port) });


				doConnectOutputIpAddress(endpointIterator, connectRequestRecord, { static_cast<unsigned char>(ip1st) , ((*secondPartPtr)[0]) , ((*secondPartPtr)[1]) , ((*secondPartPtr)[2]) });

			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
			}
		});

	}


	void doConnectOutput(boost::asio::ip::tcp::resolver::iterator endpointIterator, ConnectRequestRecord connectRequestRecord)
	{
		auto self(shared_from_this());

		boost::asio::async_connect(outsideConnectSocket, endpointIterator,
			[this, self, connectRequestRecord](boost::system::error_code ec, boost::asio::ip::tcp::resolver::iterator)
		{
			if (!ec)
			{
				sendConnectResponse(connectRequestRecord);
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
				outsideConnectSocket.close();
			}
		});
	}

	void doConnectOutputIpAddress(boost::asio::ip::tcp::resolver::iterator endpointIterator, ConnectRequestRecord connectRequestRecord, std::array<unsigned char, 4> ipAddress)
	{
		auto self(shared_from_this());

		boost::asio::async_connect(outsideConnectSocket, endpointIterator,
			[this, self, connectRequestRecord, ipAddress](boost::system::error_code ec, boost::asio::ip::tcp::resolver::iterator)
		{
			if (!ec)
			{
				sendConnectResponseIpAddress(connectRequestRecord, ipAddress);
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
				outsideConnectSocket.close();
			}
		});
	}


	void sendConnectResponse(ConnectRequestRecord connectRequestRecord)
	{
		auto self(shared_from_this());

		std::string connectResponse;

		connectResponse += 0x05;
		connectResponse += static_cast<char>(0x00);
		connectResponse += static_cast<char>(0x00);
		connectResponse += 0x03;

		connectResponse += static_cast<unsigned char>(connectRequestRecord.address.size());
		connectResponse += connectRequestRecord.address;
		connectResponse += static_cast<unsigned char>(connectRequestRecord.port / 256);
		connectResponse += static_cast<unsigned char>(connectRequestRecord.port % 256);


		boost::asio::async_write(socket(),
			boost::asio::buffer(connectResponse.data(), connectResponse.size()),
			[this, self](boost::system::error_code ec, std::size_t length)
		{

			if (!ec)
			{
				transferDataForward();
				transferDataBackward();
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
				outsideConnectSocket.close();
			}
		});

	}


	void sendConnectResponseIpAddress(ConnectRequestRecord connectRequestRecord, std::array<unsigned char, 4> ipAddress)
	{
		auto self(shared_from_this());

		std::string connectResponse;

		connectResponse += 0x05;
		connectResponse += static_cast<char>(0x00);
		connectResponse += static_cast<char>(0x00);
		connectResponse += 0x01;

		connectResponse += ipAddress[0];
		connectResponse += ipAddress[1];
		connectResponse += ipAddress[2];
		connectResponse += ipAddress[3];
		connectResponse += static_cast<unsigned char>(connectRequestRecord.port / 256);
		connectResponse += static_cast<unsigned char>(connectRequestRecord.port % 256);


		boost::asio::async_write(socket(),
			boost::asio::buffer(connectResponse.data(), connectResponse.size()),
			[this, self](boost::system::error_code ec, std::size_t length)
		{

			if (!ec)
			{
				transferDataForward();
				transferDataBackward();
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				socket().close();
				outsideConnectSocket.close();
			}
		});

	}


	std::array<unsigned char, 8192> forwardBuffer;
	std::array<unsigned char, 8192> backwardBuffer;
	//unsigned char forwardChar;
	//unsigned char backwardChar;


	void transferDataForward()
	{
		auto self(shared_from_this());

		socket().async_read_some(boost::asio::buffer(forwardBuffer),
			[this, self](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{

				std::shared_ptr<std::vector<unsigned char>> data = std::make_shared<std::vector<unsigned char>>();
				data->resize(length);

				std::copy(&forwardBuffer[0], &forwardBuffer[0] + length, &(*data)[0]);

				std::cout << "Forward Received " << length << " Bytes, sending\n";

				std::cout << boost::lexical_cast<std::string>(int(forwardBuffer[0])) << "\n";
				std::cout << boost::lexical_cast<std::string>(int(forwardBuffer[length - 1])) << "\n";

				

				boost::asio::async_write(outsideConnectSocket,
					boost::asio::buffer(*data),
					[this, self, data](boost::system::error_code ec, std::size_t length)
				{

					if (!ec)
					{
						std::cout << "Forward Sent, now read again!\n";
						transferDataForward();
					}
					else
					{
						std::string msg = ec.message();
						std::cout << msg << std::endl;
						outsideConnectSocket.close();
						socket().close();
					}
				});
			}
			else if (ec == boost::asio::error::eof)
			{
				std::cout << "transferDataForward read end of file" << std::endl;
				if (length > 0)
				{
					std::cout << "but length is positive" << std::endl;
				}
				return;
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				outsideConnectSocket.close();
				socket().close();
			}
		});
	}

	void transferDataBackward()
	{
		auto self(shared_from_this());

		outsideConnectSocket.async_read_some(boost::asio::buffer(backwardBuffer),
			[this, self](boost::system::error_code ec, std::size_t length)
		{
			if (!ec)
			{

				std::shared_ptr<std::vector<unsigned char>> data = std::make_shared<std::vector<unsigned char>>();
				data->resize(length);

				std::copy(&backwardBuffer[0], &backwardBuffer[0] + length, &(*data)[0]);

				std::cout << "Backward Received " << length << " Bytes, sending\n";

				std::cout << boost::lexical_cast<std::string>(int(backwardBuffer[0])) << "\n";
				std::cout << boost::lexical_cast<std::string>(int(backwardBuffer[length - 1])) << "\n";




				boost::asio::async_write(socket(),
					boost::asio::buffer(*data),
					[this, self, data](boost::system::error_code ec, std::size_t length)
				{

					if (!ec)
					{
						std::cout << "Backward Sent, now read again!\n";
						transferDataBackward();
					}
					else
					{
						std::string msg = ec.message();
						std::cout << msg << std::endl;
						outsideConnectSocket.close();
						socket().close();
					}
				});
			}
			else if (ec == boost::asio::error::eof)
			{
				std::cout << "transferDataBackward read end of file" << std::endl;
				if (length > 0)
				{
					std::cout << "but length is positive" << std::endl;
				}
				return;
			}
			else
			{
				std::string msg = ec.message();
				std::cout << msg << std::endl;
				outsideConnectSocket.close();
				socket().close();
			}
		});
	}

	boost::asio::io_service& ioService;

	boost::asio::ip::tcp::socket mSocket;

	boost::asio::ip::tcp::socket outsideConnectSocket;

	
};





class ProxyServer
{
public:
	ProxyServer(boost::asio::io_service& inIoService,
		const boost::asio::ip::tcp::endpoint& endpoint)
		: ioService(inIoService)
		, acceptor(inIoService, endpoint)
		, socket(inIoService)
	{
		doAccept();
	}

private:
	void doAccept()
	{
		acceptor.async_accept(socket,
			[this](boost::system::error_code ec)
		{
			if (!ec)
			{
				std::make_shared<ProxySession>(std::move(socket), ioService)->start();
			}

			counter++;

			socket = boost::asio::ip::tcp::socket(ioService);

			doAccept();
		});
	}

	boost::asio::io_service& ioService;

	boost::asio::ip::tcp::acceptor acceptor;
	boost::asio::ip::tcp::socket socket;

	size_t counter = 0;
};


#include "http/server.hpp"

int main()
{

	try
	{

		// Initialise the server.
		http::server::server s("0.0.0.0", "8043", ".");

		// Run the server until stopped.
		s.run();
	}
	catch (std::exception& e)
	{
		std::cerr << "exception: " << e.what() << "\n";
	}

	return 0;
}


int main_0()
{

	try
	{

		boost::asio::io_service ioService;

		boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), 8043);



		ProxyServer proxyServer(ioService, endpoint);


		boost::thread_group threadpool;

		threadpool.create_thread(
			boost::bind(&boost::asio::io_service::run, &ioService)
		);


		threadpool.join_all();

		//ioService.run();

	}
	catch (std::exception& e)
	{
		std::cerr << "Exception: " << e.what() << "\n";
	}


	return 0;

}