#include "server.h"

int main(int argc, char ** argv)
{
	/* variables to parse arguments */
	extern int optind,
			   optopt;
	extern char * optarg;
	char * log_file;
	int c		= (int)NULL,
		errflg	= (int)NULL,
		verbose	= (int)NULL;

	/* fd -> file descriptor */
	int socket_server_fd	= (int)NULL,
		socket_server_port	= (int)NULL,
		socket_accept_fd	= (int)NULL,
		sockaddr_in_size	= sizeof(struct sockaddr_in),
		err					= (int)NULL;

	/* Internet socket address stuct */
	struct sockaddr_in server_addr,
					   accept_addr;

	struct client * clients = (struct client *) NULL,
				  * current = (struct client *) NULL;

	pthread_t threads;

	/* clear screen */
	system(__CLEAR_SCREEN__);

	while ( (c = getopt(argc, argv, ":vp:")) != -1 )
	{
		switch ( c )
		{
			case 'p':
				if ( socket_server_port = strtol(optarg, 0, 10) == 0 )
				{
					fprintf(stderr, "Option -%c requires a valid port and '%s' isn't valid\n", optopt, optarg);
					++errflg;
				}
				break;
			case 'v':
				verbose = 1;
				break;
			case ':':
				/* -f or -o without operand */
				fprintf(stderr, "Option -%c requires an operand\n", optopt);
				++errflg;
				break;
			case '?':
				fprintf(stderr, "Unrecognized option: -%c\n", optopt);
				++errflg;
		}
	}
	if ( errflg )
	{
		fprintf(stderr, "usage: . . . \n\n");
		exit(2);
	}
	//exit(0);

	/*if ( argc != 2 || (socket_server_port = strtol(argv[1], 0, 10)) == 0 )
		usage();*/

	/* make a socket */
	socket_server_fd = socket(AF_INET, SOCK_STREAM, 0);
	if ( socket_server_fd == __SOCKET_ERROR__ )
	{
		printf("\nCould not make a socket\n");
		return 0;
	}

	bzero((char *) &server_addr, sockaddr_in_size);
	bzero((char *) &accept_addr, sockaddr_in_size);

	if ( !socket_server_port )
		socket_server_port = __DEFAULT_OPEN_PORT__;

	/* fill address struct */
	server_addr.sin_addr.s_addr	= INADDR_ANY;
	server_addr.sin_port		= htons(socket_server_port);
	server_addr.sin_family		= AF_INET;
	bzero(&(server_addr.sin_zero), 8);

	if ( __DEBUG__  || verbose )
		printf("\nBinding to port %d...\n", socket_server_port);

	/* bind to a port */
	if ( bind(socket_server_fd, (struct sockaddr *)&(server_addr), sizeof(server_addr)) == __SOCKET_ERROR__ )
	{
		printf("\nCould not connect to host\n");
		exit(1);
	}

	/* get port number */
	getsockname(socket_server_fd, (struct sockaddr *)&(server_addr), (socklen_t *) &(sockaddr_in_size));
	if ( __DEBUG__  || verbose )
	{
		printf("\nopened socket as fd (%d) on port (%d) for stream i/o\n", socket_server_fd, ntohs(server_addr.sin_port));

		printf("Server\n\
				sin_family        = %d\n\
				sin_addr.s_addr   = %d\n\
				sin_port          = %d\n"
				, server_addr.sin_family
				, server_addr.sin_addr.s_addr
				, ntohs(server_addr.sin_port)
			  );
		printf("\nMaking a listen queue of %d elements", __QUEUE_SIZE__);
	}

	/* establish listen queue */
	if ( listen(socket_server_fd, __QUEUE_SIZE__) == __SOCKET_ERROR__ )
	{
		printf("\nCould not listen\n");
		return 0;
	}

	for ( ; ; )
	{
		if ( __DEBUG__  || verbose )
			puts("\nWaiting for a connection\n");

		/* get the connected socket */
		socket_accept_fd = accept(socket_server_fd, (struct sockaddr *) &(accept_addr), (socklen_t *) &(sockaddr_in_size));
		fcntl(socket_accept_fd, F_SETFL, fcntl(socket_accept_fd, F_GETFL, 0) | O_NDELAY);

		if ( socket_accept_fd > -1 )
		{
			if ( clients == (struct client *) NULL )
				current = clients;
			else
				while ( (current = clients->next) != (struct client *) NULL );

			current				= (struct client *) malloc(sizeof(struct client));
			current->next		= (struct client *) NULL;
			current->fd			= socket_accept_fd;
			current->sockaddr	= accept_addr;
			current->last		= time(NULL);

			pthread_create(&(threads), NULL, handler, (void *) current);
		}
		puts("jah era #5");
	}
	pthread_exit(NULL);
}

