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

typedef struct {
    int idx;
    pthread_mutex_t *m;
    int *p;
} data;

typedef struct {
    int idx, nr_1, nr_2;
} response;

void *func(void *arg) {
    data d = *((data*) arg);
    int nr_1 = random() % 101;
    int nr_2 = random() % 101;
    response r;
    r.idx = d.idx;
    r.nr_1 = nr_1;
    r.nr_2 = nr_2;
    printf("Thread %d has generated %d and %d\n", d.idx, nr_1, nr_2);
    pthread_mutex_lock(d.m);
    if(0 > write(d.p[1], &r, sizeof(response))) {
        perror("Error sending data");
    }
    pthread_mutex_unlock(d.m);
    return NULL;
}

int main(int argc, char *argv[]) {
    if (argc < 2) {
        printf("Please provide an integer argument\n");
        exit(1);
    }
    int p[2];
    if (0 > pipe(p)) {
        perror("Error creating pipe: ");
        exit(1);
    }
    int n = atoi(argv[1]);
    int f = fork();
    if (0 > f) {
        perror("Oh no, my child!");
        exit(1);
    } else if (0 == f) {
        close(p[1]);
        int i;
        for (i = 0; i < n; i++) {
            response r;
            if(0 > read(p[0], &r, sizeof(response))) {
                perror("Error reading data");
            }
            printf("Thread %d - average: %f\n", r.idx, (double)(r.nr_1 + r.nr_2) / 2);
        }
        close(p[0]);
        exit(0);
    } else {
        close(p[0]);
        int i;
        pthread_mutex_t *m = malloc(sizeof(pthread_mutex_t));
        pthread_mutex_init(m, NULL);
        data *args = malloc(sizeof(data) * n);
        pthread_t *T = malloc(sizeof(pthread_t) * n);
        for (i = 0; i < n; i++) {
            args[i].idx = i;
            args[i].m = m;
            args[i].p = p;
            if (0 != pthread_create(&T[i], NULL, func, (void *) &args[i])) {
                perror("Error creating thread: ");
                close(p[1]);
                wait(0);
                free(args);
                free(T);
                free(m);
                exit(1);
            }
        }

        for (i = 0; i < n; i++) {
            pthread_join(T[i], NULL);
        }
        close(p[1]);
        wait(0);
        free(args);
        free(T);
        free(m);
    }
    return 0;
}