#include "Tennis.h"

int main()
{
    int i=0,lan,kb;
    srand((unsigned)time(NULL));
    struct Raq *rq;

    /***** Gestion du terminal *****/
    if (tcgetattr(0,&Term) == -1)
        exit(1);
    SaveTerm = Term;
    Term.c_lflag &= ~(ICANON | ECHO | ISIG);
    Term.c_cc[VMIN] = 1;
    if (tcsetattr(0,TCSANOW,&Term) == -1)
        exit(1);

    /***** Ouverture de la grille de jeu *****/
    if (OuvrirGrille(LIGNE,COLONNE,20) == -1)
    {
        perror("Erreur de InitGrille");
        exit(-1);
    }

    //Armement du signal pour faire monter la raquette:
    sigemptyset(&sigAct.sa_mask);
	sigAct.sa_handler = handlerUp;
	if (sigaction(SIGUSR1,&sigAct,NULL) == -1)
	{
		perror("Err. de signal...\n");
		exit(1);
	}

    //Armement du signal pour faire descendre la raquette:
    sigemptyset(&sigAct2.sa_mask);
    sigAct2.sa_handler = handlerDown;
	if (sigaction(SIGUSR2,&sigAct2,NULL) == -1)
	{
		perror("Err. de signal...\n");
		exit(1);
	}

    //Armement du signal pour arreter le jeu:
	/*sigemptyset(&sigAct.sa_mask);
    sigAct.sa_handler = handlerFin;
    if (sigaction(SIGINT,&sigAct,NULL) == -1)
    {
        perror("Err. de signal...\n");
        exit(1);
    }*/

    LimitesTerrain();
    pthread_mutex_init(&mutexTerrain,NULL);
    pthread_mutex_init(&mutexZone,NULL);
    pthread_cond_init(&condZone,NULL);

    if(pthread_key_create(&cle,NULL)!=0)
    {
        printf("\nErreur de creation de cle...");
        exit(0);
    }

    pthread_create(&threadHandle, NULL, (void*(*)(void*))fctClavier,&kb);

    rq->ligne = 5;
    rq->colonne = 0;
    rq->taille = 5;
    pthread_create(&threadHandle, NULL, (void*(*)(void*))fctRaquette,rq);

    rq->ligne = 5;
    rq->colonne = COLONNE-1;
    rq->taille = 5;
    pthread_create(&threadHandle, NULL, (void*(*)(void*))fctRaquette,rq);

    sigemptyset(&sigAct.sa_mask);
    sigaddset(&sigAct.sa_mask,SIGUSR1);
    sigaddset(&sigAct.sa_mask,SIGUSR2);
    sigprocmask(SIG_SETMASK,&sigAct,&OldsigAct);

    pthread_create(&threadHandle, NULL, (void*(*)(void*))fctLanceur,&lan);

    sleep(30);

    /***** Fermeture de la grille de jeu *****/
    FermerGrille();

    if (tcsetattr(0,TCSANOW,&SaveTerm) == -1)
        exit(1);
    exit(0);
}

/****************************************************************************************/
int LimitesTerrain()
{
    int i,j;

    /***** Murs haut et bas *****/
    for(j=0 ; j<COLONNE ; j++)
    {
        Terrain[0][j] = MUR;
        DessineCarre(0,j,NOIR);
        Terrain[LIGNE-1][j] = MUR;
        DessineCarre(LIGNE-1,j,NOIR);
    }

    /***** Initialisation du terrain *****/
    for(i=1 ; i<(LIGNE-1) ; i++)
        for(j=0 ; j<COLONNE ; j++)
            Terrain[i][j] = VIDE;

    /***** Murs gauche et droit *****/
    /*for(i=1 ; i<(LIGNE-1) ; i++)
    {
        Terrain[i][0] = MUR;
        DessineCarre(i,0,NOIR);
        Terrain[i][COLONNE-1] = MUR;
        DessineCarre(i,COLONNE-1,NOIR);
    }*/

    /***** Zone grise *****/
    for(i=1 ; i<(LIGNE-1) ; i++)
    {
        for(j=IND_ZONE_GAUCHE ; j<IND_ZONE_DROITE ; j++)
        {
            Terrain[i][j] = ZONE;
            DessineCarre(i,j,GRIS);
        }
    }

    return 0;
}

/****************************************************************************************/
int ReadChar()
{
    char ChLu;

    fflush(stdin);

    if (read(0,&ChLu,1) != 1)
        return -1;
    if (ChLu == Term.c_cc[VINTR])
        return 3;
    return ChLu;
}

/****************************************************************************************/
void * fctBalle(struct Balle *b)
{
    int prec;
    struct timespec time;
    time.tv_sec = 0;
    time.tv_nsec = 200000000;

    while(1)
    {
        pthread_mutex_lock(&mutexTerrain);

        //Sauvegarde de l'emplacement pour restitution:
        prec = Terrain[b->ligne][b->colonne];

        if(b->dir == GAUCHE && (Terrain[b->ligne][b->colonne-1] == BALLE || Terrain[b->ligne][b->colonne-1] == RAQUETTE))
            b->dir = DROITE;
        if(b->dir == DROITE && (Terrain[b->ligne][b->colonne+1] == BALLE || Terrain[b->ligne][b->colonne+1] == RAQUETTE))
            b->dir = GAUCHE;
        if(Terrain[b->ligne][b->colonne] == ZONE)
            zone_limite(b);

        //Affichage de la balle à l'endroit qui lui a été désigné:
        Terrain[b->ligne][b->colonne] = BALLE;
        DessineCarre(b->ligne,b->colonne,b->couleur);
        pthread_mutex_unlock(&mutexTerrain);

        nanosleep(&time,NULL);

        pthread_mutex_lock(&mutexTerrain);

        //Restitution de ce qui se trouvait à l'emplacement de la balle avant celle-ci:
        restitution(b,prec);
        balle_cote(b);
        pthread_mutex_unlock(&mutexTerrain);
        if(b->colonne>COLONNE||b->colonne<0)
            pthread_exit(1);
    }
}

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

