#define _GNU_SOURCE
#ifdef _GNU_SOURCE
# undef _ISOC99_SOURCE
# define _ISOC99_SOURCE 1
# undef _POSIX_SOURCE
# define _POSIX_SOURCE 1
# undef _POSIX_C_SOURCE
# define _POSIX_C_SOURCE 200112L
# undef _XOPEN_SOURCE
# define _XOPEN_SOURCE 600
# undef _XOPEN_SOURCE_EXTENDED
# define _XOPEN_SOURCE_EXTENDED 1
# undef _LARGEFILE64_SOURCE
# define _LARGEFILE64_SOURCE 1
# undef _BSD_SOURCE
# define _BSD_SOURCE 1
# undef _SVID_SOURCE
# define _SVID_SOURCE 1
# undef _ATFILE_SOURCE
# define _ATFILE_SOURCE 1
#endif


#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

#include <ecran.h>

#include <sys/types.h>
#include <pthread.h>
#include <sys/ipc.h>


/* creation mutex  */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

aire_t * A  = NULL ;
//err_t cr = OK ;
ecran_t * ecran  = NULL ;
//char mess[ECRAN_LG_MESS] ;

booleen_t fini = FAUX ;
int b=0;

static void arret( int sig ){
  static int cpt = 0 ;
  cpt++ ;
  switch( cpt ){
    case 1 : break ;
    case 2 : break ;
    case 3 : fini = VRAI ;
             break ;
    default :break  ;
  }
  return ;
}


/* utilise le même objet bille !!!! ATTENTION */
void traitement_bille(void * arg){
  err_t cr = OK ;
  bille_t * bille = NULL;
  char mess[ECRAN_LG_MESS] ;

  //aire_afficher(A) ;

  pthread_mutex_lock(&mutex);
  /* creation bille  */
  if( ( bille = bille_creer( direction_random() , rand()%BILLE_VITESSE_MAX , COORD_NULL , '*' ) ) == BILLE_NULL ){
    sprintf( mess , "Pb creation bille bille %d\n" , b );
    fprintf(stderr, "probleme creation bille\n" );
    ecran_message_pause_afficher( ecran , mess  ) ;
    exit(-1) ;
  }

  /* fin creation bille */

  /* pose d'une bille sur l'air */
  sprintf( mess , "Positionnement de la bille %d\n" , b ) ;
  ecran_message_afficher( ecran , mess ) ;
  if( ( cr = aire_bille_positionner( A , bille ) ) ){
    sprintf( mess , "Pb lors du positionnement de la bille %d" , b ) ;
    fprintf(stderr, "probleme positionnement bille\n" );
    ecran_message_pause_afficher( ecran , mess ) ;
    erreur_afficher(cr) ;
    ecran_stderr_afficher(ecran) ;
    exit(-1) ;
  }
  /*fin pose d'une bille*/

  /* pose d'une bille sur l'ecran */
  sprintf( mess , "Pose de la bille %d\n" , b ) ;
  ecran_message_afficher( ecran , mess ) ;
  if( ( cr = ecran_bille_poser( ecran , A , bille ) ) ){
    sprintf( mess , "Pb lors de la pose de la bille %d" , b ) ;


    ecran_message_pause_afficher( ecran , mess ) ;
    erreur_afficher(cr) ;
    ecran_stderr_afficher(ecran) ;
    exit(-1) ;
  }
  pthread_mutex_unlock(&mutex);

  while( ! aire_vide(A) ){
    /* Deplacement d'une bille */

    //sprintf( mess , "Deplacement %d" , b ) ;
    //ecran_message_afficher( ecran , mess ) ;
    pthread_mutex_lock(&mutex);
    if( ecran_bille_deplacer( ecran , A, bille ) ){
      sprintf( mess ,  "Pb lors du deplacement de la bille %d", b ) ;
      ecran_message_pause_afficher( ecran , mess ) ;
      ecran_stderr_afficher( ecran ) ;
    }
    pthread_mutex_unlock(&mutex);
    if( bille_active(bille) ){
        /* Arret sur image de ce mouvement pendant une duree inversement proportionnelle a sa vitesse */
        ecran_bille_temporiser(bille) ;
      }
    else{
        pthread_mutex_lock(&mutex);

        /* Desintegration de la bille */
        sprintf( mess , "Desintegration de la bille %d" , b ) ;
        ecran_message_afficher( ecran , mess ) ;
        ecran_bille_desintegrer( ecran , bille ) ;

        /* On enleve cete bille de l'aire */
      if( aire_bille_detruire( A , &bille ) ){
        sprintf( mess , "Pb lors de la destruction de la bille %d", b ) ;
        fprintf(stderr, "probleme dest bille\n" );
        ecran_message_pause_afficher( ecran , mess ) ;
        ecran_stderr_afficher( ecran ) ;
      }
      pthread_mutex_unlock(&mutex);

    }
  }
}




