#include <cstring></cstring>

#include <cstdlib></cstdlib>

#include <cstdio></cstdio>

#include <cerrno></cerrno>

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

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

#include <poll.h></poll.h>

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

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

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

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

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

#include "socket.h"

static void addressToInaddr(const Address &address, struct sockaddr_in &addr) {

	memset(&addr, 0, sizeof(addr));

	addr.sin_family = AF_INET;

	addr.sin_addr.s_addr = address.ipUInt;

	addr.sin_port = htons(address.port);

}

static bool configureTcpSocket(int sockId) {

	int tcp_nodelay = 1;

	return 0 == setsockopt(sockId, IPPROTO_TCP, TCP_NODELAY, &tcp_nodelay, sizeof(int))

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

}

Poll::Poll() { }

Poll::~Poll() { }

bool Poll::wait(Time duration) {

	const size_t count = list.size();

	const size_t size = sizeof(struct pollfd) * count;

	if (data.size() < size)

		data.resize(size);

	int mills = (int)((duration + rand()%1000)/1000);

	int res;

	if (size) {

		memset(data.data(), 0, size);

		struct pollfd *pfdFirst = (struct pollfd *)data.data();

		struct pollfd *pfd = pfdFirst;

		for(List::const_iterator i = list.begin(); i != list.end(); ++i, ++pfd) {

			pfd->fd = i->sockId;

			pfd->events = POLLRDHUP;

			if (i->wantRead) pfd->events |= POLLIN;

			if (i->wantWrite) pfd->events |= POLLOUT;

		}

		res = poll(pfdFirst, count, mills);

		if (res > 0) {

			struct pollfd *pfd = pfdFirst;

			for(List::iterator i = list.begin(); i != list.end(); ++i, ++pfd) {

				unsigned int e = pfd->revents;

				i->canRead  = (bool)(e & POLLIN);

				i->canWrite = (bool)(e & POLLOUT);

				i->closed   = (bool)(e & (POLLHUP | POLLRDHUP | POLLERR | POLLNVAL));

			}

		}

	} else {

		res = poll(NULL, 0, mills);

	}

	return res >= 0;

}

int Socket::tcpConnect(const Address &address) {

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

	if (sockId < 0) return -1;

	struct sockaddr_in addr;

	addressToInaddr(address, addr);

	if ( 0 != ::connect(sockId, (struct sockaddr*)&addr, sizeof(addr))

	  || !configureTcpSocket(sockId) )

		{ ::close(sockId); return -1; }

	return sockId;

}

int Socket::tcpListen(const Address &address) {

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

	if (sockId < 0) return -1;

	struct sockaddr_in addr;

	addressToInaddr(address, addr);

	if ( 0 != ::bind(sockId, (struct sockaddr*)&addr, sizeof(addr))

	  || 0 != ::listen(sockId, 16)

	  || !configureTcpSocket(sockId) )

		{ ::close(sockId); return -1; }

	return sockId;

}

int Socket::tcpAccept(int sockId, Address &address) {

	address = Address();

	struct sockaddr_in addr = {};

	addr.sin_family = AF_INET;

	socklen_t len = sizeof(addr);

	int newSockId = ::accept(sockId, (struct sockaddr*)&addr, &len);

	if (newSockId < 0) return -1;

	if (!configureTcpSocket(newSockId))

		{ ::close(newSockId); return -1; }

	address.ipUInt = addr.sin_addr.s_addr;

	address.port = ntohs(addr.sin_port);

	return newSockId;

}

int Socket::tcpSendAsync(int sockId, const void *data, int size) {

	int res = ::send(sockId, data, size, MSG_DONTWAIT);

	return res > 0 ? res : 0;

}

int Socket::tcpRecvAsync(int sockId, void *data, int size) {

	int res = ::recv(sockId, data, size, MSG_DONTWAIT);

	return res > 0 ? res : 0;

}

int Socket::udpBind(const Address &address) {

	int sockId = ::socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

	if (sockId < 0) return -1;

	struct sockaddr_in addr;

	addressToInaddr(address, addr);

	if (0 != ::bind(sockId, (struct sockaddr*)&addr, sizeof(addr))) {

		::close(sockId);

		return -1;

	}

	return sockId;

}

int Socket::udpSend(int sockId, const Address &address, const void *data, int size) {

	struct sockaddr_in addr;

	addressToInaddr(address, addr);

	int res = ::sendto(sockId, data, size, 0, (struct sockaddr*)&addr, sizeof(addr));

	return res > 0 ? res : 0;

}

int Socket::udpRecvAsync(int sockId, Address &address, void *data, int size) {

	address = Address();

	struct sockaddr_in addr = {};

	addr.sin_family = AF_INET;

	socklen_t len = sizeof(addr);

	int res = ::recvfrom(sockId, data, size, MSG_DONTWAIT, (struct sockaddr*)&addr, &len);

	if (res <= 0) return 0;

	address.ipUInt = addr.sin_addr.s_addr;

	address.port = ntohs(addr.sin_port);

	return res;

}

void Socket::close(int sockId)

	{ ::close(sockId); }