/*****************************************************************

    pour compiler   ==> gcc -pthread prog.c -o prog
    ou      ==> gcc prog.c -o prog -lpthread

    Stevens Gagnon
    Departement Informatique
    College Shawinigan


******************************************************************/

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


//++++++++++++++++++++++++++++++++++++
pthread_mutex_t startThread;
pthread_mutex_t ecriture;
//++++++++++++++++++++++++++++++++++++

int nombreRestant = 0;
int nombreTotalDePrime = 0;
//------------------------------------------------------------------

void initPremierTXT() //On initialise le fichier texte vide
{
    FILE *fp;
    fp = fopen("./text/premier.txt","w");
    fclose(fp);
}

void ecrirePremier(int nombre) //On écrit dans le fichier Premier.txt
{
    FILE *fp;
    fp = fopen("./text/premier.txt","a");
    fprintf(fp,"%d\n",nombre);
    fclose(fp);
}


int demanderNombre() //Fonction : On demande le nombre à l'usager
{
    int nombre;
    printf("\n Entrez un nombre qui se divise par 3000: ");
    scanf("%d",&nombre);
    return nombre;
}

int reduireNombreRestant() //Pour savoir dans quelle tranche on est rendu.
{                          // Exemple: if nombreRestant == 12000, alors on sait où on est
    if(nombreRestant > 0)
    nombreRestant -= 3000;
    return nombreRestant;
}

int isPrime(int nombre)
{
    int i, flag = 0;
    for (i = 2; i <= nombre / 2; ++i) {
        // condition for non-prime
        if (nombre % i == 0) {
            flag = 1;
            break;
        }
    }

    if (flag == 0)
    {
        return 1; //Retourne 1 si c'est un prime number
    }
    else
    {
        return 0; //Retourne 0 si ce n'est pas un prime number
    }


    printf("\n");
}

int QteDePrime(int nombre, int minimum, int maximum)
{
    printf("\n-----------------------------------------------------------------\n");
    printf("[Pthread: %lu] J'ai trouvé %d nombres premiers dans la page %d à %d",(unsigned long)pthread_self(),nombre,minimum,maximum);
    printf("\n-----------------------------------------------------------------\n");
    nombreTotalDePrime += nombre;
}

void FunctionPthread (int *leNombreTotal)
{
    int nombreTotal = *leNombreTotal;
    int i; //on va prendre en compte min et max ici pour l'affichage de QtePrime
    int numberToStartFrom = nombreTotal; //Juste pour rentrer dans la boucle
    int count = 0; //(servira à compter le nombre de primenumbers)
    int min = nombreTotal - 2999;
    int max = nombreTotal;
    reduireNombreRestant(); //Met à jour le NombreRestant
    pthread_mutex_unlock(&startThread);
    if(nombreTotal >= 3000) //On rentre seulement si le nombre de base est plus haut ou egal que 3000, sinon c'est pas une tranche acceptable.
    {
        while(numberToStartFrom > 0) //Tant qu'on pogne pas zero comme minimum, on continue
        {
            numberToStartFrom = nombreTotal - 2999; //On pogne la nouvelle valeur 12000 et fait -2999 = 9001
            for(i = numberToStartFrom;i < nombreTotal;i++) //numberToStartFrom = minimum range
            {                                              // nombreTotal = Maximum range
                if(isPrime(i))
                {
                    pthread_mutex_lock(&ecriture);
                    if(i>1)
                    {
                    ecrirePremier(i); //ZONE CRITIQUE
                    count++; // ZONE CRITIQUE
                    }

                    pthread_mutex_unlock(&ecriture);

                }
            }
            numberToStartFrom = 0; //On sort de la boucle.
        QteDePrime(count,min,max); //***MANQUE A RAJOUTER L'IDENTIFICATION DU PTHREAD *** Affichage seulement de qte de prime et dans quelle plage.
        }
    }
}




int main(void)
{
    initPremierTXT(); //On fait la fonction qui crée le fichier vide
    int i = 0;
    int nombre = demanderNombre(); //On demande le nombre à l'usager
    nombreRestant = nombre;
    int totalToDivide = nombre/3000; //On trouve ici le nombre de fois qu'on doit partir un thread (un thread par tranche de 3000)


//++++++++++++++++++++++++++++++++++++//++++++++++++++++++++++++++++++++++++
    pthread_mutex_init(&startThread, NULL); //INITALISE LE MUTEX AVEC LADRESSE COPIE
    pthread_mutex_init(&ecriture, NULL); //INITALISE LE MUTEX AVEC LADRESSE COPIE
    pthread_t thread; // ON CRÉE UN THREAD
    pthread_t list_thread[totalToDivide];    // ON CRÉE UN TABLEAU DE THREADS (POUR EN AVOIR PLUSIEURS)
//++++++++++++++++++++++++++++++++++++//++++++++++++++++++++++++++++++++++++



    for(i = 0; i < totalToDivide;i++) // la boucle qui contient le start d'un thread par tranche de 3000
    {
        printf("\n-----------------------------\n");
        printf("--%i - On start un Pthread--",i+1);
        printf("\n-----------------------------\n");
//++++++++++++++++++++++++++++++++++++//++++++++++++++++++++++++++++++++++++
        pthread_mutex_lock(&startThread);

        if(pthread_create(&thread, NULL, (void*)&FunctionPthread, &nombreRestant))   //////////////ON ENVOIT LE THREAD avec l'adresse de la fonction et l'adresse de la variable demo
        {
            printf("Probleme pthread_create\n");
            pthread_mutex_unlock(&startThread);

        }
        else
        {
            list_thread[i] = thread; // SI ça LA MARCHÉ AVANT, ON MET LE THREAD DANS LA CASE DU TABLEAU à l'endroit "DEMO"
        }
//++++++++++++++++++++++++++++++++++++//++++++++++++++++++++++++++++++++++++
        //FunctionPthread (nombreRestant);
        //reduireNombreRestant(); //Met à jour le NombreRestant
    }




        for(i = 0; i < totalToDivide;i++)     // BOUCLE POUR VENIR ATTENDRE SUR LE THREAD
        {
            thread = list_thread[i];   // ON ASSIGNE A LA VARIABLE THREAD, LE THREAD A LA CASE DU TABLEAU EN COURS
            if(pthread_join(thread, NULL))  // ON VIENT ATTENDRE SUR LE THREAD EN QUESTION, QUAND C'EST FINI LA BOUCLE CONTINU ET ON POGNE LE PROCHAIN.
            {
                printf("Probleme pthread_join\n");
            }
            else
            {

            }
        }






    printf("\n By the way... Il y a %d primes de trouvés en tout\n",nombreTotalDePrime);
}

//------------------------------------------------------------------