#include  <stdio.h>
#include  <unistd.h>
#include  <sys/socket.h>
#include  <netdb.h>
#include  <string.h>
#include  <stdlib.h>
#include  <stdbool.h>


#define SERVADDR "localhost"        // Définition de l'adresse IP d'écoute
#define SERVPORT "0"                // Définition du port d'écoute,
                                    // si 0 port choisi dynamiquement
#define LISTENLEN 1                 // Taille du tampon de demande de connexion
#define MAXBUFFERLEN 1024
#define MAXHOSTLEN 64
#define MAXPORTLEN 6

void lancerSocketClient();
void lancerSocketServeur();

int socketClient;               // Descripteur de la socketClient
int socketServeur;              // Descripteur de socket de communication
int ecodeClient;                // Retour des fonctions coté client
int ecodeServeur;               // Code retour des fonctions coté serveur

int main(int argc, char* argv[]){

	char bufferProxyClientServeur[MAXBUFFERLEN];
				// Buffer stockant les messages entre
                                // le clientProxy et le serveur

	char bufferProxyServeurClient[MAXBUFFERLEN];
				// Tampon de communication entre le client et le serveurProxy

	char bufferProxy[MAXBUFFERLEN];
				// Tampon de communication entre cliet et serveur proxy

	// Lancement des deux socket
	lancerSocketServeur();
	lancerSocketClient();


	// Login
	// Echange de données entre serveurProxy le client connecté
	strcpy(bufferProxyServeurClient, "220 Connexion au serveur\n");
	write(socketServeur, bufferProxyServeurClient, strlen(bufferProxyServeurClient));

	// Echange de données entre serveurProxy et clientProxy
	read(socketServeur, bufferProxy, strlen(bufferProxy));
	write(socketClient,socketServeur,strlen(bufferProxy));
	//Echange de données entre le clientProxy et le serveur
	read(socketClient, bufferProxyClientServeur, MAXBUFFERLEN);

	ecodeServeur = read(socketClient, bufferProxyClientServeur, MAXBUFFERLEN);
	if (ecodeServeur == -1) {perror("Problème de lecture\n"); exit(3);}
	bufferProxyClientServeur[ecodeServeur] = '\0';
	printf("MESSAGE RECU DU SERVEUR: \"%s\".\n",bufferProxyClientServeur);




	//Fermeture des sockets
	close(socketServeur);
	close(socketClient);
}

void lancerSocketClient(){


	struct addrinfo *res,*resPtr;  // Résultat de la fonction getaddrinfo
	struct addrinfo hints;
	char serverName[MAXHOSTLEN];   // Nom de la machine serveur
	char serverPort[MAXPORTLEN];   // Numéro de port

	bool isConnected = false;      // booléen indiquant que l'on est bien connecté

    //On teste les valeurs rentrées par l'utilisateur
	/*
    if (argc != 3){ perror("Mauvaise utilisation de la commande: <nom serveur> <numero de port>\n"); exit(1);}
    if (strlen(argv[1]) >= MAXHOSTLEN){ perror("Le nom de la machine serveur est trop long\n"); exit(2);}
    if (strlen(argv[2]) >= MAXPORTLEN){ perror("Le numero de port du serveur est trop long\n"); exit(2);}
	*/
    strncpy(serverName, "r-info-onyx", MAXHOSTLEN);
    serverName[MAXHOSTLEN-1] = '\0';
    strncpy(serverPort, "21", MAXPORTLEN);
    serverPort[MAXPORTLEN-1] = '\0';



    // Initailisation de hints
	memset(&hints, 0, sizeof(hints));
	hints.ai_socktype = SOCK_STREAM;  // TCP
	hints.ai_family = AF_UNSPEC;      // les adresses IPv4 et IPv6 seront présentées par
				                          // la fonction getaddrinfo

	//Récupération des informations sur le serveur
	ecodeClient = getaddrinfo(serverName,serverPort,&hints,&res);
	if (ecodeClient){
		fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecodeClient));
		exit(1);
	}

	resPtr = res;

	while(!isConnected && resPtr!=NULL){

		//Création de la socket IPv4/TCP
		socketClient = socket(resPtr->ai_family, resPtr->ai_socktype, resPtr->ai_protocol);
		if (socketClient == -1) {
			perror("Erreur creation socket");
			exit(2);
		}

  		//Connexion au serveur
		ecodeClient = connect(socketClient, resPtr->ai_addr, resPtr->ai_addrlen);
		if (ecodeClient == -1) {
			resPtr = resPtr->ai_next;
			close(socketClient);
		}
		// On a pu se connecté
		else isConnected = true;
	}
	freeaddrinfo(res);
	if (!isConnected){
		perror("Connexion impossible");
		exit(2);
	}

}

