/** 
 @file  unix.c
 @brief ENet Unix system specific functions
*/
#ifndef WIN32

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include <time.h>

#define ENET_BUILDING_LIB 1
#include "enet/enet.h"

#ifdef __APPLE__
#ifdef HAS_POLL
#undef HAS_POLL
#endif
#ifndef HAS_FCNTL
#define HAS_FCNTL 1
#endif
#ifndef HAS_INET_PTON
#define HAS_INET_PTON 1
#endif
#ifndef HAS_INET_NTOP
#define HAS_INET_NTOP 1
#endif
#ifndef HAS_MSGHDR_FLAGS
#define HAS_MSGHDR_FLAGS 1
#endif
#ifndef HAS_SOCKLEN_T
#define HAS_SOCKLEN_T 1
#endif
#endif

#ifdef HAS_FCNTL
#include <fcntl.h>
#endif

#ifdef HAS_POLL
#include <sys/poll.h>
#endif

#ifndef HAS_SOCKLEN_T
typedef int socklen_t;
#endif

#ifndef MSG_NOSIGNAL
#define MSG_NOSIGNAL 0
#endif

static enet_uint32 timeBase = 0;

int enet_initialize(void)
{
	return 0;
}

void enet_deinitialize(void)
{
}

enet_uint32
enet_time_get(void)
{
	struct timeval timeVal;

	gettimeofday(&timeVal, NULL);

	return timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - timeBase;
}

void enet_time_set(enet_uint32 newTimeBase)
{
	struct timeval timeVal;

	gettimeofday(&timeVal, NULL);

	timeBase = timeVal.tv_sec * 1000 + timeVal.tv_usec / 1000 - newTimeBase;
}

int enet_address_set_host(ENetAddress *address, const char *name)
{
	struct hostent *hostEntry = NULL;
#ifdef HAS_GETHOSTBYNAME_R
	struct hostent hostData;
	char buffer[2048];
	int errnum;

#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
	gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &hostEntry, &errnum);
#else
	hostEntry = gethostbyname_r(name, &hostData, buffer, sizeof(buffer), &errnum);
#endif
#else
	hostEntry = gethostbyname(name);
#endif

	if (hostEntry == NULL ||
		hostEntry->h_addrtype != AF_INET)
	{
#ifdef HAS_INET_PTON
		if (!inet_pton(AF_INET, name, &address->host))
#else
		if (!inet_aton(name, (struct in_addr *)&address->host))
#endif
			return -1;
		return 0;
	}

	address->host = *(enet_uint32 *)hostEntry->h_addr_list[0];

	return 0;
}

int enet_address_get_host_ip(const ENetAddress *address, char *name, size_t nameLength)
{
#ifdef HAS_INET_NTOP
	if (inet_ntop(AF_INET, &address->host, name, nameLength) == NULL)
#else
	char *addr = inet_ntoa(*(struct in_addr *)&address->host);
	if (addr != NULL)
		strncpy(name, addr, nameLength);
	else
#endif
		return -1;
	return 0;
}

int enet_address_get_host(const ENetAddress *address, char *name, size_t nameLength)
{
	struct in_addr in;
	struct hostent *hostEntry = NULL;
#ifdef HAS_GETHOSTBYADDR_R
	struct hostent hostData;
	char buffer[2048];
	int errnum;

	in.s_addr = address->host;

#if defined(linux) || defined(__linux) || defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
	gethostbyaddr_r((char *)&in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer), &hostEntry, &errnum);
#else
	hostEntry = gethostbyaddr_r((char *)&in, sizeof(struct in_addr), AF_INET, &hostData, buffer, sizeof(buffer), &errnum);
#endif
#else
	in.s_addr = address->host;

	hostEntry = gethostbyaddr((char *)&in, sizeof(struct in_addr), AF_INET);
#endif

	if (hostEntry == NULL)
		return enet_address_get_host_ip(address, name, nameLength);

	strncpy(name, hostEntry->h_name, nameLength);

	return 0;
}

