/*********************************************************
* MINI-PROJET PROGRAMMATION SYSTEME EN C SOUS UNIX	*
*							*
* Auteurs : 	MOUHOUNOU Sophie			*
* 	         NGO Hoan Kiem				*
* 							*
* 12/05/2008						*
*							*
* Version 1.1						*
*							*
*********************************************************/

/*Processus Initial*/

#include<sys/types.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
#include<stdio.h>
#include<stdlib.h>
#include<sys/signal.h>
#include<sys/wait.h>
#include<sys/msg.h>
#include<ipc.h>
#include<sem.h>
#include<wait.h>
#include<sys/stat.h>

#define MSGKEY 50


struct msg_struct2 {
      long mtype;		/* pid du mecano */
      long tps;
      int nat;
      int cat1;
      int cat2;
      int cat3;
      int cat4; 
	} envoi_msg;

struct msg_struct {
	long mtype;
	int information;
	}msg_recu;



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

int j,status,msgS0,nbr_id,num_cat,etat, num_ord,i,nb_mecano;
pid_t pid;
int outil1,outil2,outil3,outil4;

srand(time(NULL));

/* Verification des parametres */

if (nb_argc!=6){
	write(STDERR_FILENO, "5 arguments svp\n",23);
	exit(2); }
else {
/*Recuperation des paramètres*/
  nb_mecano = atoi(argv[0]);
  outil1 = atoi(argv[1]);
  outil2 = atoi(argv[2]);
  outil3 = atoi(argv[3]);
  outil4 = atoi(argv[4]);

printf("mecano : %d\n",nb_mecano);
printf("outil n°1 : %d\n",outil1);
printf("outil n°2 : %d\n",outil2);
printf("outil n°3 : %d\n",outil3);
printf("outil n°4 : %d\n",outil4);
}

/*else {
	
	while(!((argv[0]<100) && (argv(0]>=2)) 
		{
		if ((argv[0]<100) && (argv[0]>=2)) {
			write(STDERR_FILENO,"Creation des argv[0] fils\n");}
		else {
			write(STDERR_FILENO, "Choix invalide : entre 2 et 100\n",23);
			exit(2);
			}
		}
	for(j=1;j++;j<=4) {
	for(num_cat=1;num_cat++;num_cat<=4) {
		while(!((argv[j]<10) && (argv[j]>0))
		{
		if ((argv[j]<100) && (argv[j]>=2)) {
			write("Creation de %i outils dans la categorie %i\n",argv[j],num_cat);}
		else {
			write("Choix invalide : entre 1 et 10\n",23);
			exit(2);
			}
		}
						}
				}*/



system("clear");

printf("\n\n\t**************************************************\t\n");
printf("\tBIENVENUE A L'ATELIER DE SOPHIE ET HOAN KIEM\t\n");
printf("\t*******************************************************\t\n");

/*void sortir_serveur();*/

/* Creation et initialisation des IPC */

/* Creation de la memoire partagee contenant les outils */

int mem_id=shmget(ftok(getenv("HOME"),3),4*sizeof(int),IPC_CREAT | 0666);

/*Pointeur sur la mémoire partagée*/
int *Mem_Part; 

/* Association d'un pointeur a la zone de memoire partagee avec le nombre total d'outils par categorie */
int Ptr_Part=shmat(mem_id,NULL,0);

/* Mem_Part pointe sur le début de la mémoire parttagée*/
Mem_Part=(int *) Ptr_Part;	

Mem_Part[0]=outil1;
Mem_Part[1]=outil2;
Mem_Part[2]=outil3;
Mem_Part[3]=outil4;

printf("Initialisation de la memoire partagee des outils : \n");
printf("Mem partie 1 : %d\n",(int)Mem_Part[0]);
printf("Mem partie 2: %d\n",(int)Mem_Part[1]);
printf("Mem partie 3: %d\n",(int)Mem_Part[2]);
printf("Mem partie 4: %d\n",(int)Mem_Part[3]);

/* Creation du semaphore de synchronisation A REVOIR !!!!!!!!!!!! */


/*Creation de la memeoire partagee pour incrementer le compteur du travail effectue*/
int cpt_id=shmget(ftok(getenv("HOME"),10),sizeof(int),IPC_CREAT | 0666);