void * fctLanceur()
{
    struct Balle *b;
    struct timespec time;
    time.tv_sec = 1;
    time.tv_nsec = 0;
    int i=0,j=0;

    while(1)
    {
        b = (struct Balle *) malloc (sizeof(struct Balle));

        do
        {
            //b->ligne = 10;
            b->ligne = rand()%13 + 1;
            b->colonne = rand()%28 + 1;
        }while(Terrain[b->ligne][b->colonne] == BALLE || Terrain[b->ligne][b->colonne] == ZONE);
        do
            b->couleur = rand()%10;
        while(b->couleur == BLANC || b->couleur == NOIR || b->couleur == GRIS);
        b->dir = rand()%2;

        pthread_create(&threadHandle, NULL, (void*(*)(void*))fctBalle,b);

        i++;

        nanosleep(&time,NULL);
    }
    printf("\n\n");
    for(i=0;i<15;i++)
    {
        for(j=0;j<30;j++)
        {
            printf("%d",Terrain[i][j]);
        }
        printf("\n");
    }
}

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

void * zone_limite(struct Balle *b)
{
    //Blocage de l'accès à la zone grise:
    pthread_mutex_lock(&mutexZone);
    while(NbrBallesZone == NBMAX_BALLES_ZONE)
    {
        if(b->dir == GAUCHE)
            DessineCarre(b->ligne,b->colonne+1,b->couleur);
        else
            DessineCarre(b->ligne,b->colonne-1,b->couleur);

        pthread_mutex_unlock(&mutexTerrain);
        pthread_cond_wait(&condZone,&mutexZone);
        pthread_mutex_lock(&mutexTerrain);

        if(b->dir == GAUCHE)
           DessineCarre(b->ligne,b->colonne+1,BLANC);
        else
           DessineCarre(b->ligne,b->colonne-1,BLANC);
    }
    NbrBallesZone++;

    pthread_mutex_unlock(&mutexZone);
}

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

void * restitution(struct Balle *b,int prec)
{
    Terrain[b->ligne][b->colonne] = prec;
    if(prec == ZONE)
    {
        pthread_mutex_lock(&mutexZone);
        DessineCarre(b->ligne,b->colonne,GRIS);
        NbrBallesZone--;
        pthread_mutex_unlock(&mutexZone);
        pthread_cond_signal(&condZone);
    }
    else
        DessineCarre(b->ligne,b->colonne,BLANC);
}

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

void * balle_cote(struct Balle *b)
{
    if(b->dir == GAUCHE)
    {
        if(Terrain[b->ligne][b->colonne-1] == BALLE||Terrain[b->ligne][b->colonne-1] == RAQUETTE)
        {
            b->dir = DROITE;
            b->colonne++;
        }
        else
            b->colonne--;
    }
    else
    {
        if(Terrain[b->ligne][b->colonne+1] == BALLE||Terrain[b->ligne][b->colonne+1] == RAQUETTE)
        {
            b->dir = GAUCHE;
            b->colonne--;
        }
        else
            b->colonne++;
    }
}

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

void * fctClavier()
{
    while(1)
    {
        switch(ReadChar())
        {
            case 'a': kill(getpid(),SIGUSR1);
                          break;
            case 'q': kill(getpid(),SIGUSR2);
                          break;
            case 'p': kill(getpid(),SIGUSR1);
                          break;
            case 'm':kill(getpid(),SIGUSR2);
                          break;
            case 'x': printf("x\n");
                          break;
        }
    }
}

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

void * fctRaquette(struct Raq *p)
{
    int i,j,ligne,colonne,taille,raq;
    /***** Raquette gauche et droit *****/
    for(i=5 ; i<(LIGNE-5) ; i++)
    {
        Terrain[i][0] = RAQUETTE;
        DessineCarre(i,0,NOIR);
        Terrain[i][COLONNE-1] = RAQUETTE;
        DessineCarre(i,COLONNE-1,NOIR);
    }

         if(pthread_setspecific(cle,p)!=0)
    {
        printf("\nErreur de sauvegarde de la donnee specifique...");
        exit(0);
    }
}

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

void handlerDown(int sig)
{
    struct Raq *p;
    printf("handlerDown\n");

    if((p = (struct Raq *) pthread_getspecific(cle)) == NULL)
    {
        printf("\nErreur de getspecific...\n");
        exit(0);
    }
    printf("\nligne: %d , colonne: %d , taille : %d\n",p->ligne,p->colonne,p->taille);
}

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

void handlerUp(int sig)
{
    printf("\nhandlerUp");
}

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

void handlerFin(int sig)
{
    printf("\nhandlerFin");
}