#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#define NUM_PROVAS 5
#define MAX_GRADE 100
#define NUM_THREADS 5

typedef struct {
    int number;
    int notaG1;
    int notaG2;
    int notaG3;
    int notaFinal;
} Prova;

Prova arrayProva[NUM_PROVAS];
int numProvas;

int numPos;
int numNeg;

int flag;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t mutexInc = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t condCreate = PTHREAD_COND_INITIALIZER;
pthread_cond_t condCalculate = PTHREAD_COND_INITIALIZER;
pthread_cond_t condPos = PTHREAD_COND_INITIALIZER;
pthread_cond_t condNeg = PTHREAD_COND_INITIALIZER;

void *insertProvas(void *arg) {

    time_t t;
    srand ((unsigned) time (&t));

    int i;
    for (i = 0; i < NUM_PROVAS; i++) {

        Prova prova;
        prova.number = rand() % 1000 + 1;
        prova.notaG1 = rand() % MAX_GRADE + 1;
        prova.notaG2 = rand() % MAX_GRADE + 1;
        prova.notaG3 = rand() % MAX_GRADE + 1;

        arrayProva[i] = prova;

        pthread_mutex_lock(&mutex);
        numProvas++;

        printf("Cria: %d\n", numProvas - 1);

		flag = 1;
        pthread_cond_broadcast(&condCalculate);
        printf("Calculate Start\n");

        pthread_mutex_unlock(&mutex);

        pthread_mutex_lock(&mutex);

		pthread_cond_wait(&condCreate, &mutex);

        pthread_mutex_unlock(&mutex);
	}

	pthread_mutex_lock(&mutex);

	flag = 1;
	numProvas++;
	pthread_cond_broadcast(&condCalculate);

	pthread_mutex_unlock(&mutex);

	printf("Cria termina!\n");
    pthread_exit(NULL);

}

void *calculateFinalNote(void *arg) {

    while (1) {

        pthread_mutex_lock(&mutex);

        printf("Calculate Wait\n");
        while (flag == 0) {
			pthread_cond_wait(&condCalculate, &mutex);
		}

        int index = numProvas - 1;

		if (index == NUM_PROVAS) {
            printf("Calculate finished!\n");

            pthread_cond_signal(&condCalculate);
            pthread_mutex_unlock(&mutex);

            pthread_exit(NULL);
        }
		printf("Create Start\n");

		flag = 0;

        pthread_mutex_unlock(&mutex);

        printf("Calcula: %d\n", index);

        arrayProva[index].notaFinal = (arrayProva[index].notaG1 + arrayProva[index].notaG2 + arrayProva[index].notaG3) / 3;

        pthread_mutex_lock(&mutexInc);

        if (arrayProva[index].notaFinal < 50) {
			printf("Incrementa prova negativa\n");
			pthread_cond_signal(&condNeg);
		} else {
			printf("Incrementa prova positiva\n");
			pthread_cond_signal(&condPos);
		}

		pthread_mutex_unlock(&mutexInc);

        pthread_mutex_lock(&mutex);

        pthread_cond_signal(&condCreate);

        pthread_mutex_unlock(&mutex);

    }

    pthread_exit(NULL);

}

void *incrementProvasPos(void *arg) {

	while (1) {
		pthread_mutex_lock(&mutexInc);

		pthread_cond_wait(&condPos, &mutexInc);

		numPos++;
		if (numPos + numNeg == NUM_PROVAS) {
			pthread_exit(NULL);
		}

		pthread_mutex_unlock(&mutexInc);
	}

	pthread_exit(NULL);

}

void *incrementProvasNeg(void *arg) {

	while (1) {
		pthread_mutex_lock(&mutexInc);

		pthread_cond_wait(&condNeg, &mutexInc);

		numNeg++;
		if (numPos + numNeg == NUM_PROVAS) {
			pthread_exit(NULL);
		}

		pthread_mutex_unlock(&mutexInc);
	}

	pthread_exit(NULL);

}

int main() {

    numProvas = 0;

    numPos = 0;
    numNeg = 0;

    pthread_t threads[NUM_THREADS];

    int i;
    for (i = 2; i < 4; i++) {
        if (pthread_create(&threads[i], NULL, calculateFinalNote, NULL) != 0) {
            printf("Erro no pthread_create()!\n");
            exit(1);
        }
    }

    if (pthread_create(&threads[0], NULL, incrementProvasPos, NULL) != 0) {
        printf("Erro no pthread_create()!\n");
        exit(1);
    }

    if (pthread_create(&threads[1], NULL, incrementProvasNeg, NULL) != 0) {
        printf("Erro no pthread_create()!\n");
        exit(1);
    }

    if (pthread_create(&threads[4], NULL, insertProvas, NULL) != 0) {
        printf("Erro no pthread_create()!\n");
        exit(1);
    }

    for (i = 2; i < NUM_THREADS; i++) {
        if(pthread_join(threads[i], NULL) != 0){
            perror("Erro a terminar thread...");
            exit(1);
        }
    }

	for (i = 0; i < NUM_PROVAS; i++) {
        printf("Aluno: %d  Nota G1: %d  Nota G2: %d  Nota G3: %d  Nota Final: %d\n", arrayProva[i].number, arrayProva[i].notaG1, arrayProva[i].notaG2, arrayProva[i].notaG3, arrayProva[i].notaFinal);
    }

	printf("Provas positivas: %d\nProvas Negativas: %d\n", numPos, numNeg);

    return 0;
}