#include <fcntl.h></fcntl.h>

#include <unistd.h></unistd.h>

#include <sys types.h=""></sys>

#include <sys socket.h=""></sys>

#include <sys epoll.h=""></sys>

#include <netinet in.h=""></netinet>

#include <netinet tcp.h=""></netinet>

#include <netdb.h></netdb.h>

#include "protocol.h"

#include "server.h"

#include "connection.h"

#include "tcpprotocol.h"

TcpSocket::TcpSocket(

	Protocol &protocol,

	const Connection::Handle &connection,

	const Server::Handle &server,

	const Address &address,

	int sockId

):

	Socket(protocol, connection, server, address),

	sockId(sockId)

{

	int tcp_nodelay = 1;

	setsockopt(sockId, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay, sizeof(int));

	fcntl(sockId, F_SETFL, fcntl(sockId, F_GETFL, 0) | O_NONBLOCK);

	struct epoll_event event = {};

	event.data.ptr = this;

	epoll_ctl(getProtocol().epollId, EPOLL_CTL_ADD, sockId, &event);

}

TcpProtocol::TcpProtocol():

	thread(), stopping() { }

ErrorCode TcpProtocol::resolve(Address &address) {

	if (address.type == Address::SOCKET)

		return ERR_NONE;

	if ( address.type != Address::COMMON_STRING

	  || address.text.empty() )

		return ERR_ADDRESS_INCORRECT;

	// split to host and port

	const char *addrString = address.text.c_str();

	const char *colon = addrString;

	while(*colon && *colon != ':') ++colon;

	std::string hostBuf;

	const char *host = nullptr;

	const char *port = nullptr;

	if (*colon) {

		hostBuf.assign(addrString, colon);

		host = hostBuf.c_str();

		port = colon + 1;

	} else {

		bool allDigits = true;

		for(const char *c = addrString; *c && allDigits; ++c)

			if (*c < '0' || *c > '9') allDigits = false;

		(allDigits ? port : host) = addrString;

	}

	// get ipv4

	unsigned char ip[4] = {};

	if (host) {

		if (4 != sscanf(host, "%hhu.%hhu.%hhu.%hhu", &ip[0], &ip[1], &ip[2], &ip[3])) {

			hostent *he;

			in_addr **addr_list;

			if ( (he = gethostbyname(host))

			  && (addr_list = (struct in_addr**)he->h_addr_list)

			  && (*addr_list) )

			{

				memcpy(ip, *addr_list, sizeof(ip));

			} else {

				return ERR_ADDRESS_NOT_FOUND;

			}

		}

	}

	unsigned short portNum = 0;

	if (!port || 1 != sscanf(port, "%hu", &portNum) || !portNum)

		return ERR_ADDRESS_INCORRECT;

	address.set(Address::SOCKET);

	sockaddr_in &addr = address.as<sockaddr_in>();</sockaddr_in>

	addr.sin_family = AF_INET;

	memcpy(&addr.sin_addr, ip, sizeof(ip));

	addr.sin_port = htons(portNum);

	return ERR_NONE;

}

void TcpProtocol::threadRun() {

	const int count = 1024;

	struct epoll_event events[count] = {};

	while(true) {

		epoll_wait(epollId, events, count, 1000);

		break;

	}

	closeAll();

}

ErrorCode TcpProtocol::connect(const Connection::Handle &connection, const Address &address) {

	if (!thread) return ERR_PROTOCOL_NOT_INITIALIZED;

	Address remoteAddres = address;

	ErrorCode errorCode = resolve(remoteAddres);

	if (errorCode) return errorCode;

	Lock lock(mutex);

	int sockId = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

	if (0 != ::connect(sockId, &remoteAddres.as<sockaddr>(), remoteAddres.size)) {</sockaddr>

		::close(sockId);

		return ERR_CONNECTION_FAILED;

	}

	TcpSocket *socket = new TcpSocket(*this, connection, nullptr, remoteAddres, sockId);

	connection->open(socket);

	return ERR_NONE;

}

ErrorCode TcpProtocol::listen(const Server::Handle &server, const Address &address) {

	return ERR_NOT_IMPLEMENTED;

}

void TcpProtocol::start() {

	stop();

	epollId = ::epoll_create(32);

	thread = new std::thread(&TcpProtocol::threadRun, this);

}

void TcpProtocol::stop() {

	if (!thread) return;

	{ Lock lock2(mutex); stopping = true; }

	thread->join();

	delete thread;

	::close(epollId);

	epollId = 0;

}