#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <errno.h>
#include <error.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <signal.h>

const int PORT_SERVER = 6440; 			/* portul folosit */
const int CLIENTI_MAXIM = 3;			/* nr maxim de clienti acceptati */

extern int errno; 						/* eroare returnata */
int nr = 0;								/* numar de clienti */
int port;								/* portul*/
struct operation request;			   	/* cererea primita de server */
int sockfd, newsockfd, frlen, servlen;

struct operation
{
    int number1;
    int number2;
    int number3;
    int number4;
    int number5;
};

/*functie de tratare a semnalelor*/
void semnal (int nr_semnal) 
{
	if (nr_semnal == SIGCHLD)
	{
		wait(NULL);
		nr--; /*s-a pierdut un client*/
		return;
	}
}

/*operatiile pentru fiecare client*/
void doprocessing(int sock)
{
	printf("Esti clientul cu numarul: %d !\n", nr+1); 
	 
	/* am realizat conexiunea, asteptam mesajul... */
	bzero (&request, sizeof(struct operation));
	printf ("Asteptam cererea...\n");
	fflush (stdout);
      
	/* citirea mesajului */
	int nrbytes = recv (newsockfd, &request, sizeof(struct operation), 0);
	
	/*incercam sa citim datele de la client*/
	if (nrbytes <= 0)
    {
		perror ("Eroare la read() de la client.\n");
		close (newsockfd);    /* inchidem conexiunea cu clientul */
	}
	
	/*verificam integritatea datelor*/
	if (nrbytes < sizeof(struct operation))
    {
		perror ("Date primite incomplet");
		close (newsockfd);
    }
	
	request.number1 = ntohl(request.number1);
    request.number2 = ntohl(request.number2);
    request.number3 = ntohl(request.number3);
    request.number4 = ntohl(request.number4);
	request.number5 = ntohl(request.number5);

	printf ("Cerere primita... \n In curs de rezolvare: %d %d %d %d %d \n", 
											request.number1, request.number2, request.number3, request.number4, request.number5);
      
      
	/* rezolvarea cererii */

	int magic;
	int a=0;
	int b=0;
	int c=0;
	int d=0;
	int e=0;
	int min=0;
	int result;

	/* generarea numarului magic de la 1 la 1000*/
	magic = rand() % 1001; 

	/* diferenta dintre numarul magic si numerele primite */
	if (magic >= request.number1)
		a = magic - request.number1;
	else
		a = request.number1 - magic;

	if (magic >= request.number2)
		b = magic - request.number2;
	else
		b = request.number2 - magic;

	if (magic >= request.number3)
		c = magic - request.number3;
	else
		c = request.number3 - magic;

	if (magic >= request.number4)
		d = magic - request.number4;
	else
		d = request.number4 - magic;

	if (magic >= request.number5)
		e = magic - request.number5;
	else
		e = request.number5 - magic;

	printf("\nnumar magic: %d\n", magic);
	printf("numerele sunt: %d %d %d %d %d\n", a, b, c, d, e);
	
	/* verificare care numar este mai aproape de numarul magic */
	if (a > b)
		min = b;
	else 
		min = a;

	if (min > c)
		min = c;

	if (min > d)
		min = d;

	if (min > e)
	{
		min = e;
		//result = min;
	}
	printf("diferenta minima este: %d", min);
	
	/*selectam numarul care este mai apropiat de numarul magic*/
	if (min == a)
		result = request.number1;
	if (min == b)
		result = request.number2;
	if (min == c)
		result = request.number3;
	if (min == d)
		result = request.number4;
	else
		result = request.number5;
		
    result = htonl(result);
	/* returnam rapunsul clientului */
    if (send (newsockfd, &result, sizeof(int),0) <= 0)
    {
		perror ("Eroare la write() catre client.\n");
    }
    else
		printf ("\nTrasmitere cu succes.\n");
      /* am terminat cu acest client, inchidem conexiunea */
      close (newsockfd);
}

/*programul principal*/
int main (int argc, char * argv[])
{
	struct sockaddr_in server , from;    	/* structurile folosite de server si client */
	int port;								/* portul */
	pid_t pid;								/* Process ID from fork() */

	
	/* setare port in cazul specificarii explicite */
	if (argc > 1)
	{
		port = atoi(argv[1]);
	}
	else
		port = PORT_SERVER;
	
	/*tratarea semnalele*/
	if (signal (SIGCHLD, semnal) == SIG_ERR)
	{
		perror("signal()");
		exit(errno);
	}
	
	/* cream un socket */
	sockfd = socket(AF_INET, SOCK_STREAM,0);
	if (sockfd <0)
	{
		perror("Eroare la socket().");
		exit(1);
	}
	
	frlen = sizeof (from);
	servlen = sizeof (server);
	
	/* pregatim structurile de date */
	bzero (&server, servlen);
	bzero (&from, frlen);
  
	/* umplem structura folosita de server */
	server.sin_family = AF_INET;    					/* stabilirea familiei de socket-uri */
	server.sin_addr.s_addr = htonl (INADDR_ANY);		/* acceptam orice adresa */
	server.sin_port = htons (port);						/* utilizam un port utilizator */
	
	/* atasam socketul */
	if (bind (sockfd, (struct sockaddr *) &server, servlen) == -1)
    {
		perror ("Eroare la bind().\n");
		exit(1);
    }
	
	/* punem serverul sa asculte daca vin clienti sa se conecteze */
	if (listen (sockfd, 3) == -1)
    {
		perror ("Eroare la listen().\n");
		exit(1);
    }
	
	/*servim in mod concurent clientii*/
	while (1) 
    {
		printf ("Asteptam la portul %d...\n", port);
		fflush (stdout);
	
        newsockfd = accept(sockfd, (struct sockaddr *) &from, &frlen);
        if (newsockfd < 0)
        {
            perror("Eroare la accept().\n");
            exit(1);
        }
		
		/* Verificam daca am ajuns la numarul maxim de clienti */
		if (nr == CLIENTI_MAXIM)
		{
			perror("Numar maxim de clienti atins. Incercati mai tarziu.\n");
			shutdown(newsockfd,2);
			continue;
		}
		
        /* Cream procesul copil*/
        pid = fork();
        if (pid < 0)
        {
            perror("Eroare la fork().\n");
	    exit(1);
        }
        if (pid == 0)  
        {
            /* Procesul parcurs de client */
            close(sockfd);
            doprocessing(newsockfd);
            exit(0);
        }
        else
        {
            close(newsockfd);
        }
		nr++;
    }
}