#include "central-manager.h"

/*
*
* @argv : {0:program name}
*
* @history
*   [1] Lancement des THREADS d'écoute
*       1. On démarre le SERVEUR TCP d'écoute globale
*       2. On démarre le SERVEUR UDP d'écoute globale
*   [2] On attends la fin de tous les THREADS
*   [3] On ferme la SOCKET d'écoute globale
*
*/
int main(int argc, char* argv[]){


	/* [1] Lancement des THREADS d'écoute
	=========================================================*/
	/* (1) Ecoute TCP */
	pthread_create(&listenManagers[0], NULL, LISTEN_TCP, NULL);
	if( DEBUGMOD&THR ) printf("LISTEN THREAD[TCP] démarré\n");

	/* (2) Ecoute UDP */
	pthread_create(&listenManagers[1], NULL, LISTEN_UDP, NULL);
	if( DEBUGMOD&THR ) printf("LISTEN THREAD[UDP] démarré\n");


	/* [2] On attends la fin de tous les THREADS
	==========================================================*/
	pthread_join(listenManagers[0], NULL);
	pthread_join(listenManagers[1], NULL);

	/* [3] On ferme la SOCKET d'écoute globale
	==========================================================*/
	printf("FERMETURE DE TOUTES LES CONNECTIONS!\n");
}






/* Attente de connection TCP
*
* @history
*   [0] Initialisation des variables
*   [1] On démarre le SERVEUR TCP d'écoute globale
*   [2] Attente d'une demande de connection TCP -> création d'un THREAD
*   [3] On attends la fin de tous les THREADS
*   [4] On ferme la SOCKET d'écoute TCP globale
*
*/
void* LISTEN_TCP(){
	/* [0] Initialisation des variables
	==========================================================*/
	int                CLIENT_SOCKET;                         // contiendra la socket TCP à envoyer sur un THREAD
	struct sockaddr_in clientInfo;                            // contiendra les infos client
	socklen_t          len;                                   // taille de la socket
	int                index, i;                              // compteurs

	// retour de @DROP_TCP_SERVER
	int LISTENSOCK;   // contiendra la socket d'écoute TCP


	/* [1] On démarre le SERVEUR TCP d'écoute globale
	==========================================================*/
	if( DROP_TCP_SERVER(TCP_PORT, &LISTENSOCK) < 0 ){

		if( DEBUGMOD&SCK ) printf("\tErreur de mise en place de la socket d'écoute TCP\n");

		// On ferme la SOCKET d'écoute globale
		printf("\tFERMETURE DE L'ECOUTE TCP!\n");
		close(LISTENSOCK);

		return NULL;
	}


	printf("\tTCP Listen Port: %d\n", TCP_PORT);



	/* [2] Attente d'une demande de connection, pour création d'un THREAD
	============================================================================*/
	while( 1 ){

		/* 1. On initialise les SOCKET en attendant la connexion et le rang du "manager" inactif */
		CLIENT_SOCKET = -1;
		index         = -1;

		/* 2. On attends une connection TCP */
		CLIENT_SOCKET = accept(LISTENSOCK, (struct sockaddr*) &clientInfo, &len);

		/* 3. Si erreur, on attend une nouvelle connection */
		if( CLIENT_SOCKET < 0 ){
			if( DEBUGMOD&SCK ) printf("\tErreur connection TCP\n");
			break;
		}

		/* 4. On cherche un "manager" libre (inactif) */
		for( i = 0 ; i < MAX_TCP_THR ; i++ )
			if( activeTCPManagers[i] == 0 ){ index = i; break; }

		// si on a trouvé un "manager" libre
		if( index != -1 ){

			/* 5. On lance un thread pour le traitement de ce client */
			pthread_create(&TCPManagers[index], NULL, managePlane, (void*)(intptr_t) CLIENT_SOCKET);

			if( DEBUGMOD&THR ) printf("\tTHREAD[TCP][%d] démarré\n", index);

			/* 6. On signale que ce "manager" est maintenant actif */
			activeTCPManagers[index] = 1;

		}else
			if( DEBUGMOD&THR ) printf("\tAucun thread TCP libre!\n");

	}


	/* [3] On attends la fin de tous les THREADS
	==========================================================*/
	for( i = 0 ; i < MAX_TCP_THR ; i++ )
		pthread_join(TCPManagers[i], NULL);

	/* [4] On ferme la SOCKET d'écoute globale
	==========================================================*/
	printf("FERMETURE DE L'ECOUTE TCP!\n");
	close(LISTENSOCK);

	return NULL;
}







