/* server.c */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <unistd.h>
#include <time.h>
#include <arpa/inet.h>
#include <limits.h>

#include "../debug/debug.h"
#include "../cmdline/server_cmdline.h"
#include "common.h"

int setup_TCP_server(int porto, int backlog);
void handle_requests(int tcp_server_socket);
void process_cmd(uint8_t option, char *buffer, int buffer_len);

int main(int argc, char *argv[]) {
	struct gengetopt_args_info args;

	if( cmdline_parser(argc, argv, &args) )
		ERROR(99, "Erro: execução de cmdline_parser\n");

	/* criar socket - servidor */
	int max_connections = 1;
	int tcp_server_socket = setup_TCP_server(args.porto_arg, max_connections);

	handle_requests(tcp_server_socket);

	/* close - socket servidor */
	close(tcp_server_socket);

	cmdline_parser_free(&args);

	exit(0);
}

void handle_requests(int tcp_server_socket){
	char tcp_client_string_ip[20];
	struct sockaddr_in tcp_client_endpoint;
	int tcp_client_socket;
	ssize_t recv_bytes, send_bytes;
	uint8_t option;
	char buffer[MAX_STR];

	while(1){
		memset(&tcp_client_endpoint, 0, sizeof(struct sockaddr_in));
		socklen_t tcp_client_endpoint_length = sizeof(struct sockaddr_in);

		/* accept */
		printf("à espera da ligação do cliente... "); fflush(stdout);
		if ((tcp_client_socket = accept(tcp_server_socket, (struct sockaddr *) &tcp_client_endpoint, &tcp_client_endpoint_length)) == -1)
			ERROR(54, "Can't accept client");
		printf("ok. \n");
		printf("cliente: %s@%d\n", inet_ntop(AF_INET, &tcp_client_endpoint.sin_addr, tcp_client_string_ip, sizeof(tcp_client_string_ip)), htons(tcp_client_endpoint.sin_port));

		/* comunicacao com o cliente */
		if((recv_bytes = recv(tcp_client_socket, &option, sizeof(option), 0)) == -1){
			close(tcp_client_socket);
			ERROR(43, "Erro no recv()\n");
		}
		printf("ok. (%d bytes recebidos)\n", recv_bytes);

		sleep(3);

		//processar a data
		process_cmd(option, buffer, MAX_STR);

		/* devolver resposta para cliente - send */
		if((send_bytes = send(tcp_client_socket, buffer, strlen(buffer), 0)) == -1 ){
			close(tcp_client_socket);
			ERROR(43, "Erro no send()\n");
		}
		printf("ok. (%d bytes enviados)\n", send_bytes);

		/* close - socket cliente */
		close(tcp_client_socket);
	}
}

void process_cmd(uint8_t option, char *buffer, int buffer_len){
	time_t t = time(NULL);
	struct tm *localtime_ptr;
	localtime_ptr = localtime(&t);

	if(localtime_ptr == NULL){
		WARNING("Error on localtime()\n");
		return;
	}

	switch(option){
		case 0: //data+hora
			strftime(buffer, buffer_len, "%Y%m%d_%Hh%M:%S", localtime_ptr);
			break;
		case 1: //data
			strftime(buffer, buffer_len, "%Y%m%d", localtime_ptr);
			break;
		case 2: //hora
			strftime(buffer, buffer_len, "%Hh%M:%S", localtime_ptr);
			break;
		default: //devolve msg de erro
			snprintf(buffer, buffer_len, "Unknown cmd '%d'", option);
	}
}

