#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <unistd.h>
#include <sys/un.h>
#include <fcntl.h>
#include <time.h>
#include <pthread.h>
#include <limits.h>


#define SOCKET_NAME "/tmp/my_first_socket"
#define DIM_MATRICE 10
/*===============================================================================================================================================
Indizi
===============================================================================================================================================*/
struct indizi{
	int CoordX;
	int CoordY;
};
struct indizi aiuto[10];
/*===============================================================================================================================================
LISTA GIOCATORI ONLINE
===============================================================================================================================================*/
struct ListaGiocatori{								
	char NomeGiocatore[25];
	int nIndiziTrovati; 
	int FlagUltimoInd;	//Assume il valore di 1 solo se è stato trovato l'ultimo indizio
	struct ListaGiocatori *next;
};
struct ListaGiocatori *players=NULL;

int indizitrovati[9];	//Array degli indizi trovati
pthread_mutex_t semaforo1=PTHREAD_MUTEX_INITIALIZER ;
pthread_mutex_t semaforo2=PTHREAD_MUTEX_INITIALIZER ;
time_t Tinizio,Tcorrente; 	//Variabili temporali
int sincronizzazioneclient1=0; //Sincronizzazione del client
int tesoro=1;		//assume il valore di 1 se è stato scovato il tesoro
char Mappa[DIM_MATRICE][DIM_MATRICE];//Mappa di gioco
/*===============================================================================================================================================
Prototipi di funzioni
===============================================================================================================================================*/
struct ListaGiocatori *EliminaGiocatore(struct ListaGiocatori *players, char username[]);
void CreaGiocatore(char username[]);
int UtentiCollegati(struct ListaGiocatori *players);
void IndizioTrovato(struct ListaGiocatori *players,char *username);
void StampaGiocatori(int Socket, struct ListaGiocatori *players);
void StampaMappa(char Mappa [DIM_MATRICE][DIM_MATRICE]);
void * ThreadLogin(void * arg);
void creaMappa(char Mappa[DIM_MATRICE][DIM_MATRICE], struct indizi* aiuto);
void Partenza(int Socket,int *Riga, int *Colonna);
void PosizioneAttuale(char Mappa[DIM_MATRICE][DIM_MATRICE], int Riga, int Colonna);
void FileTesoro(char username[]);
int updateMappa(int Socket,char Mappa[DIM_MATRICE][DIM_MATRICE],int Riga,int Colonna,int oldRiga,int oldColonna,struct indizi* aiuto,char *username);
void MappaClient(int Socket, char Mappa[DIM_MATRICE][DIM_MATRICE], int flag, int Riga,int Colonna,char *username);
void Gioco(int Socket,char username[], char Mappa[DIM_MATRICE][DIM_MATRICE]);
void MenuGioco(int Socket, char username[]);
int ControlloDisponibilita(char username[]);
void SalvaLogin ( char username[] );
void LiberaMappa(int *Riga, int *Colonna);
void login(int Socket);
/*===============================================================================================================================================
Autori: Nunzio Salvato & Salvatore Barbuto
Programma: Caccia al Tesoro
===============================================================================================================================================*/
int main(int argc, char **argv){
	srand((unsigned)time(NULL));
  	if(argc<2){
		perror("Errore parametri\n");
		exit(1);
	}
  	int *ThreadSocket, ascoltosocket, connessionesocket, porta=atoi(argv[1]);
	struct sockaddr_in indirizzo, clientAddr;
	pthread_t tid;
  	socklen_t clientLen;
  	indirizzo.sin_family=AF_INET;
  	indirizzo.sin_addr.s_addr=INADDR_ANY;
  
 	if((ascoltosocket=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))<0){  //crea un socket e lo assegnamo a ascoltosocket
		perror("socket");
		exit(1);
	}
  	unlink(SOCKET_NAME); 
  	indirizzo.sin_port=htons(porta); // assegno a my address il numero della porta su cui comunnicano client e server 
  	//Binding
  	if(bind(ascoltosocket, (struct sockaddr *)&indirizzo, sizeof(indirizzo))<0){  // bind serve per dare al socket un indirizzo (&my addr)
		perror("bind");
		exit(1);
	}
  	if(listen(ascoltosocket, 1)<0) { // setto il socket in modalita' ascolto verso il server (ascolta il server)
		perror("ListaGiocatorien");
		exit(1);
	}
	//Creazione della mappa
	time(&Tinizio);
	Tcorrente=Tinizio;
    creaMappa(Mappa,aiuto);	
  	while(1){
  		clientLen = sizeof(clientAddr);
    	if((connessionesocket=accept(ascoltosocket, (struct sockaddr *)&clientAddr, &clientLen))<0){ // con la funzione accept il server accetta i client, fa si che i client si colleghino a lui
			perror("accept");
			exit(1);
		}
    	ThreadSocket=(int*)malloc(sizeof(int)); //il serve crea un thread per il client connesso e per gestirlo
    	fprintf(stderr, " new connection \n");//
    	*ThreadSocket = connessionesocket;//
    	printf("server: new connection from %d \n",connessionesocket);//
    	pthread_create(&tid, NULL, ThreadLogin, (void *) ThreadSocket); // fine creazione, threadlogin funzione che fa i login dei client, il terzo parametro di queta funzione sarà l'input della funzione managethread
    }
  	close(connessionesocket);// chiusura dei 2 socket
  	close(ascoltosocket);
  	return 0;
}
/*===============================================================================================================================================
Rimuovi Giocatore dalla Lista
===============================================================================================================================================*/
struct ListaGiocatori *EliminaGiocatore(struct ListaGiocatori *players, char username[]){
	if(players!=NULL){
		if(strcmp(players->NomeGiocatore,username)==0){
			struct ListaGiocatori *PabloEmilioEscobarGaviria=(struct ListaGiocatori *)malloc(sizeof(struct ListaGiocatori));
			PabloEmilioEscobarGaviria=players;
			players=players->next;
			free(PabloEmilioEscobarGaviria); // abbiamo ucciso escobar
		}
		else{
		    players->next=EliminaGiocatore(players->next, username);
		}

	}
    return players;
}
/*===============================================================================================================================================
Crea Lista giocatori
===============================================================================================================================================*/
void CreaGiocatore(char username[]){
	if(players==NULL){
		players=(struct ListaGiocatori *)malloc(sizeof(struct ListaGiocatori));
		strcpy(players->NomeGiocatore, username);
		players->nIndiziTrovati=0;
		players->next=NULL;
	}
	else{  //aggiungo in testa il giocatore
		struct ListaGiocatori *NewPlayer=(struct ListaGiocatori *)malloc(sizeof(struct ListaGiocatori));
		strcpy(NewPlayer->NomeGiocatore, username);
		players->nIndiziTrovati=0;
		players->FlagUltimoInd=0;
		NewPlayer->next=players;
		players=NewPlayer;
	}
}
/*===============================================================================================================================================
Restituisci Utenti Online
===============================================================================================================================================*/
int UtentiCollegati(struct ListaGiocatori *players){
	if(players != NULL){
        return 1+UtentiCollegati(players->next);
    }
	else{
        return 0;
    }
}

