/*
 ============================================================================
 Name        : lab4b.c
 Author      :
 Version     :
 Copyright   : Your copyright notice
 Description : Hello World in C, Ansi-style
 ============================================================================
 */

#include <stdio.h> 			// needed for printf, sprintf, ...
#include <stdlib.h> 		// needed for exit()
#include <unistd.h> 		// needed for sleep, fork, waitpid, _exit, ftruncate
#include <sys/wait.h> 		// needed for waitpid
#include <fcntl.h> 			// For O_* constants
#include <sys/mman.h> 		// needed for mmap, munmap and associated constants
#include <semaphore.h>

void philosopher(int i);
int parent(void);
void take_forks(int i);
void put_forks(int i);
void test (int i);
void think(int i);
void eat(int i);

#define N 				5 			/* number of philosophers */
#define THINKING 		0 			/* philosopher is thinking */
#define HUNGRY 			1 			/* philosopher is trying to get for ks */
#define EATING 			2 			/* philosopher is eating */
#define FINISH 			3
#define LEFT (arga+4)%N
#define RIGHT (arga+1)%N

struct shared_memory {
int k;
int state[N];
sem_t s[N];
sem_t mutex;
};

struct shared_memory *shared;
int fd_shm, fd_log;

int main(void) {

	if ((fd_shm = shm_open ("/test", O_RDWR | O_CREAT, 0660)) == -1)
		printf("error");
	if (ftruncate (fd_shm, sizeof (struct shared_memory)) == -1)
		printf("error");
	if ((shared = mmap (NULL, sizeof (struct shared_memory), PROT_READ | PROT_WRITE, MAP_SHARED,fd_shm, 0)) == MAP_FAILED)
		printf("error");

	// Initialize the shared memory
	shared -> k = 0;
	for (int i=0; i<N;i++){
		shared -> state[i] = 0;
		sem_init(&shared->s[i],0,0);
	}

	sem_init(&shared->mutex,1,1);

	pid_t pids[N];

	// At the beginning every philosopher is thinking
	  for (int l = 0; l < N; l++){
	  	shared ->state[l]=THINKING;
	  }

	printf("Start");

	for(int j=0; j< N; j++){

		if((pids[j] = fork()) < 0){
			printf("failed");
			perror("fork");
		}else if (pids[j] == 0 ){
			int pid = getpid();
			printf("pids[%d] = %d\n",j,pid);
			philosopher(j);
		}
	}

	parent();

	for (int m=0; m<N;m++){
		waitpid(pids[m],NULL,0);
	}
	printf("This is final k %d\n",shared->k);

	if (munmap(shared, sizeof(struct shared_memory)) == -1) {
		printf("Function munmap() failed\n");
		exit(-1);
	}
	if ((shm_unlink("/test")) == -1){
		printf("Function shm_unlink() failed\n");
		exit(-1);
	}
	return EXIT_SUCCESS;
}

void philosopher(int arga) {
	//int count =0;

	//while(count<5){
	while(1){
		sleep(1);
		//think(i);
		take_forks(arga);
		sleep(2);
		//eat(i);
		sleep(1);
		put_forks(arga);
		//count++;
	}
	shared->state[arga] = FINISH;
	exit(0);
}

void take_forks(int arga) /* i: philosopher number, from 0 to N−1 */
{
	printf("arga take_fork: %d\n", arga);
	sem_wait(&shared->mutex); 		/* enter critical region, down mutex */
	shared->state[arga] = HUNGRY; 		/* record fact that philosopher i is hungry */
	//while (shared->state[i] == HUNGRY){
	test(arga); 						/* try to acquire 2 forks */
	sem_post(&shared->mutex); 		/* exit critical region, up mutex */
	sem_wait(&shared->s[arga]); 		/* block if for ks were not acquired, down philosopher*/
	//}


	//sleep(1);
}
void put_forks(int arga) 				/* i: philosopher number, from 0 to N−1 */
{
	printf("arga put_fork: %d\n", arga);
	sem_wait(&shared->mutex); 		/* enter critical region, down mutes */
	shared->state[arga] = THINKING; 	/* philosopher has finished eating */
	test(LEFT); 					/* see if left neighbor can now eat */
	test(RIGHT); 					/* see if right neighbor can now eat */
	sem_post(&shared->mutex); 		/* exit critical region, up mutex */


}
void test(int arga) 					/* i: philosopher number, from 0 to N−1 */
{
	if (shared->state[arga] == HUNGRY && shared->state[LEFT] != EATING && shared->state[RIGHT] != EATING)
	{
		//printf("Philosopher: %d (i+N-1)%N - %d", i, ((i+N-1)%N));
		shared->state[arga] = EATING;
		//sleep(2);
		sem_post(&shared->s[arga]); //Up philosopher
	}

}

void think(int arga){
	//printf("I am philosopher %d i am thinking\n", i);
	sleep(2);
}

void eat(int arga){
	//printf("I am philosopher %d i am eating\n", i);
	sleep(3);
}

int parent(void){
	puts("This is the Parent Process");
	int philosopherState;
	char* philprint;
	int count=0;

	while (1){
		sleep(1);
		for(int o = 0; o<N;o++ ){
			philosopherState = shared->state[o];

			 if (philosopherState == 0) {
				 philprint = "Thinking";
			 }else if(philosopherState == 1){
				 philprint = "Eating";
			 }else if(philosopherState == 2){
				 philprint = "Hungry";
			 }else if(philosopherState == 3){
				 philprint = "Gone";
				 count++;
			 }

			 printf("P%d %s \t",o, philprint);

			 if (count >4){
				 break;
			 }
		}
		 printf("\n");
	}
	return 0;
}