int main( int argc , char * argv[] ){

  int nb_bille=0;

  signal( SIGINT , arret ) ;

  printf("\n\n\n\t===========Debut %s==========\n\n" , argv[0] );

  if( argc != 4 ){
      printf( " Programme de test sur l'affichage de l'aire avec plusieurs billes\n" );
      printf( " usage : %s <Hauteur de l'aire> <Largeur de l'aire> <nb billes>\n" , argv[0] );
      exit(0);
  }

  int Hauteur  = atoi( argv[1] ) ;
  int Largeur  = atoi( argv[2] ) ;
  int NbBilles = atoi( argv[3] ) ;
  printf( " \nTest sur une aire de %dX%d et %d billes\n" , Hauteur , Largeur , NbBilles );


  /*--- Thread ----*/

  int inc;

  pthread_attr_t attr;
  pthread_t thread_id[NbBilles];
    //traitement_bille(ecran,A,mess);bBilles];

  pthread_attr_init(&attr);
  pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);

  pthread_setconcurrency(NbBilles);


  /*----Fin thread -----*/


  srand( getpid() ) ;

  /* Creation et affichage de l'aire */
  printf("Creation de l'aire %dX%d\n" , Hauteur , Largeur ) ;
  if( ( A = aire_creer( Hauteur , Largeur ) ) == AIRE_NULL ){
      printf("Pb creation aire\n");
      exit(-1) ;
  }

  aire_afficher(A) ;

  /* Creation et affichage de l'ecran */
  if( ( ecran = ecran_creer(A) ) == ECRAN_NULL ){
      printf("Pb creation ecran\n");
      exit(-1) ;
  }


  /* debut execution thread */

  for(inc=0;inc<NbBilles;inc++){
      if(pthread_create(&thread_id[inc],&attr,(void *)traitement_bille,(void *)NULL)!=0){
        fprintf(stderr, "probleme creation thread !\n");
      }
  }

    //traitement_bille(ecran,A,mess);
  /* fin execution thread */

  /* attente terminaison fils */

  for(inc=0;inc<NbBilles;inc++){
    pthread_join(thread_id[inc],NULL);
  }

  /* fin attente terminaison fils */

  //ecran_afficher(  ecran , A )  ;
  ecran_message_afficher( ecran , "Envoyez un signal pour continuer" ) ;
  pause() ;

  ecran_message_pause_afficher( ecran , "Arret" ) ;

  ecran_message_pause_afficher( ecran , "Destruction de la structure ecran" ) ;
  ecran_detruire(&ecran)  ;

  printf("\nDestruction aire\n" ) ;
  aire_detruire( &A)  ;


  /* destruction mutex  */
  printf("\nDestruction mutex\n" ) ;
  pthread_mutex_destroy(&mutex);

  printf("\n\n\t===========Fin %s==========\n\n" , argv[0] );

  return(0) ;
}