#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,
		optval	= 1;

	socklen_t optlen = sizeof(optval);

	/* 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);
	}

	/* 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);

    char buffer_client[__BUFFER_SIZE__],
		 buffer_jabber[__BUFFER_SIZE__];
    struct client * client = current;//(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);
	/*---------------------------------------------------*/

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

	struct sockaddr_in jabber_addr;

	jabber_port = __DEFAULT_JABBER_PORT__;
	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_addr.s_addr = inet_addr(__DEFAULT_JABBER_IP__);
	jabber_addr.sin_port = htons(jabber_port);

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

	last = time(NULL);
	int client_is_connected = -1;
	int jabber_is_connected = -1;
	int sockaddr_in_size    = sizeof(struct sockaddr_in);
	while ( client_is_connected != 0 )
	{
		/* read from client */
		puts("\tread - client");
		bzero(buffer_client, __BUFFER_SIZE__);
		if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 && strlen(buffer_jabber) > 0 )
		{
			puts("\twrite - client");
			printf("\t%s\n", buffer_jabber);
			/* write in the client */
			write(client->fd, buffer_jabber, strlen(buffer_jabber));
		}

		/* read from jabber service */
		puts("\tread - jabber");
		bzero(buffer_jabber, __BUFFER_SIZE__);
		if ( (jabber_is_connected = read(jabber_fd, buffer_jabber, __BUFFER_SIZE__))  && strlen(buffer_client) > 0 )
		{
				puts("\twrite - jabber");
				printf("\t%s\n", buffer_client);
				/* write in the jabber service */
				if ( !strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
					write(jabber_fd, buffer_client, strlen(buffer_client));
		}
		if ( strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
		{
			fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | ~O_NDELAY);
			//starttls(&jabber_fd, &client->fd);
			int err;

			SSL_CTX * ctx;
			SSL * jabberssl;

			//OpenSSL_add_all_algorithms();

			SSL_library_init();
			SSL_load_error_strings();

			if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
			{
				printf("Error creating the context.\n");
				exit(0);
			}

			SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);

			jabberssl = SSL_new(ctx);

			puts("#1");
			err=SSL_set_fd(jabberssl, jabber_fd);
			if ( err < 1 )
			{
				puts("shsfghdfgh");
				SSL_CTX_free(ctx);
			}

			puts("connect");
			err = SSL_connect(jabberssl);
			if ( err < 1 )
			{
				puts("client");
				err = SSL_get_error(jabberssl, err);
				printf("%d\n", err);
				char err_str[1024];
				ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
				printf("%s\n", err_str);
				SSL_CTX_free(ctx);
			}
		}

		if ( jabber_is_connected == 0 )
			client_is_connected = jabber_is_connected;

		puts("end loop");
		usleep(500000);
	}

    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_create(&(threads), NULL, handler, (void *) current);
		}
	}
	pthread_exit(NULL);
}

void * handler(void * pClient)
{
    char buffer_client[__BUFFER_SIZE__],
		 buffer_jabber[__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);
	/*---------------------------------------------------*/

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

	struct sockaddr_in jabber_addr;

	jabber_port = __DEFAULT_JABBER_PORT__;
	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_addr.s_addr = inet_addr(__DEFAULT_JABBER_IP__);
	jabber_addr.sin_port = htons(jabber_port);

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

	last = time(NULL);
	int client_is_connected = -1;
	int jabber_is_connected = -1;
	int sockaddr_in_size    = sizeof(struct sockaddr_in);
	while ( client_is_connected != 0 )
	{
		/* read from client */
		puts("\tread - client");
		bzero(buffer_client, __BUFFER_SIZE__);
		if ( (client_is_connected = read(client->fd, buffer_client, __BUFFER_SIZE__)) != 0 && strlen(buffer_jabber) > 0 )
		{
			puts("\twrite - client");
			printf("\t%s\n", buffer_jabber);
			/* write in the client */
			write(client->fd, buffer_jabber, strlen(buffer_jabber));
		}

		/* read from jabber service */
		puts("\tread - jabber");
		bzero(buffer_jabber, __BUFFER_SIZE__);
		if ( (jabber_is_connected = read(jabber_fd, buffer_jabber, __BUFFER_SIZE__))  && strlen(buffer_client) > 0 )
		{
				puts("\twrite - jabber");
				printf("\t%s\n", buffer_client);
				/* write in the jabber service */
				if ( !strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
					write(jabber_fd, buffer_client, strlen(buffer_client));
		}
		if ( strstr(buffer_jabber, "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>") )
		{
			fcntl(jabber_fd, F_SETFL, fcntl(jabber_fd, F_GETFL, 0) | ~O_NDELAY);
			//starttls(&jabber_fd, &client->fd);
			int err;

			SSL_CTX * ctx;
			SSL * jabberssl;

			//OpenSSL_add_all_algorithms();

			SSL_library_init();
			SSL_load_error_strings();

			if ( !(ctx = SSL_CTX_new(TLSv1_server_method())) )
			{
				printf("Error creating the context.\n");
				exit(0);
			}

			SSL_CTX_set_verify(ctx,SSL_VERIFY_NONE,NULL);

			jabberssl = SSL_new(ctx);

			puts("#1");
			err=SSL_set_fd(jabberssl, jabber_fd);
			if ( err < 1 )
			{
				puts("shsfghdfgh");
				SSL_CTX_free(ctx);
			}

			puts("connect");
			err = SSL_connect(jabberssl);
			if ( err < 1 )
			{
				puts("client");
				err = SSL_get_error(jabberssl, err);
				printf("%d\n", err);
				char err_str[1024];
				ERR_error_string_n(ERR_get_error(), err_str, sizeof(err_str));
				printf("%s\n", err_str);
				SSL_CTX_free(ctx);
			}
		}

		if ( jabber_is_connected == 0 )
			client_is_connected = jabber_is_connected;

		puts("end loop");
		usleep(500000);
	}

    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);
}