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

/// Processus legers

#define TAILLE 8 /// Multiple de 4 !!!!

int SOMME;  /// Variable GLOBALE en mutex (somme totale)
int NOMBRE; /// Variable GLOBALE en mutex (nbre de reponses)
int sommeFinale[4] = {-1}; /// Variable GLOBALE pour les sous-tableau

pthread_mutex_t mutexSomme = PTHREAD_MUTEX_INITIALIZER; /// mutex

typedef struct TF
{
    int numero;
    int *tabAdresse;
    int tabNombre;
} tabParams;

void initTabAleat (int *leTableau, int leNombre);
/// Initialise <leTableau> de <leNombre> elements
/// de façon aleatoire avec des nombres tous differents.

int sommeTab (int *leTableau, int leNombre);
/// retourne la somme des <leNombre> elements de <leTableau>.

void afficheTableau (int leTableau [], int leNombre);
/// Affiche <leTableau> de <leNombre> elements sur la sortie standard.

void initTabAleat (int leTableau [], int leNombre)
{
    int i;
    int min = 0;
    srand (time (NULL));

    for (i=0; i<leNombre; i++)
    {
        leTableau [i] = (rand() % (leNombre - min + 1));
    }
}

int sommeTab (int leTableau [], int leNombre)
{
    int i, somme = 0;
    for(i=0 ; i < leNombre ; i++)
    {
        somme = somme + leTableau[i];
    }
    return somme;
}

void afficheTableau (int leTableau [], int leNombre)
{
    int i;
    printf ("\n==> tableau : ");
    for (i=0; i <leNombre; i++)
        printf ("%d ",  leTableau[i]);
    printf ("\n\n");
}

void ajouterGlob (int unNombre)
{
    pthread_mutex_lock (&mutexSomme);
    SOMME = SOMME + unNombre;
    NOMBRE++;
    pthread_mutex_unlock (&mutexSomme);
}

int threadFonction (tabParams *param)
{
    int local;
    printf ("Lancement threadFonction ...\n");
    local = sommeTab (param->tabAdresse, param->tabNombre);

    sommeFinale [param->numero] = local;
    ajouterGlob (local);

    return local;
}

int main()
{
    int i;
    int * grandTableau;
    pthread_t tache[4];
    tabParams *localParam;

    SOMME = 0;
    NOMBRE = 0;

    grandTableau = malloc (sizeof(int) * TAILLE);

    initTabAleat (grandTableau, TAILLE);
    afficheTableau(grandTableau, TAILLE);

    for (i=0; i<4; i++)
    {
        localParam = malloc (sizeof (tabParams));
        localParam->numero = i;
        localParam->tabAdresse = grandTableau + (i * TAILLE / 4);
        localParam->tabNombre = TAILLE / 4;
        pthread_create(&tache[i], NULL, (void*(*)(void*)) threadFonction,
                       localParam);
    }
    /// Version 1 : avec pthread_join
    pthread_join (tache[0], NULL); pthread_join (tache[1], NULL);
    pthread_join (tache[2], NULL); pthread_join (tache[3], NULL);
    printf ("\nVERSION 1 : OK !\n");

    /// Version 2 : attente du remplissage de sommeFinale []
    while ( sommeFinale [0] == 0 || sommeFinale [1] == 0 ||
    sommeFinale [2] == 0 || sommeFinale [3] == 0 );
    printf ("VERSION 2 : OK !\n");

    /// Version 3 : attente de NOMBRE == 4
    while ( NOMBRE != 4);
    printf ("VERSION 3 : OK !\n");

    /// Affichage toutes versions ...
    SOMME = sommeFinale [0] + sommeFinale [1] +
            sommeFinale [2] + sommeFinale [3] ;

    printf ( "\nSOMME : %d = %d + %d + %d + %d\n", SOMME, sommeFinale [0],
             sommeFinale [1],sommeFinale [2], sommeFinale [3]);

    return 0;
}