/*===============================================================================================================================================
Aggiorna Indizi
===============================================================================================================================================*/
void IndizioTrovato(struct ListaGiocatori *players,char *username){
	if(strcmp(players->NomeGiocatore, username) == 0){
        players->nIndiziTrovati=players->nIndiziTrovati+1;
    }
	else{
        IndizioTrovato(players->next,username);
    }
}

/*===============================================================================================================================================
Stampa Lista Giocatori
===============================================================================================================================================*/
void StampaGiocatori(int Socket, struct ListaGiocatori *players){
	char Messaggio[300]; // messaggio che il server manda al client
	char NumIndizi[3]; 
	char NomePlayer[20];
	int i;
	bzero(Messaggio,300); //pulisco il Messaggio
	if(players==NULL){
		write(Socket, "0 UTENTI ONLINE",  15);
	}
	else{
		struct ListaGiocatori *tmp=players;
		strcat(Messaggio,"USERNAME   NUMERO INDIZI\n");
		for(;tmp!=NULL;tmp=tmp->next){
            for (i=0; tmp->NomeGiocatore[i] != '\n'; i++){
			   NomePlayer[i]=tmp->NomeGiocatore[i];
			}
			NomePlayer[i]='\0';
			strcat(Messaggio, NomePlayer);
			for(i=0;i < (20-strlen(NomePlayer));i++) strcat(Messaggio," ");
			sprintf(NumIndizi,"%d",tmp->nIndiziTrovati);
			strcat(Messaggio,NumIndizi);
			strcat(Messaggio,"\n");
		}
		write(Socket,Messaggio,strlen(Messaggio));
	}
}
/*===============================================================================================================================================
Stampo Mappa di gioco lato server
===============================================================================================================================================*/
void StampaMappa(char Mappa [DIM_MATRICE][DIM_MATRICE]){
	int i, j;
	char indizio[2];
	printf("\nMAPPA DI GIOCO:\n");
	for(i=0;i<DIM_MATRICE;i++){
     	for(j=0;j<DIM_MATRICE;j++){
			if(Mappa [i][j]>='1' && Mappa [i][j]<='9'){
				indizio[0]=Mappa[i][j];
				indizio[1]='\0';
				printf("\t%d" , atoi(indizio));
			}
			else{
                printf("\t%c", Mappa[i][j]);
            }
        }
        printf ("\n");
    }
}

/*===============================================================================================================================================
Gestione Thread iniziale
===============================================================================================================================================*/
void * ThreadLogin(void * arg){
  int socket=*(int*)arg;
  login(socket);
}