/* Lancement des fils */
int chef;
chef=fork();		/* Creation du chef */
if (chef==0) {
	printf("Ici le chef\n");

int cpt,duree,num_tache,nb_outil1,nb_outil2,nb_outil3,nb_outil4,pid_mecano;
char nature[3] = {'m', 'r', 'f' };

int status;
srand(time(NULL));


int msgS0 = msgget(MSGKEY,0666 | IPC_CREAT);

/*void sortir_serveur();*/

while(1) {

/* Attente d'une demande de travail d'un mecanicien */

msgrcv(msgS0,&msg_recu,sizeof(struct msg_struct),1L,0);	/* Reception d'une demande de travail dont le type est egal a 1 */

if((int)msgrcv==-1){
	printf("Erreur lors de la reception du message\n");}
else { printf("Message bien recu\n");}	

pid_mecano=msg_recu.information;				/* On recupere le pid du mecano qui se situe dans le texte du message */
printf("\t[CHEF] MESSAGE DU MECANO : N° %ld\n", pid_mecano);


/* Determination de la duree du travail en secondes */

duree=(Rand() % 10) + 1;
printf("La duree du travail sera de %d secondes\n");


/* Determination de sa nature */

num_tache=(Rand() % 3 + 1);
printf("tache %d a effectuer\n",num_tache);


/* Determination du nombre d'outils nécessaires de chacune des 4 catégories */

nb_outil1=(Rand() % outil1) + 1;
printf("%d outils necessaires pour categorie 1\n",nb_outil1);

nb_outil2=(Rand() % outil2) + 1;
printf("%d outils necessaires pour categorie 2\n",nb_outil2);
		
nb_outil3=(Rand() % outil3) + 1;
printf("%d outils necessaires pour categorie 3\n",nb_outil3);
			
nb_outil4=(Rand() % outil4) + 1;
printf("%d outils necessaires pour categorie 4\n",nb_outil4);
			 

	
/* Envoi du travail a faire au mecanicien concerne */

envoi_msg.mtype=pid_mecano;
envoi_msg.tps=duree;
envoi_msg.nat=num_tache;
envoi_msg.cat1=nb_outil1;
envoi_msg.cat2=nb_outil2;
envoi_msg.cat3=nb_outil3;
envoi_msg.cat4=nb_outil4;


printf("Envoi du travail a faire\n");
msgsnd(msgS0,&envoi_msg,sizeof(struct msg_struct2),0);	/* Envoi de la reponse dont le type est le pid du mecano */
if((int)msgsnd == -1) {
	printf("Erreur lors de l'envoi du message\n");}
else { printf("Envoi du message reussi\n");}

}
	}
	
else {
for (i=0;i<(nb_mecano-1);i++) {	
	if ((pid==fork())==0) 	{	/* mecano */
		num_ord = (Rand() % (nb_mecano-1)+1);
		printf("mecano n° %d\n",i);
		printf("Son numero d'ordre est %d\n",num_ord);

int cpt1=0,cpt2=0,cpt3=0,num_O;

msgS0=msgget(MSGKEY,0666);
int num_pid=getpid();
printf("Ici mecano %d, mon numero d'ordre est le suivant : %d\n",num_pid,num_ord);

/* Attente du passage a zero d'un semaphore A FAIRE!!!!!!!!!!! */

printf("semaphore z\n");

while(1) {

/* Envoi demande de travail de type 1 vers le chef */
msg_recu.mtype=1;
msg_recu.information=num_pid;

msgsnd(msgS0,&msg_recu,sizeof(struct msg_struct),0);


/* Attente du message dont le type est notre pid */

printf("\n\t*********************************************************************************\t\n");
printf("\tVeuillez patientez en attendant de recevoir la reponse de la demande de travail\t\n");
printf("\t************************************************************************************\t\n");

sleep(4);	/* Pour avoir le temps de voir ce qui se passe */
msgrcv(msgS0,&envoi_msg,sizeof(struct msg_struct2),1,0);

printf("Ici mecano n° %d a recu ses informations : \n",num_pid);
printf("\t\t- type de message lu : %ld\n",envoi_msg.mtype);
printf("\t\t - duree du travail : %ld\n",envoi_msg.tps);
printf("\t\t - nature du travail : %ld\n",envoi_msg.nat);
printf("\t\t - outils necessaires dans la categorie 1 : %d\n",envoi_msg.cat1);
printf("\t\t - outils necessaires dans la categorie 2 : %d\n",envoi_msg.cat2);
printf("\t\t - outils necessaires dans la categorie 3 : %d\n",envoi_msg.cat3);
printf("\t\t - outils necessaires dans la categorie 4 : %d\n",envoi_msg.cat4);

//int tache=msg.mtype;


/* Reservation des outils A REVOIR !!!!!!!!!!!!!!!! */

Mem_Part[0]=outil1-envoi_msg.cat1; printf("Memoire outil categorie 1 : %d\n",(int)Mem_Part[0]);
Mem_Part[1]=outil2-envoi_msg.cat2; printf("Memoire outil categorie 2 : %d\n",(int)Mem_Part[1]);
Mem_Part[2]=outil3-envoi_msg.cat3; printf("Memoire outil categorie 3 : %d\n",(int)Mem_Part[2]);
Mem_Part[3]=outil4-envoi_msg.cat4; printf("Memoire outil categorie 4 : %d\n",(int)Mem_Part[3]);

while((Mem_Part[0]<envoi_msg.cat1) && (Mem_Part[1]<envoi_msg.cat2) && (Mem_Part[2]<envoi_msg.cat3) && (Mem_Part[3]<envoi_msg.cat4)) {
	sleep(1);
	}
if ((Mem_Part[0]>envoi_msg.cat1) && (Mem_Part[1]>envoi_msg.cat2) && (Mem_Part[2]>envoi_msg.cat3) && (Mem_Part[3]>envoi_msg.cat4)) {
	for(i=0;i<4;i++) {
	write(1,&Mem_Part[i],sizeof(int)); }
		}


/* Execution du travail : A FAIRE!!!!!!!!!!!! */

printf("Execution du travail par le mecano %d\n",pid);
printf("Veuillez patientez\n");
printf("*********************************************\n\n");
sleep(envoi_msg.tps);


/* Remise a disposition des outils A REVOIR AUSSI !!!!!!!!!!!!!!!! */

Mem_Part[0]=Mem_Part[0]+envoi_msg.cat1; printf("Memoire outil categorie 1 apres recuperation : %d\n",(int)Mem_Part[0]);
Mem_Part[1]=Mem_Part[1]+envoi_msg.cat2; printf("Memoire outil categorie 2 : %d\n",(int)Mem_Part[1]);
Mem_Part[2]=Mem_Part[2]+envoi_msg.cat3; printf("Memoire outil categorie 3 : %d\n",(int)Mem_Part[2]);
Mem_Part[3]=Mem_Part[3]+envoi_msg.cat4; printf("Memoire outil categorie 4 : %d\n",(int)Mem_Part[3]);

for(i=0;i<4;i++) {
write(1,&Mem_Part[i],sizeof(int));
  }

	}

		
}
	}
}