/* Attente de connection UDP
*
* @history
*   [0] Initialisation des variables
*   [1] On démarre le SERVEUR UDP d'écoute globale
*   [2] On attends un client
*   [3] On gère la requête
*   [4] On ouvre une socket client sur un nouveau port (si ok)
*   [5] On envoie la réponse
*   [6] On démarre un thread de gestion avec timeout (en attente du client redirigé)
*
*/
void* LISTEN_UDP(){
	/* [0] Initialisation des variables
	==========================================================*/
	int                CLIENT_SOCKET;                        // contiendra la socket UDP à envoyer sur un THREAD
	struct sockaddr_in clientInfo;                           // contiendra les infos client
	char               client_ip[20];                        // IP du client
	socklen_t          len;                                  // taille de la socket
	int                read;                                 // compteurs
	char               buffer[MAX_BUF_LEN];                  // buffer requête
	struct bind_header request;                              // requête parsée
	int                i, index;                             // compteurs

	// retour de @DROP_UDP_SERVER
	int SOCKET;

	/* [1] On démarre le SERVEUR UDP d'écoute globale
	==========================================================*/
	if( DROP_UDP_SERVER(UDP_PORT, &SOCKET) < 0 ){

		if( DEBUGMOD&SCK ) printf("\tErreur de mise en place de la socket UDP\n");

		// On ferme la SOCKET d'écoute globale
		printf("\tFERMETURE DE LA SOCKET UDP!\n");
		close(SOCKET);

		return NULL;
	}

	printf("\tUDP Listen Port: %d\n", UDP_PORT);



	/* [2] Attente de connection
	============================================================================*/
	while( 1 ){

		/* 0. On initialise les SOCKET en attendant la connexion et le rang du "manager" inactif */
		CLIENT_SOCKET = -1;
		index         = -1;

		/* 1. On attends une connection UDP */
		read = recvfrom(SOCKET, buffer, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len);

		/* 2. Si erreur reception ou taille incorrecte */
		if( read != sizeof(struct bind_header) ){
			if( DEBUGMOD&BUF ) printf("\t\t[UDP] READ('%s') = %d bytes (expected: %d)\n", buffer, read, (int) sizeof(struct bind_header));
			break;
		}

		/* 3. On récupère l'adresse IP du client */
		inet_ntop(AF_INET, &(clientInfo.sin_addr), client_ip, 20);

		if( DEBUGMOD&SCK ) printf("\t[UDP] %s connecté\n", client_ip);

		/* 3. On parse la requête*/
		memcpy(&request, buffer, sizeof(struct bind_header));

		printf("\t\t\t[UDP] parsed:\n\t\t\t\tflag = %d\n\t\t\t\tport = %d\n", (int) request.flags, request.port);




		/* 4. On cherche un "manager" libre (inactif) */
		for( i = 0 ; i < MAX_UDP_THR ; i++ )
			if( activeUDPManagers[i] == 0 ){ index = i; break; }

		// si on a trouvé un "manager" libre
		if( index != -1 ){

			/* 5. On lance un thread pour le traitement de ce client */
			pthread_create(&UDPManagers[index], NULL, manageTerminal, (void*)(intptr_t) CLIENT_SOCKET);

			if( DEBUGMOD&THR ) printf("\tTHREAD[UDP][%d] démarré\n", index);

			/* 6. On signale que ce "manager" est maintenant actif */
			activeUDPManagers[index] = 1;

		}else
			if( DEBUGMOD&THR ) printf("\tAucun thread UDP libre!\n");

	}



	/* [n] On ferme la SOCKET d'écoute globale
	==========================================================*/
	printf("\tFERMETURE DE LA SOCKET UDP!\n");
	close(SOCKET);

	return NULL;
}