/*===============================================================================================================================================
Creazione Mappa
===============================================================================================================================================*/
void creaMappa(char Mappa[DIM_MATRICE][DIM_MATRICE], struct indizi* aiuto){
	char NumIndizio='1';
	int Coordinate[2], i=0, j=0,num_indizi=8, num_ostacoli=rand()%20+1;
	//Azzero array indizi e matrice
	for(i=0;i<9;i++) indizitrovati[i]=0;
	for(i=0;i<DIM_MATRICE;i++){
		for(j=0;j<DIM_MATRICE;j++){
			Mappa[i][j]='0';
		}
	}
	i=0;
	//Inizio blocco indizi
	aiuto[0].CoordX=rand()%10;
	aiuto[0].CoordY=rand()%10;
	Mappa[aiuto[0].CoordX][aiuto[0].CoordY]=NumIndizio;
	while(atoi(&NumIndizio)!=num_indizi+1){
		Coordinate[0]=rand()%10;
		Coordinate[1]=rand()%10;
		if(Mappa[Coordinate[0]][Coordinate[1]]=='0'){
			Mappa[Coordinate[0]][Coordinate[1]]=NumIndizio+1 ;
			aiuto[atoi(&NumIndizio)].CoordX=Coordinate[0];
			aiuto[atoi(&NumIndizio)].CoordY=Coordinate[1];
			NumIndizio++;
		}
	}
	//Fine blocco indizi
	i=0;
    //Inizio blocco tesoro
	do{
		Coordinate[0]=rand()%10;
		Coordinate[1]=rand()%10;
        if(Mappa[Coordinate[0]][Coordinate[1]]=='0'){
            Mappa[Coordinate[0]][Coordinate[1]]='$';
            i++;
        }
	}while(i!=1);
	//Fine blocco tesoro ed assegno coordinate all'ultimo suggerimento
	aiuto[9].CoordX=Coordinate[0],
	aiuto[9].CoordY=Coordinate[1];
	i=0;
    //Inizio blocco ostacoli
	while(i!=num_ostacoli){
		Coordinate[0]=rand()%10;
		Coordinate[1]=rand()%10;
		if(Mappa[Coordinate[0]][Coordinate[1]]=='0'){
			Mappa[Coordinate[0]][Coordinate[1]]='x';
			i++;
		}
	}
	//Fine blocco ostacoli
	StampaMappa(Mappa);
}

/*===============================================================================================================================================
Posiziono Giocatore
===============================================================================================================================================*/ 
void Partenza(int Socket,int *Riga, int *Colonna){
	char Messaggio[256], scelta[128];
	bzero(Messaggio, 256);
	pthread_mutex_lock(&semaforo2); // semaforo utilizzato per evitare che 2 client possano iniziare nello stesso punto
	do{
	    *Riga=rand()%10;
	   	*Colonna=rand()%10;
	}
	while(Mappa[*Riga][*Colonna]!='0' && Mappa[*Riga][*Colonna]!='c');
	strcpy(Messaggio, "GIOCATORE PRONTO A GIOCARE...");
	write(Socket, Messaggio, strlen(Messaggio));
	read(Socket,scelta,127);
	pthread_mutex_unlock(&semaforo2); //sblocco semaforo
	bzero(Messaggio, 256);
}

/*===============================================================================================================================================
Aggiornamento posizione del giocatore
===============================================================================================================================================*/
void PosizioneAttuale(char Mappa[DIM_MATRICE][DIM_MATRICE], int Riga, int Colonna){
	Mappa[Riga][Colonna]='?';
}

/*===============================================================================================================================================
Salvataggio utente - orario di chi ha trovato il tesoro
===============================================================================================================================================*/
void FileTesoro(char username[]){
      int fd;
      char messaggio[256], orario[256];
      time_t ora;
      time(&ora); 
      bzero(messaggio, 256);
      bzero(orario, 256);
      strcpy(messaggio, "L'UTENTE : " ) ;
      sprintf(orario, "%s", asctime(localtime(&ora)));
      strcat(messaggio, username);
      strcat(messaggio, " HA TROVATO IL TESORO IL ");
      strcat(messaggio, orario);
      strcat(messaggio, "\n");
      pthread_mutex_lock(&semaforo1); // per evitare che più client possano aprire il file di testo in contemporanea
      fd=open("tesoro.txt", O_WRONLY|O_CREAT);
      lseek(fd, 0, SEEK_END);
      write(fd, messaggio, strlen(messaggio));
      close(fd);
      pthread_mutex_unlock(&semaforo1);
}

/*===============================================================================================================================================
Aggiorno valori all'interno della mappa di gioco
===============================================================================================================================================*/
int updateMappa(int Socket,char Mappa[DIM_MATRICE][DIM_MATRICE],int Riga,int Colonna,int oldRiga,int oldColonna,struct indizi* aiuto,char *username){
	struct ListaGiocatori *Gioc1;
	int lastIndizio, flag=0;
	char app[5], buf[2];
	for(Gioc1=players;Gioc1;Gioc1=Gioc1->next){
		if(strcmp(Gioc1->NomeGiocatore,username)==0) lastIndizio=Gioc1->FlagUltimoInd;
	}
	//Blocco ritrovamento tesoro
	if(Mappa[Riga][Colonna]=='$' || Mappa[Riga][Colonna]=='X'){
		Mappa[Riga][Colonna]='X';
		//Tesoro scovato
		if(lastIndizio==1){
			tesoro=0;
			FileTesoro(username);
		}
		if(!(Mappa[oldRiga][oldColonna]>='1' && Mappa[oldRiga][oldColonna]<='9')){
            Mappa[oldRiga][oldColonna]='c';
        }	
        flag=20;
	}
	//Blocco ritrovamento indizio
	else if(Mappa[Riga][Colonna]>='1' && Mappa[Riga][Colonna]<='9'){
     	     if(!(Mappa[oldRiga][oldColonna]>='1' && Mappa[oldRiga][oldColonna]<='9') ){
        	     if (Mappa[oldRiga][oldColonna]!='X'){
				       Mappa[oldRiga][oldColonna]='c';
        	     }
    	     }
    	     buf[0]=Mappa[Riga][Colonna];
		     buf[1]='\0';
		     flag=9+atoi(buf);
		     indizitrovati[atoi(buf)-1]=1;
		     if(Mappa[Riga][Colonna]=='9'){
		     	for(Gioc1=players;Gioc1;Gioc1=Gioc1->next){
		     		if(strcmp(Gioc1->NomeGiocatore,username)==0){
			     		Gioc1->FlagUltimoInd=1;
				     }
			     }
		     }
	}

	//Blocco ritrovamento ostacolo
	else if(Mappa[Riga][Colonna]=='x'){	
		if(oldRiga == Riga && oldColonna != Colonna) 	Mappa[Riga][Colonna]='|';
		else Mappa[Riga][Colonna]='_';
    	flag=1;
    }
    //Movimento non consentito su ostacolo o utente
    else if(Mappa[Riga][Colonna]=='|' || Mappa[Riga][Colonna]=='_' || Mappa[Riga][Colonna]=='?' || Mappa[Riga][Colonna]=='O'){
    	flag=1;
    }
    //Movimento su celle non importanti
    else if (Mappa[Riga][Colonna]=='0' || Mappa[Riga][Colonna]=='c'){
     	if(!(Mappa[oldRiga][oldColonna]>='1' && Mappa[oldRiga][oldColonna]<='9')  ){
           	if (Mappa[oldRiga][oldColonna]!='X'){
				Mappa[oldRiga][oldColonna]='c';
        	}
        }
     	flag=0;
    }
    
	return flag;
}