int enet_socket_bind(ENetSocket socket, const ENetAddress *address)
{
	struct sockaddr_in sin;

	memset(&sin, 0, sizeof(struct sockaddr_in));

	sin.sin_family = AF_INET;

	if (address != NULL)
	{
		sin.sin_port = ENET_HOST_TO_NET_16(address->port);
		sin.sin_addr.s_addr = address->host;
	}
	else
	{
		sin.sin_port = 0;
		sin.sin_addr.s_addr = INADDR_ANY;
	}

	return bind(socket,
				(struct sockaddr *)&sin,
				sizeof(struct sockaddr_in));
}

int enet_socket_listen(ENetSocket socket, int backlog)
{
	return listen(socket, backlog < 0 ? SOMAXCONN : backlog);
}

ENetSocket
enet_socket_create(ENetSocketType type)
{
	return socket(PF_INET, type == ENET_SOCKET_TYPE_DATAGRAM ? SOCK_DGRAM : SOCK_STREAM, 0);
}

int enet_socket_set_option(ENetSocket socket, ENetSocketOption option, int value)
{
	int result = -1;
	switch (option)
	{
		case ENET_SOCKOPT_NONBLOCK:
#ifdef HAS_FCNTL
			result = fcntl(socket, F_SETFL, O_NONBLOCK | fcntl(socket, F_GETFL));
#else
			result = ioctl(socket, FIONBIO, &value);
#endif
			break;

		case ENET_SOCKOPT_BROADCAST:
			result = setsockopt(socket, SOL_SOCKET, SO_BROADCAST, (char *)&value, sizeof(int));
			break;

		case ENET_SOCKOPT_REUSEADDR:
			result = setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, (char *)&value, sizeof(int));
			break;

		case ENET_SOCKOPT_RCVBUF:
			result = setsockopt(socket, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
			break;

		case ENET_SOCKOPT_SNDBUF:
			result = setsockopt(socket, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
			break;

		case ENET_SOCKOPT_RCVTIMEO:
			result = setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&value, sizeof(int));
			break;

		case ENET_SOCKOPT_SNDTIMEO:
			result = setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&value, sizeof(int));
			break;

		default:
			break;
	}
	return result == -1 ? -1 : 0;
}

int enet_socket_connect(ENetSocket socket, const ENetAddress *address)
{
	struct sockaddr_in sin;
	int result;

	memset(&sin, 0, sizeof(struct sockaddr_in));

	sin.sin_family = AF_INET;
	sin.sin_port = ENET_HOST_TO_NET_16(address->port);
	sin.sin_addr.s_addr = address->host;

	result = connect(socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in));
	if (result == -1 && errno == EINPROGRESS)
		return 0;

	return result;
}

ENetSocket
enet_socket_accept(ENetSocket socket, ENetAddress *address)
{
	int result;
	struct sockaddr_in sin;
	socklen_t sinLength = sizeof(struct sockaddr_in);

	result = accept(socket,
					address != NULL ? (struct sockaddr *)&sin : NULL,
					address != NULL ? &sinLength : NULL);

	if (result == -1)
		return ENET_SOCKET_NULL;

	if (address != NULL)
	{
		address->host = (enet_uint32)sin.sin_addr.s_addr;
		address->port = ENET_NET_TO_HOST_16(sin.sin_port);
	}

	return result;
}

int enet_socket_shutdown(ENetSocket socket, ENetSocketShutdown how)
{
	return shutdown(socket, (int)how);
}

void enet_socket_destroy(ENetSocket socket)
{
	if (socket != -1)
		close(socket);
}

int enet_socket_send(ENetSocket socket,
					 const ENetAddress *address,
					 const ENetBuffer *buffers,
					 size_t bufferCount)
{
	struct msghdr msgHdr;
	struct sockaddr_in sin;
	int sentLength;

	memset(&msgHdr, 0, sizeof(struct msghdr));

	if (address != NULL)
	{
		memset(&sin, 0, sizeof(struct sockaddr_in));

		sin.sin_family = AF_INET;
		sin.sin_port = ENET_HOST_TO_NET_16(address->port);
		sin.sin_addr.s_addr = address->host;

		msgHdr.msg_name = &sin;
		msgHdr.msg_namelen = sizeof(struct sockaddr_in);
	}

	msgHdr.msg_iov = (struct iovec *)buffers;
	msgHdr.msg_iovlen = bufferCount;

	sentLength = sendmsg(socket, &msgHdr, MSG_NOSIGNAL);

	if (sentLength == -1)
	{
		if (errno == EWOULDBLOCK)
			return 0;

		return -1;
	}

	return sentLength;
}

