#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <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>();
	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;
	if (!connection) return ERR_INVALIDD_ARGS;

	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)) {
		::close(sockId);
		return ERR_CONNECTION_FAILED;
	}
	
	TcpSocket *socket = new TcpSocket(*this, connection, nullptr, remoteAddres, sockId);
	connectionOpen(connection, 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;
}