/*===============================================================================================================================================
Stampa della mappa sul client
===============================================================================================================================================*/
void MappaClient(int Socket, char Mappa[DIM_MATRICE][DIM_MATRICE], int flag, int Riga,int Colonna,char *username){
	int lastIndizio,i, j;
	char buf[2],ColRiga[5],messaggio[1000],app[5];
	bzero(messaggio,1000);
	struct ListaGiocatori* Gioc1;
	//Cerchiamo se l'username è presente all'interno della lista dei giocatori online e ci salviamo l'ultimo indizio
	for(Gioc1=players;Gioc1;Gioc1=Gioc1->next){
		if(strcmp(Gioc1->NomeGiocatore,username)==0){
			lastIndizio=Gioc1->FlagUltimoInd;
		}
	}
	sprintf(app, "%f", difftime(time(&Tcorrente), Tinizio));
	strcat(messaggio, "\t\t\t TEMPO: ");
	strcat(messaggio, app);
	strcat(messaggio, "s \n");
	if(flag==0 || flag==20){
		strcat(messaggio, " MOVIMENTO EFFETTUATO ");
		strcat(messaggio, "\n\n");
	}
	else if(flag==-1){
		strcat(messaggio, "\t\t\t INIZIO GIOCO!");
		strcat(messaggio, ColRiga);
		strcat(messaggio, " \n\n");
		strcat(messaggio, "\t IL PRIMO INDIZIO SI TROVA NELLA COLONNA :  ");
		sprintf(app, "%d", aiuto[0].CoordY + 1);
		strcat(messaggio, app);
		strcat(messaggio, ",");
		strcat(messaggio, " E RIGA :  ");
		sprintf(app, "%d", aiuto[0].CoordX + 1);
		strcat(messaggio, app);
		strcat(messaggio, "     \n");
	}
	else if(flag==3){
		strcat(messaggio, " MOVIMENTO FUORI CAMPO DI GIOCO!");
		strcat(messaggio, ColRiga);
		strcat(messaggio, " \n\n");
	}
	else if (flag==1){
		strcat( messaggio , " MOVIMENTO NON CONCESSO! ");
		strcat(messaggio, ColRiga);
		strcat(messaggio, " \n\n");
	}
	else{
		if(flag!=20){
			if(flag==18) strcat(messaggio, "\tULTIMO INDIZIO SCOVATO, IL TESORO SI TROVA NELLA COLONNA: ");
			else  strcat(messaggio, "\tINDIZIO SCOVATO, IL PROSSIMO INDIZIO SI TROVA NELLA COLONNA: ");	
			sprintf(ColRiga, "%d", aiuto[(flag-9)].CoordY + 1);
			strcat(messaggio, ColRiga);
			strcat(messaggio, ",");
			strcat(messaggio, " E RIGA : ");
			sprintf(ColRiga, "%d", aiuto[(flag-9)].CoordX + 1);
			strcat(messaggio, ColRiga);
			strcat(messaggio, "   \n\n");
		}
	}

	for(i=0;i<DIM_MATRICE;i++){
     	for(j=0;j<DIM_MATRICE;j++){
		    //Trovato il tesoro
            if(Mappa[i][j]=='X' ){
				if(lastIndizio==1) strcat(messaggio, "\a\033[36mX\t\033[0m");
     		   	else{
     		   		if(Riga==i && Colonna==j) strcat(messaggio, "\033[31m?\033[0m\t");
     		   		else  strcat(messaggio, ".\t");	
				}
     		}
            //Trovato ostacolo
            else
			{	 if(Mappa[i][j]=='|'){
     		  			strcat ( messaggio , "|\t" ) ;
            	 }
            	 else{
				 		if(Mappa[i][j]=='_'){
							strcat ( messaggio , "_\t" ) ;
            			}
            			//Trovate celle inesplorate
            			else{
            				if( Mappa[i][j]=='x' || Mappa[i][j]=='X' || Mappa[i][j]=='0'){
            					strcat(messaggio, "o\t");
            				}	
           					//Trovato indizio
            				else{
            					if(Mappa[i][j]>='1' && Mappa[i][j]<='9') {
            						buf[0]=Mappa[i][j];
									buf[1]='\0';
									if(indizitrovati[atoi(buf)-1]==0) strcat(messaggio, "o\t");
									else {
										if(Riga==i && Colonna==j){
										strcat(messaggio,"\033[31m?\033[0m\t");	
										}
										else{
											strcat(messaggio, buf);
											strcat(messaggio, "\t");
										}
									}
								}			
            					//Celle già visitate
            					else{
            							if(Mappa[i][j]=='c'){
                							strcat(messaggio, ".\t");
            							}
            							//Posizione utente attuale
            							else{
            								if(Mappa[i][j]=='?'){
                								strcat(messaggio, "\033[31m?\033[0m\t");
            								}
        								}
    							}
    						}
    					}
    			}
    		}
    		
    	}
		strcat(messaggio, "\n");
	}
    strcat(messaggio, "\n");
    if(tesoro!=0){
    	strcat(messaggio, "(4/8/2/6) PER MUOVERTI, (ONLINE) PER STAMPARE GLI UTENTI ONLINE, (EXIT) PER USCIRE ");
    }
    else{
    	strcat(messaggio, "(: TROVATO  IL TESORO!!! (INVIO) GENERA UNA NUOVA MAPPA, (EXIT) DISCONNETTI! ;)");
		tesoro=0;
    }
    write(Socket, messaggio, strlen(messaggio));
    bzero(messaggio, 1000);
}