int enet_socket_receive(ENetSocket socket,
						ENetAddress *address,
						ENetBuffer *buffers,
						size_t bufferCount)
{
	struct msghdr msgHdr;
	struct sockaddr_in sin;
	int recvLength;

	memset(&msgHdr, 0, sizeof(struct msghdr));

	if (address != NULL)
	{
		msgHdr.msg_name = &sin;
		msgHdr.msg_namelen = sizeof(struct sockaddr_in);
	}

	msgHdr.msg_iov = (struct iovec *)buffers;
	msgHdr.msg_iovlen = bufferCount;

	recvLength = recvmsg(socket, &msgHdr, MSG_NOSIGNAL);

	if (recvLength == -1)
	{
		if (errno == EWOULDBLOCK)
			return 0;

		return -1;
	}

#ifdef HAS_MSGHDR_FLAGS
	if (msgHdr.msg_flags & MSG_TRUNC)
		return -1;
#endif

	if (address != NULL)
	{
		address->host = (enet_uint32)sin.sin_addr.s_addr;
		address->port = ENET_NET_TO_HOST_16(sin.sin_port);
	}

	return recvLength;
}

int enet_socketset_select(ENetSocket maxSocket, ENetSocketSet *readSet, ENetSocketSet *writeSet, enet_uint32 timeout)
{
	struct timeval timeVal;

	timeVal.tv_sec = timeout / 1000;
	timeVal.tv_usec = (timeout % 1000) * 1000;

	return select(maxSocket + 1, readSet, writeSet, NULL, &timeVal);
}

int enet_socket_wait(ENetSocket socket, enet_uint32 *condition, enet_uint32 timeout)
{
#ifdef HAS_POLL
	struct pollfd pollSocket;
	int pollCount;

	pollSocket.fd = socket;
	pollSocket.events = 0;

	if (*condition & ENET_SOCKET_WAIT_SEND)
		pollSocket.events |= POLLOUT;

	if (*condition & ENET_SOCKET_WAIT_RECEIVE)
		pollSocket.events |= POLLIN;

	pollCount = poll(&pollSocket, 1, timeout);

	if (pollCount < 0)
		return -1;

	*condition = ENET_SOCKET_WAIT_NONE;

	if (pollCount == 0)
		return 0;

	if (pollSocket.revents & POLLOUT)
		*condition |= ENET_SOCKET_WAIT_SEND;

	if (pollSocket.revents & POLLIN)
		*condition |= ENET_SOCKET_WAIT_RECEIVE;

	return 0;
#else
	fd_set readSet, writeSet;
	struct timeval timeVal;
	int selectCount;

	timeVal.tv_sec = timeout / 1000;
	timeVal.tv_usec = (timeout % 1000) * 1000;

	FD_ZERO(&readSet);
	FD_ZERO(&writeSet);

	if (*condition & ENET_SOCKET_WAIT_SEND)
		FD_SET(socket, &writeSet);

	if (*condition & ENET_SOCKET_WAIT_RECEIVE)
		FD_SET(socket, &readSet);

	selectCount = select(socket + 1, &readSet, &writeSet, NULL, &timeVal);

	if (selectCount < 0)
		return -1;

	*condition = ENET_SOCKET_WAIT_NONE;

	if (selectCount == 0)
		return 0;

	if (FD_ISSET(socket, &writeSet))
		*condition |= ENET_SOCKET_WAIT_SEND;

	if (FD_ISSET(socket, &readSet))
		*condition |= ENET_SOCKET_WAIT_RECEIVE;

	return 0;
#endif
}

#endif