void lancerSocketServeur(){

	char serverAddr[MAXHOSTLEN];     // Adresse du serveur
	char serverPort[MAXPORTLEN];     // Port du server
	int descSockRDV;                 // Descripteur de socket de rendez-vous
	struct addrinfo hints;           // Contrôle la fonction getaddrinfo
	struct addrinfo *res;            // Contient le résultat de la fonction getaddrinfo
	struct sockaddr_storage myinfo;  // Informations sur la connexion de RDV
	struct sockaddr_storage from;    // Informations sur le client connecté
	socklen_t len;                   // Variable utilisée pour stocker les
				         // longueurs des structures de socket


	// Publication de la socket au niveau du système
	// Assignation d'une adresse IP et un numéro de port
	// Mise à zéro de hints
	memset(&hints, 0, sizeof(hints));
	// Initailisation de hints
	hints.ai_flags = AI_PASSIVE;      // mode serveur, nous allons utiliser la fonction bind
	hints.ai_socktype = SOCK_STREAM;  // TCP
	hints.ai_family = AF_UNSPEC;      // les adresses IPv4 et IPv6 seront présentées par
				                         // la fonction getaddrinfo

	// Récupération des informations du serveur
	ecodeServeur = getaddrinfo(SERVADDR, SERVPORT, &hints, &res);
	if (ecodeServeur) {
		fprintf(stderr,"getaddrinfo: %s\n", gai_strerror(ecodeServeur));
		exit(1);
	}

	//Création de la socket IPv4/TCP
	descSockRDV = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
	if (descSockRDV == -1) {
		perror("Erreur creation socket");
		exit(4);
	}

	// Publication de la socket
	ecodeServeur = bind(descSockRDV, res->ai_addr, res->ai_addrlen);
	if (ecodeServeur == -1) {
		perror("Erreur liaison de la socket de RDV");
		exit(3);
	}
	// Nous n'avons plus besoin de cette liste chainée addrinfo
	freeaddrinfo(res);
	// Récuppération du nom de la machine et du numéro de port pour affichage à l'écran

	len=sizeof(struct sockaddr_storage);
	ecodeServeur=getsockname(descSockRDV, (struct sockaddr *) &myinfo, &len);
	if (ecodeServeur == -1)
	{
		perror("SERVEUR: getsockname");
		exit(4);
	}
	ecodeServeur = getnameinfo((struct sockaddr*)&myinfo, sizeof(myinfo), serverAddr,MAXHOSTLEN,
                         serverPort, MAXPORTLEN, NI_NUMERICHOST | NI_NUMERICSERV);
	if (ecodeServeur != 0) {
		fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(ecodeServeur));
		exit(4);
	}
	printf("L'adresse d'ecoute est: %s\n", serverAddr);
	printf("Le port d'ecoute est: %s\n", serverPort);
	// Definition de la taille du tampon contenant les demandes de connexion
	ecodeServeur = listen(descSockRDV, LISTENLEN);
	if (ecodeServeur == -1) {
		perror("Erreur initialisation buffer d'écoute");
		exit(5);
	}

	len = sizeof(struct sockaddr_storage);
	// Attente connexion du client
	// Lorsque demande de connexion, creation d'une socket de communication avec le client
	socketServeur = accept(descSockRDV, (struct sockaddr *) &from, &len);
	if (socketServeur == -1){
		perror("Erreur accept\n");
		exit(6);
	}

	//Fermeture de la connexion
	close(descSockRDV);
}