/*===============================================================================================================================================
Funzione del Gioco
===============================================================================================================================================*/
void Gioco(int Socket,char username[], char Mappa[DIM_MATRICE][DIM_MATRICE]){
	int n, flag=0,Vincitori=0,min_indizi=INT_MIN,Riga=0,Colonna=0;
    char rematch[300],messaggio[1000],NomeUser[20],scelta[300];
    struct ListaGiocatori *Gioc1;
    Partenza(Socket, &Riga, &Colonna);
    PosizioneAttuale(Mappa, Riga, Colonna);
    MappaClient(Socket, Mappa,-1,Riga,Colonna,username);
    //Stampa mappa sul server
	while(1) { //fino a quando non viene trovato il tesoro o finisce il tempo:
     	bzero(scelta, 300);
     	bzero(messaggio, 1000);
     	flag=0;
     	n=read(Socket, scelta, 299);
     	if(n<0){
			perror("Errore lettura da socket scelta\n");
			exit(1);
		}
		//controllo se il gioco è terminato
     	if(tesoro==0 || difftime(time(&Tcorrente), Tinizio)>180){
		 	if ( tesoro==1 && difftime(time(&Tcorrente), Tinizio)>180){  //se è scaduto il tempo
				for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
					if(Gioc1->nIndiziTrovati>min_indizi){
						min_indizi=Gioc1->nIndiziTrovati;
						strcpy(NomeUser,Gioc1->NomeGiocatore);
					}
				}
				strcat(messaggio, "\nTempo Scaduto!!\n");
				for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
					if(Gioc1->nIndiziTrovati==min_indizi){
						Vincitori++;
					}
				}
				if(Vincitori>1){
					strcat (messaggio, "Vincono i seguenti Giocatori...\n"); //Pareggio
					for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
						if(Gioc1->nIndiziTrovati==min_indizi){
							strcat(messaggio, Gioc1->NomeGiocatore);
							strcat(messaggio,"\n");
						}
					}
				}
				else{
					strcat(messaggio, "Il vincitore e' l'utente: \n"); //Vince la partita
					strcat(messaggio, NomeUser);
				}
				Vincitori=0;
				min_indizi=INT_MIN;
			}
			pthread_mutex_lock(&semaforo1);
			sincronizzazioneclient1++;
			if(sincronizzazioneclient1==1){
	     		creaMappa(Mappa, aiuto);
	     	}
     		pthread_mutex_unlock(&semaforo1);
     		strcat(messaggio, "\nAttendi altri giocatori...");
     		write(Socket, messaggio, strlen(messaggio));
     		while(sincronizzazioneclient1<UtentiCollegati(players) && sincronizzazioneclient1!=0);
			read(Socket, rematch, 299);
			Partenza(Socket, &Riga, &Colonna);
     		PosizioneAttuale(Mappa, Riga, Colonna);
			for(Gioc1=players;Gioc1!=NULL;Gioc1=Gioc1->next){
				Gioc1->nIndiziTrovati=0;
				Gioc1->FlagUltimoInd=0;
     		}
			tesoro=1;
			sincronizzazioneclient1=0;
			flag=-1;
			time(&Tinizio);
		}
		else{//Blocco spostamento a sx
	     	if(strcmp(scelta, "4\n")==0 ){//Controllo non superare il limite della matrice
	     		if((Colonna-1)>-1){
	     			flag=updateMappa(Socket, Mappa, Riga, Colonna-1, Riga, Colonna, aiuto,username);
	     			
	     			if(flag==0 && tesoro==1){
	     				PosizioneAttuale(Mappa, Riga, Colonna-1);
	               		Colonna=Colonna-1;
	              	}
	               	else {
	               		if(flag>=10){
	               			IndizioTrovato(players,username);
	               			Colonna=Colonna-1;
	               		}
	        		}
	        	}
	        	else flag=3; 	//Avviso che si è usciti fuori dalla matrice
			}
	        //Blocco spostamento su
      		else{
      			if(strcmp(scelta, "8\n")==0){
			    	//Controllo non superare il limite della matrice
      				if((Riga-1)>-1){
	      				flag=updateMappa(Socket,Mappa,Riga-1,Colonna,Riga,Colonna,aiuto,username);
	      				if (flag==0 && tesoro==1){
	      					PosizioneAttuale(Mappa,Riga-1,Colonna);
                   		    Riga=Riga-1;
	               	 	}
	               		else{
	               			if(flag>=10){
	               				IndizioTrovato(players,username);
	               				Riga=Riga-1;
	               			}
                		}
                	}
               		else flag=3;	//Avviso che si è usciti fuori dalla matrice
				}
				//Blocco spostamento giù
     			else{
     				if(strcmp(scelta, "2\n")==0){
			   		//Controllo non superare il limite della matrice
     					if((Riga+1)<10){
     						flag=updateMappa(Socket, Mappa, Riga+1, Colonna, Riga, Colonna, aiuto,username);
     						if(flag==0 && tesoro==1){
     							PosizioneAttuale(Mappa, Riga+1, Colonna);
               					Riga=Riga+1;
              	 			}
	               			else{
	               				if(flag>=10){
	               					IndizioTrovato(players,username);
	               					Riga=Riga+1;
	               				}
            				}
	            		}
						else flag=3;	//Avviso che si è usciti fuori dalla matrice
					}
					//Blocco spostamento a dx
					else{
						if(strcmp(scelta, "6\n")==0){
			    			//Controllo non superare il limite della matrice
							if((Colonna+1)<10){
									flag=updateMappa(Socket, Mappa, Riga, Colonna+1, Riga, Colonna, aiuto,username);
									if(flag==0 && tesoro==1){
										PosizioneAttuale(Mappa, Riga, Colonna+1);
               							Colonna=Colonna+1;
               						}
               						else{
               							if(flag>=10){
               								IndizioTrovato(players,username);
               								Colonna=Colonna + 1;
               							}
                					}
                			}
							else{
                				flag=3;	//Avviso che si è usciti fuori dalla matrice
							}
          				}
						else{	
							if(strcmp(scelta, "EXIT\n")==0 || strcmp(scelta, "exit\n")==0){
						    	printf("Mi sto disconnettendo...\n");
						    	players=EliminaGiocatore(players, username);
						    	LiberaMappa(&Riga, &Colonna);
						    	printf("Disconnesso..\n");
						    	pthread_exit(NULL);
						    }
						    else{
						    		if(strcmp(scelta, "ONLINE\n")==0 || strcmp(scelta, "online\n")==0){
						    				StampaGiocatori(Socket,players);	
									}
						    }
      					}
      				}
      			}
      		 }
      	}
    	MappaClient(Socket, Mappa, flag,Riga,Colonna,username);
 	}
}

