#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

// Fonction pour la création d'un socket serveur
int creer_socket_serveur(int port) {
    int socket_serveur;
    int optval = 1;
    struct sockaddr_in adresse_locale;
    char adresse_ip[INET_ADDRSTRLEN];

    // Création de la socket
    socket_serveur = socket(AF_INET, SOCK_STREAM, 0);
    if (socket_serveur == -1) {
        perror("socket serveur");
        exit(-1);
    }

    // On rend le port réutilisable rapidement après un arrêt brutal
    if (setsockopt(socket_serveur, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int)) == -1) {
        perror("setsockopt");
        exit(-1);
    }

    // Configuration de la socket
    adresse_locale.sin_family = AF_INET;
    adresse_locale.sin_port = htons(port);
    adresse_locale.sin_addr.s_addr = INADDR_ANY;
    if (bind(socket_serveur, (struct sockaddr*)&adresse_locale, sizeof(adresse_locale)) == -1) {
        perror("bind serveur");
        exit(-1);
    }

    // Afficher l'adresse IP d'écoute choisie par défaut
	if (inet_ntop(AF_INET, &adresse_locale.sin_addr, adresse_ip, INET_ADDRSTRLEN) == NULL) {
    	perror("inet_ntop");
    	exit(-1);
	}
	printf("Adresse IP d'écoute : %s\n", adresse_ip);

	// Afficher le port d'écoute choisi par défaut
	port = ntohs(adresse_locale.sin_port);
	printf("Port d'écoute : %d\n", port);

	// Démarrage du listage
	if (listen(socket_serveur, 10) == -1) {
    	perror("listen serveur");
    	exit(-1);
	}

	return socket_serveur;
}



int main(int argc, char* argv[]) {
    int socket_serveur;
    int socket_client;
    int port;
    socklen_t longueur_adresse_courante;
    struct sockaddr_in adresse_client_courant;
    char buffer[32];

    // Vérifier le nombre d'arguments
    if (argc != 2) {
        printf("Usage: %s port\n", argv[0]);
        exit(-1);
    }

    // Récupérer le numéro de port
    port = atoi(argv[1]);

    // Créer la socket serveur
    socket_serveur = creer_socket_serveur(port);

    // Afficher un message indiquant que le serveur est en écoute
    printf("Le serveur est en écoute sur le port %d...\n", port);

    // BOUCLE PRINCIPALE
	while (1) {
    // Attendre une connexion client
    longueur_adresse_courante = sizeof(adresse_client_courant);
    socket_client = accept(socket_serveur, (struct sockaddr*)&adresse_client_courant, &longueur_adresse_courante);
    if (socket_client == -1) {
        perror("accept");
        exit(-1);
    }

    // Afficher un message indiquant qu'un client s'est connecté
    printf("Un client s'est connecté...\n");

    // BOUCLE DE TRAITEMENT
    while (1) {
        // Lire la demande du client
        if (read(socket_client, buffer, sizeof(buffer)) == -1) {
            perror("read");
            exit(-1);
        }

        // Vérifier si c'est une demande d'état
		if (strcmp(buffer, "ETAT") == 0) {
		// Répondre en envoyant le PID du serveur
		sprintf(buffer, "%d", getpid());
		write(socket_client, buffer, strlen(buffer) + 1);
		} else {
		// Sinon, ignorer la demande
		}	

		// Fermer la socket client
		close(socket_client);

		// Afficher un message indiquant que la connexion avec le client est fermée
		printf("Connexion avec le client fermée.\n");
		}
	}
		
	// Fermer la socket serveur
	close(socket_serveur);

	return 0;
}