void * handler(void * pClient)
{
    char pBuffer[__BUFFER_SIZE__];
    struct client * client = (struct client *) pClient;
    int i = 0, err;
	time_t last;

	char ip[46];
	unsigned short port;
	inet_ntop(AF_INET, &(client->sockaddr.sin_addr), ip, sizeof (ip));
	port = ntohs(client->sockaddr.sin_port);
	printf("\nGot a connection from %s, port %hu\n", ip, port);
	//fcntl( client->fd, F_SETFL, fcntl( client->fd, F_GETFL ) & ~O_NONBLOCK );
	//printf(":::client %d\n\n\n", fcntl( client->fd, F_GETFL, 0));
	//printf(":::client %d\n\n\n", fcntl( client->fd, F_SETFL, fcntl( client->fd, F_GETFL ) & ~O_NONBLOCK ));
	/*---------------------------------------------------*/

	int jabber_fd		= (int)NULL,
		jabber_port		= (int)NULL,
		jabber_error	= (int)NULL;

	struct sockaddr_in jabber_addr;

	jabber_port = __DEFAULT_JABBER_PORT__;
	//jabber_port = strtol(__DEFAULT_JABBER_PORT__, 0, 10);
	jabber_fd = socket(AF_INET, SOCK_STREAM, 0);
	fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | O_NDELAY);

	jabber_addr.sin_family = AF_INET;
	inet_aton(__DEFAULT_JABBER_IP__, &jabber_addr.sin_addr);
	jabber_addr.sin_port = htons(jabber_port);

	jabber_error = connect(jabber_fd, (struct sockaddr *) &(jabber_addr), sizeof(jabber_addr));

	last = time(NULL);
	//while ( (time(NULL) - last) < 60 )
	//{
		/* read from client */
	//	read(client->fd, pBuffer, __BUFFER_SIZE__);
	//	printf("\n\n--------\n\nread from client:\n%s\n\n------------\n\n", pBuffer);
		/* write in the jabber service */
	//	write(jabber_fd, pBuffer, strlen(pBuffer));
	//	sleep(1);
		/* read from jabber service */
	//	read(jabber_fd, pBuffer, __BUFFER_SIZE__);
	//	printf("\n\n--------\n\nread from jabber:\n%s\n\n------------\n\n", pBuffer);
		/* write in the client */
	//	write(client->fd, pBuffer, strlen(pBuffer));
	//}

	int optval = 1;
	socklen_t optlen = sizeof(optval);
	if ( setsockopt(client->fd, SOL_SOCKET, SO_KEEPALIVE, &(optval), optlen ) )
	{
		puts("asdgsdfgsdfg");
		exit(1);
	}

	int retval, ttlval, rbuf, len;
	while ( (time(NULL) - last) < 20 )
	{
		printf("\n\n#################\n%d\n", getsockopt(client->fd, SOL_SOCKET, SO_KEEPALIVE, &optval, NULL));
		printf("%d\n#######################\n\n", optval );
		bzero(pBuffer, __BUFFER_SIZE__);
		/* read from client */
		printf("\n\n--------\nread from client...\n");
		printf("error: %d\n", read(client->fd, pBuffer, __BUFFER_SIZE__));
		printf("read from client:\n%s\n\n------------\n\n", pBuffer);

		/* write in the jabber service */
		printf("write in the jabber...\n");
		//write(jabber_fd, pBuffer, strlen(pBuffer));
		printf("send to jabber %d", sendto(jabber_fd, pBuffer, strlen(pBuffer), MSG_CONFIRM, 0,0));

		//while ( (time(NULL) - last) < 5 );

		bzero(pBuffer, __BUFFER_SIZE__);
		/* read from jabber service */
		printf("\n\n--------\nread from jabber...\n");
		printf("error: %d\n", read(jabber_fd, pBuffer, __BUFFER_SIZE__));
		printf("read from jabber:\n%s\n\n------------\n\n", pBuffer);

		/* write in the client */
		printf("write in the client...\n");
		write(client->fd, pBuffer, strlen(pBuffer));

		//printf("buffer limpo: %s\n\n----------------\n\n", pBuffer);
		sleep(1);
	}

    if ( close(jabber_fd) == __SOCKET_ERROR__ )
    {
        printf("\nCould not close jabber socket\n");
        return 0;
    }
	/*---------------------------------------------------*/
    if ( close(client->fd) == __SOCKET_ERROR__ )
    {
        printf("\nCould not close socket\n");
        return 0;
    }

    fflush(stdin);
    fflush(stdout);
	free(client);
    pthread_exit(NULL);
}