/*===============================================================================================================================================
MENU UTENTE
===============================================================================================================================================*/
void MenuGioco(int Socket, char username[]){
	char scelta[300], messaggio[300],app[300];
	int n, opzione=0;
  	do{
     	bzero(messaggio, 300);
     	strcpy(messaggio, "\033[0m\n\t\t\t\t\t M    E    N    U \033[0m");
     	strcat(messaggio, "\n");
     	strcat(messaggio, "\033[32m\nOPZIONI POSSIBILI:\033[0m ");
     	strcat(messaggio, "\n");
     	strcat(messaggio, "\033[33m\n\t( 1 ) I N I Z I A M O   A   G I O C A R E !\033[0m ");
     	strcat(messaggio, "\n\n");
		strcat(messaggio, "\033[33m\t( 2 ) V I S U A L I Z Z A  UTENTI  CONNESSI   A L   S E R V E R \033[0m");
		strcat(messaggio, "\n\n");
     	strcat(messaggio, "\033[33m\t( 3 ) D I S C O N N E T T I T I   D A L L'  A C C O U N T\033[0m");
     	strcat(messaggio, "\n\n\n");
     	strcat(messaggio, "\t\t\033[36mS C E L T A :\033[0m  ");
     	n=write(Socket, messaggio, strlen(messaggio)); //Invio del menu al client
     	if(n<0){
			perror("Errore scrittura sul socket\n");
			exit(1);
		}
     	bzero(scelta, 300);
     	n=read(Socket ,scelta ,299);
     	opzione=atoi(scelta);
     	if(n<0){
			perror("Errore lettura da socket\n");
			exit(1);
		}
     	if(strcmp(scelta, "1\n")==0){
			printf("FUNZIONE GIOCO:\n");
       		Gioco(Socket, username, Mappa);
      		break;
    	}
      	else if(strcmp(scelta, "2\n")==0){
			printf("UTENTI ONLINE:\n");
			StampaGiocatori(Socket, players);
			read(Socket ,app ,299);
        	}
   			else if(strcmp(scelta, "3\n")==0) break;
        		 else{
         			 strcpy(messaggio, "Operazione non valida. Premere  INVIO per continuare.");
        			 write(Socket, messaggio, strlen(messaggio));
         			 bzero(messaggio, 300);
         			 read(Socket, messaggio, 300);
        		}
	}
	while(opzione<=0 || opzione==2 || opzione>3);
  	
	bzero(messaggio, 300);
    players=EliminaGiocatore(players, username);
    strcpy(messaggio, "\nAccount disconnesso. Premere INVIO per continuare.." );
    write(Socket, messaggio, strlen(messaggio));
 	bzero(messaggio, 300);
    read(Socket, messaggio, 300);
}

