/*
    Allocare una matrice dinamicamente di dimensione NxN dove n è un numero pari,
    inserito come input al programma ( argv ). Riempire la matrice con numeri casuali.
    Lanciare N thread che esaminano ognuno una riga delle N righe della matrice,
    prelevano un elemento casuale dalla loro riga di competenza, e lo inseriscono in
    un vettore di dimensione (N^2) /2. Al termine del riempimento di questo vettore
    viene risvegliato un thread n+1esimo che stampa il numero di elementi inseriti
    nel vettore da ogni thread e gli elementi inseriti nel vettore da ogni thread.
    Usare semafori con memoria e variabili di condizione.
*/

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <sys/types.h>
#include <semaphore.h>

void *riempitore(void *arg), *conteggiatore(void *arg);
int **matrice;
int n;

struct
{   pthread_mutex_t mutex;
    int cont;
    int *vector;
    sem_t sem1,sem2;

    pthread_cond_t cond;

} bobby = {PTHREAD_MUTEX_INITIALIZER,0};

int size_vettore;

int main(int arg, char **argv) {

    n = atoi(argv[1]);
    int i,j;
    int *riga[n];
    pthread_t p_tids[n+1];

    size_vettore = (n*n)/2;
    printf("size vettore %d\n",size_vettore);

    bobby.vector = malloc(size_vettore*sizeof(int));

    sem_init(&bobby.sem1,0,1);
    sem_init(&bobby.sem2,0,0);

    if(arg != 2) { printf("usage:./program n\n"); exit(0);}
    if((n % 2) != 0) { printf("Errore: n deve essere pari."); exit(0);}

    matrice = (int**) malloc(n*sizeof(int *));

    for (i=0;i<n;i++) {
        matrice[i] = (int *) malloc(n*sizeof(int *));
    }
    for(j=0;j<n;j++) {
        for(i=0;i<n;i++)
            matrice[j][i] = rand() % 10;
    }

    for(j=0;j<n;j++) {
        for(i=0;i<n;i++)
            printf("|%d",matrice[j][i]);
        printf("\n");
    }
    for(i=0;i<n;i++) {

        riga[i] = (int *)malloc(sizeof(int));
        *riga[i] = i;

        pthread_create(&p_tids[i],NULL,riempitore,(void *) riga[i]);
    }
    pthread_create(&p_tids[n],NULL,conteggiatore,NULL);

    for(i=0;i<n;i++) {
        pthread_join(p_tids[i],NULL);
    }
    pthread_join(p_tids[n],NULL);

    sem_destroy(&bobby.sem1);
    sem_destroy(&bobby.sem2);
    pthread_exit(NULL);

}
void *riempitore(void *riga) {
    int * myoff,myvoff,value_sem;
    myoff = (int *) riga;
    myvoff = *myoff;
    int value;
    int i,n_casuale,random = rand() % n;

    for(;;) {
    n_casuale = matrice[myvoff][random];


    sem_wait(&bobby.sem1);
        sem_getvalue(&bobby.sem1,&value_sem);
        printf("Sono il thread %d\n sem = %d\n",myvoff,value_sem);
        printf("Sto inserendo l'elemento %d\n",n_casuale);

        if(bobby.cont >= size_vettore) {
            printf("verificata");
            pthread_cond_signal(&bobby.cond);
                sem_wait(&bobby.sem2);
        }



        bobby.vector[bobby.cont] = n_casuale;
        printf("ho inserito bobby.vector[%d] = %d",bobby.cont, bobby.vector[bobby.cont]);
        bobby.cont++;
        printf(" cont=%d\n",bobby.cont);

    sem_post(&bobby.sem1);
    }

    pthread_exit(0);
}
void *conteggiatore(void *arg) {
    int sum=0,i;
    for(; ;) {
    pthread_mutex_lock(&bobby.mutex);
        printf("\npartito il conteggiatore\n");
        while(bobby.cont < size_vettore)
            pthread_cond_wait(&bobby.cond, &bobby.mutex);

        for(i=0;i<size_vettore;i++) {
            sum += bobby.vector[i];

        }
        bobby.cont = 0;

    pthread_mutex_unlock(&bobby.mutex);
    sem_post(&bobby.sem2); }
}