/* Gestion d'une connexion PLANE
*
* @THREADABLE_SOCKET<void*>			SOCKET de la connexion client
*
* @history
* [1] Initialisation des variables
* [2] Récupération de la requête
* [3] Traitement de la requête
* [4] Création de la réponse
* [5] Envoi de la réponse
* [6] On vide les buffers
* [7] Fermeture de la connection (SOCKET)
* [n] Arrêt du THREAD
* 	1. On récupère le rang dans les "managers"
* 	2. On met à jour "activeManagers"
* 	3. On arrête le THREAD
*
*/
void* managePlane(void* THREADABLE_SOCKET){

	/* [1] Initialisation des variables
	=========================================================*/
	int read; // compteur
	int TCP_SOCKET = (intptr_t) THREADABLE_SOCKET; // Socket client
	char request[MAX_BUF_LEN]; // Requête
	// char response[MAX_BUF_LEN]; // Réponse

	do{

		/* [2] Récupération de la requête
		=========================================================*/
		/* 1. On lit sur la socket */
		read = recv(TCP_SOCKET, request, MAX_BUF_LEN, 0);

		/* 2. Si erreur reception */
		if( read < 0 ){
			if( DEBUGMOD&BUF ) printf("\t\t[TCP] READ = %d\n", read);
			break;
		}

		/* 3. On désérialise la requête*/


		printf("\t\tPLANE Request(%d bytes) : '%s'\n", read, request);

		/* [3] Gestion de la requête
		=========================================================*/



	}while( 0 );

	/* [n] Arrêt du THREAD
	============================================================================*/
	/* 1. On récupère le rang dans les "managers" */
	int i, index = -1;
	for( i = 0 ; i < MAX_TCP_THR ; i++ )
		if( TCPManagers[i] == pthread_self() ){ index = i; break; }

	/* 2. On met à jour "activeManagers" */
	if( index != -1 )
		activeTCPManagers[index] = 0;

	/* 3. On arrête le THREAD */
	if( DEBUGMOD&THR ) printf("\t\tTHREAD[TCP][%d] libéré\n", index);
	pthread_exit(NULL);
}






/* Gestion d'une connexion TERMINAL
*
* @THREADABLE_SOCKET<void*>			SOCKET de la connexion client
*
* @history
* [1] Initialisation des variables
* [2] Récupération de la requête
* [3] Traitement de la requête
* [4] Création de la réponse
* [5] Envoi de la réponse
* [6] On vide les buffers
* [7] Fermeture de la connection (SOCKET)
* [n] Arrêt du THREAD
* 	1. On récupère le rang dans les "managers"
* 	2. On met à jour "activeManagers"
* 	3. On arrête le THREAD
*
*/
void* manageTerminal(void* THREADABLE_SOCKET){

	/* [1] Initialisation des variables
	=========================================================*/
	int read; // compteur
	struct sockaddr_in clientInfo;
	socklen_t len;
	int TCP_SOCKET = (intptr_t) THREADABLE_SOCKET; // Socket client
	char request[MAX_BUF_LEN]; // Requête
	// char response[MAX_BUF_LEN]; // Réponse

	do{

		/* [2] Récupération de la requête
		=========================================================*/
		/* 1. On lit sur la socket */
		read = recvfrom(TCP_SOCKET, request, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len);

		/* 2. Si erreur reception */
		if( read < 0 ){
			if( DEBUGMOD&BUF ) printf("\t\t[TCP] READ = %d\n", read);
			break;
		}

		/* 3. On désérialise la requête*/


		printf("\t\tPLANE Request(%d bytes) : '%s'\n", read, request);

		/* [3] Gestion de la requête
		=========================================================*/



	}while( 0 );

	/* [n] Arrêt du THREAD
	============================================================================*/
	/* 1. On récupère le rang dans les "managers" */
	int i, index = -1;
	for( i = 0 ; i < MAX_TCP_THR ; i++ )
		if( TCPManagers[i] == pthread_self() ){ index = i; break; }

	/* 2. On met à jour "activeManagers" */
	if( index != -1 )
		activeTCPManagers[index] = 0;

	/* 3. On arrête le THREAD */
	if( DEBUGMOD&THR ) printf("\t\tTHREAD[TCP][%d] libéré\n", index);
	pthread_exit(NULL);
}