/*===============================================================================================================================================
CONTROLLO DISPONIBILITA' USERNAME
===============================================================================================================================================*/
int ControlloDisponibilita(char username[]){
	char c,NomeUtente[20];
	int Pf,i=0;
     Pf=open("accesso.txt", O_RDONLY);
     if(Pf){
     	while (read(Pf,&NomeUtente[i],1)>0)
     	{    if(NomeUtente[i]==' ')
     	     {     NomeUtente[i]='\0';
			       if(strcmp(NomeUtente,username)==0) return 1;
     	           bzero(NomeUtente,20);
     	           while(read(Pf,&c,1)>0)
     	           {   if(c == ' ') break;
     	           }
     	           i=0;
     	     }
     	     else i++;
		}
     	close(Pf);
        return 0 ;
     }
     else return -1;
}
/*===============================================================================================================================================
MEMORIZZA GLI ACCESSI DEGLI UTENTI
===============================================================================================================================================*/
void SalvaLogin ( char username[] ){
    int Pf;
    char messaggio[300], orario[300];
    time_t ora;
    time(&ora); 
	bzero(messaggio, 300);
    bzero(orario, 300);
    strcpy(messaggio, "L'utente: ");
    sprintf(orario, "%s", asctime(localtime(&ora)));
    strcat(messaggio, username);
    strcat(messaggio, " ha effettuato l'accesso il giorno: ");
	strcat(messaggio, orario);
    strcat(messaggio, "  ");
    pthread_mutex_lock(&semaforo1);
    Pf=open("salvalogin.txt", O_WRONLY|O_CREAT) ;
    lseek(Pf, 0, SEEK_END);
    write(Pf, messaggio, strlen(messaggio));
    close(Pf);
    pthread_mutex_unlock(&semaforo1);
}