return 0;

}

/* Arret des processus */

/* void sortir_serveur() {

int i_signal;
sleep(5);			/* Attente de signaux */
/*while(i_signal!=9) {
	while ((pid=waitpid(-1,&etat,0))>0) {
		if (WIFEXITED(etat))
			if (WEXITSTATUS(etat)==0){
				printf("Le fils %i s'est termine correctement, avec le code 0\n",pid);
			OU

while (wait(&etat)!=-1)	{			/* Wait renvoie -1 s'il n'y a plus de processus a acquitter */
/*		printf("Le chef et les mecanos se sont termines normalement\n");}
	for (i=1;i++;i<argv[0])	{			/* ou l'envoyer au groupe avec kill(0,SIGTERM) */
/*		kill(getpid(),SIGTERM);
		printf("Processus fils %i termine\n",getpid());
		printf("******************************\n"); }

	if(shmctl(Mem_Part, IPC_RMID, NULL)==-1) { 
		perror("Probleme de suppression du segment de memoire partagee, Mem_Part\n");}
	else {printf("Pointeur Mem_Part, segment de memoire partage supprime Mem_Part\n");

	if(shmctl(Ptr_Part, IPC_RMID, NULL)==-1) { 
		perror("Probleme de suppression du pointeur sur segment de memoire partagee, Ptr_Part\n");}
	else {printf("Pointeur Ptr_Part, segment de memoire partage supprime\n");

	if(shmctl(mem_id, IPC_RMID, NULL)==-1) { 
		perror("Probleme de suppression du segment de memoire partagee mem_id\n");}
	else {printf("Segment de memoire partage, mem_id supprime\n");
	
	if(shmctl(cpt_id, IPC_RMID, NULL)==-1) { 
		perror("Probleme de suppression du segment de memoire partagee du compteur\n");}
	else {printf("Segment de memoire partage du compteursupprime\n");

	if(msgctl(msgS0, IPC_RMID, NULL)==-1) { 
		perror("Probleme de suppression de la file de message msgS0\n");}

	kill(getpid(),SIGTERM);
	printf("\nProcessus initial termine\n");
	printf("\n\n\t--------------------\n");
	printf("\tFIN DU PROGRAMME\n");
	printf("\t---------------------\n");
	exit(0);
	
			}
if(i_signal==9) {
	kill(getpid(),SIGKILL);					/* ou msgctl(msgS0,IPC_RMID,0);*/
/*	printf("\tArret des processus du au signal SIGKILL(9)\n");
	printf("\n\n\t--------------------\n");
	printf("\tFIN DU PROGRAMME\n");
	printf("\t---------------------\n");
	exit();
		}
	}
*/