int setup_TCP_server(int porto, int backlog){
	int tcp_server_socket;

	if(porto < 1 || porto > USHRT_MAX){
		ERROR(99, "Porto não está numa gama válida");
	}

	if ((tcp_server_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
		ERROR(51, "Can't create tcp_server_socket (IPv4)");

	/* registar socket - servidor */
	struct sockaddr_in tcp_server_endpoint;
	memset(&tcp_server_endpoint, 0, sizeof(struct sockaddr_in));
	tcp_server_endpoint.sin_family = AF_INET;
	tcp_server_endpoint.sin_addr.s_addr = htonl(INADDR_ANY); 		// Todas as interfaces de rede
	tcp_server_endpoint.sin_port = htons(porto);		// Server port

	if (bind(tcp_server_socket, (struct sockaddr *) &tcp_server_endpoint, sizeof(struct sockaddr_in)) == -1)
		ERROR(52, "Can't bind @tcp_server_endpoint");

	/* listen */
    if (listen(tcp_server_socket, backlog)  == -1)
		ERROR(53, "Can't listen for %d clients", backlog);

	return tcp_server_socket;
}

/* client.c */
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/socket.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <string.h>
#include <sys/wait.h>
#include <limits.h>

#include "../debug/debug.h"
#include "../cmdline/client_cmdline.h"
#include "common.h"

#define FILHOS	5

void executa_pedido(struct gengetopt_args_info args);

int main(int argc, char *argv[])
{
	struct gengetopt_args_info args;

	// cmdline_parser: deve ser a primeira linha de código no main
	if( cmdline_parser(argc, argv, &args) )
		ERROR(99, "Erro: execução de cmdline_parser\n");

	pid_t pid;
	int i;

	for(i=0; i<FILHOS; i++){
		pid = fork();
		if(pid == 0){//proc. filho
			printf("Processo filho '%d'\n", i+1);
			executa_pedido(args);
			exit(0);
		}else if(pid > 0){//proc. pai

		}else{
			ERROR(99, "Erro no fork()\n");
		}
	}

	for(i=0; i<FILHOS; i++){
		wait(NULL);
	}

	// libertar recurso (cmdline_parser)
	cmdline_parser_free(&args);

	exit(0);
}

void executa_pedido(struct gengetopt_args_info args){
	/* socket */
	if(args.porto_arg < 1 || args.porto_arg > USHRT_MAX){
		ERROR(99, "Porto não está numa gama válida");
	}

	int tcp_client_socket;
	if ((tcp_client_socket = socket(AF_INET, SOCK_STREAM, 0)) == -1)
		ERROR(41, "Can't create tcp_client_socket (IPv4)");

	/* connect */
	struct sockaddr_in tcp_server_endpoint;
	memset(&tcp_server_endpoint, 0, sizeof(struct sockaddr_in));
	tcp_server_endpoint.sin_family = AF_INET;

	/* converter ip de formato string para binário (rede) */
	switch (inet_pton(AF_INET, args.ip_arg, &tcp_server_endpoint.sin_addr)) {
		case 0:
			fprintf(stderr, "[%s@%d] ERROR - Cannot convert IP address (IPv4): Invalid Network Address\n", __FILE__, __LINE__);
			exit(22);
		case -1:
			ERROR(22, "Cannot convert IP address (IPv4)");
	}
	tcp_server_endpoint.sin_port = htons(args.porto_arg);

	printf("a ligar ao servidor... "); fflush(stdout);
	if (connect(tcp_client_socket, (struct sockaddr *) &tcp_server_endpoint, sizeof(struct sockaddr_in)) == -1)
		ERROR(43, "Can't connect @tcp_server_endpoint");
	printf("ok. \n");

	/* enviar string ao servidor */
	ssize_t send_bytes, recv_bytes;
	uint8_t option = 0;
	char response[MAX_STR];

	if((send_bytes = send(tcp_client_socket, &option, sizeof(option), 0)) == -1 ){
		close(tcp_client_socket);
		ERROR(43, "Erro no send()\n");
	}
	printf("ok. (%d bytes enviados)\n", send_bytes);

	/* aguardar resposta do servidor */
	if((recv_bytes = recv(tcp_client_socket, response, MAX_STR, 0)) == -1){
		close(tcp_client_socket);
		ERROR(43, "Erro no recv()\n");
	}
	printf("ok. (%d bytes recebidos)\n", recv_bytes);

	response[recv_bytes] = '\0';

	/* mostrar resposta do servidor */
	printf("Valor recebido do servidor: %s\n", response);

	/* close */
	if (close(tcp_client_socket) == -1)
		ERROR(45, "Can't close tcp_client_socket (IPv4)");
	printf("ligação fechada. ok. \n");
}