/*===============================================================================================================================================
AGGIORNO MAPPA IN CASO DI ABBANDONO DI UN UTENTE
===============================================================================================================================================*/
void LiberaMappa(int *Riga, int *Colonna){
	if(Mappa[*Riga][*Colonna]=='?'){
		Mappa[*Riga][*Colonna]='0';
	}
	else {
		*Riga=-1;
		*Colonna=-1;
	}
	
}
/*===============================================================================================================================================
ACCESSO E REGISTRAZIONE
===============================================================================================================================================*/
void login(int Socket){
    int PuntFile,n,trovato,accesso=0; // utilizzo accesso per sapere se l'accesso è avvenuto correttamente (caso in cui accesso=1), ci sono stati problemi di tipo credenziali non valide (accesso=0) oppure accesso con dati di un giocatore gia' connesso (accesso=2)
    struct ListaGiocatori *TrovoPlayer; // utilizzo questo puntatore per scoprire se l'username inserito dall'utente non sia gia' presente nella lista dei giocatori online
 	char messaggio[300], username[300], password[300], confronta_passwd[300], confronta_user[300];
    do{
    	write(Socket, "\n PREMERE: \n\t\t(1) Se vuoi registrarti;\n\t\t(2) Se vuoi accedere;\n\t\t(3) per uscire\n", 92);
      	bzero(messaggio, 300);
      	n=read(Socket, messaggio, 299); // leggo risposta del client e salvo il messaggio nell'array messaggio
     	if(n<0){
			perror("Errore lettura da socket\n");
			exit(1);
		}
      	if(strcmp(messaggio, "3\n")==0){
      		printf("Mi disconnetto..\n");
      		pthread_exit(NULL);
      	 }
      	//Registrazione
      	else {
		  	if ( strcmp ( messaggio , "1\n" ) == 0 ){
            	pthread_mutex_lock(&semaforo1); // semaforo1 rosso
           		PuntFile=open("accesso.txt", O_RDWR | O_CREAT); // per tenere traccia degli utenti registrati salvo su file nome utente e pass
            	lseek(PuntFile, 0, SEEK_END);
       			//Username
       			do{
           			write(Socket, "\n\t\t Inserire Username:\t\tPREMERE i per tornare indietro..", 61);
           			bzero(username, 300);
           			n=read(Socket, username, 299);
           			if(strcmp(username,"i\n")==0) break;
           			if(n<0){
						perror ("Errore lettura socket\n");
						exit(1);
					  }
            		trovato=ControlloDisponibilita(username) ; //Username già in uso?
            		if(trovato < 0){
            			bzero(messaggio,300);
              			strcpy(messaggio, "\nERRORE NELLA CREAZIONE DEL FILE!");
              			write(Socket, messaggio, strlen(messaggio));
              			read(Socket, messaggio, 300);
            		}
            		if(trovato==1){
               			bzero(messaggio,300);
              			strcpy(messaggio, "\nUsername gia' in uso. Premi INVIO per provarne un altro!");
              			write(Socket, messaggio, strlen(messaggio));
                   		read(Socket, messaggio, 300);
               		}
        		}
				while(trovato==1);
        		if(strcmp(username,"i\n")!=0){
					n=write(PuntFile, username, strlen(username));
        			n=write(PuntFile, " ", 1);
       				//Password
        			write(Socket, "\n\t\t Inserire Password:\n\t\t", 31);
       				bzero(password, 300);
       				n=read(Socket, password, 299);
       				if(n<0){
						perror("Errore lettura socket\n");
						exit(1);
					}
        			n=write(PuntFile, password, strlen(password));
        			n=write(PuntFile, " ", 1);
       				bzero(messaggio, 300);
       				strcpy(messaggio, " Registrazione effettuata con SUCCESSO! \nPremere INVIO per continuare...");
       				write(Socket, messaggio, strlen(messaggio));
       				bzero(messaggio, 300);
       				read(Socket, messaggio, 300);
				}
				close(PuntFile);
       			pthread_mutex_unlock(&semaforo1);	//Sblocco semaforo
     		 }
     	
    		  else{
				if(strcmp(messaggio, "2\n")==0){ 
					n = write ( Socket, "\n\t\t Inserire Username:\t\tPREMERE i per tornare indietro..", 61 ) ;
					if ( n < 0 ){
						perror ("Errore scrittura socket");
						exit (1);
					}

          			  bzero ( username , 300 );
          			  n=read(Socket, username, 299);
          			  if(strcmp(username,"i\n")!=0){
					  	 if(n< 0){
						 		perror ( "Errore lettura socket\n");
						 		exit (1);
					 	 }
					  	 for(TrovoPlayer=players;TrovoPlayer;TrovoPlayer=TrovoPlayer->next){
					    		if(strcmp(TrovoPlayer->NomeGiocatore,username)==0) break;  
				 	  	 }
					  	 if(TrovoPlayer)accesso=2;
					  	 else{	
	           				   n=write(Socket, "\n\t\t Inserire Password:\n\t\t", 31);
	           				   if(n<0){
							 		perror("Errore scrittura socket");
									exit(1);
							   }
	           				   bzero(password, 300);
	           				   n=read(Socket, password, 299);
	           				   if(n<0){
									perror("Errore lettura socket\n");
									exit(1);
							   }
		          	 		   pthread_mutex_lock(&semaforo1);
	          	 			   PuntFile=open("accesso.txt", O_RDWR | O_CREAT);
	          	 			   lseek(PuntFile, 0, SEEK_SET);
	          	 			   int i=0, j=0;
	          	 			   bzero(confronta_user, 300);
	          	 			   bzero(confronta_passwd, 300);
	          	 			   while(read(PuntFile, &confronta_user[i], 1)>0) {
	          	     		    	if(confronta_user[i]==' '){ 	// Acquisisco username da file
										j=0;
	            	        			confronta_user[i] = '\0';
	            	        			if(strcmp(username,confronta_user)==0){
	            	        				while(read(PuntFile,&confronta_passwd[j],1)>0){
												if(confronta_passwd[j]==' '){
	            	        						confronta_passwd[j]='\0';
													break;
											 	} 
											 	else j++;	
	                    					}
	                  		  				if(strcmp(confronta_passwd,password)!=0){//Password non coincide
												break;
	                           		  		}   
	                       		     		else {
												if(strcmp(confronta_passwd, password)==0){
	            	                   				CreaGiocatore(username);
	                	                			accesso = 1 ; 
	                    	            			break;
	                        	    			}
											}
	                					}
	                					else{
											bzero(confronta_user,i);
							   				i=0;
										}
	            					}
	                				else i++;
								} 
								close ( PuntFile ) ;
	        					pthread_mutex_unlock (&semaforo1);
	        		  	   }
           	  			   if(accesso==0){ 
						   // Credenziali non valide
           		 		   		n=write(Socket, "Credenziali invalide! Premere INVIO per continuare", 53);
               	 		   		if(n<0){
			   						perror("Errore scrittura socket");
									exit(1);
				 		   		}
               	 		   		bzero(messaggio, 300);
               	 		   		n=read(Socket, messaggio, 299);
               	 		   		if(n<0){
				 					perror("Errore lettura da socket");
									exit(1);
				 		   		}
               				}
           	   				else{
			   					if(accesso==2){
           			 			// Utente già collegato in partita
           							n=write(Socket, "Utente gia' in gioco con questo Username! Premere INVIO per continuare", 72);
              						if(n<0){
			   								perror("Errore scrittura sul socket");
											exit(1);
									}
               						bzero(messaggio, 300);
               						n=read(Socket, messaggio, 299);
               						if(n<0){
											perror("Errore lettura da socket");
											exit(1);
									}	
           		  				}
           		  				else{ //Credenziali Valide
              						n=write(Socket, "Login effettuato con successo!\nPremere INVIO  per continuare..", 65);
              						if(n<0){
											perror("Errore scrittura sul socket");
											exit(1);
									}
              						bzero(messaggio, 300);
              						n=read(Socket, messaggio, 299);
              						if(n<0){
											perror("Errore lettura da socket");
											exit(1);
									}
              						SalvaLogin(username);
	      							printf("\n %s \n",username);
	      							// dopo aver fatto correttamente il log in del client chiamo la funzione MenuGioco
              						MenuGioco(Socket, username ) ; 
           		    			}
           					}
           			  }
       	 		}
       		  }
       	}
	}while(n!=3);
}