#include <libusb-1.0/libusb.h>
  #include <stdio.h>
  #include <stdlib.h>
  
  /* Caractéristiques du périphérique */
  #define VENDOR_ID		0x2341
  #define PRODUCT_ID		0x0001
  #define TAB_PA_SIZE		10
  
  libusb_device_handle *handle=NULL;
  libusb_device *device=NULL;
  libusb_device *found=NULL; //notre périphérique
  libusb_context *context;
  
  /*
  struct TABLEAU{
  	struct EP *tableau[3]; //tableau des points d'accès en interruption
  	int dernier;
  };
  
  struct EP {
      uint8_t ep; 				//adresse d'accès de l'endpoint
      unsigned char io;   //décrit si c'est une entrée ou une sortie
  };
  
  //init structure tableau
  struct TABLEAU tab_pa;
  
  void init_tableau(){
      for (int i=0;i<3;i++){        
      tab_pa.tableau[i]=NULL;
      }
      tab_pa.dernier=0;
  }
  */
  
  /*énumération des périphériques USB*/
  void enum_periph(){
      libusb_device **list;
      
      /* On compte le nombre de périphérique connectés... */
      ssize_t count=libusb_get_device_list(context,&list);
      if(count<0) {perror("libusb_get_device_list"); exit(-1);}
      ssize_t i=0;
      
      /* et on en établit la liste complète */
      for(i=0;i<count;i++){
          libusb_device *device=list[i];      //enregistre l'appareil i dans la liste list
          struct libusb_device_descriptor desc;
          int status=libusb_get_device_descriptor(device,&desc);      //enregistre le descripteur d'appareil
          if(status!=0) continue;
          
          /* On capture et affiche les numéros de bus et d'addresse */
          uint8_t bus=libusb_get_bus_number(device);
          uint8_t address=libusb_get_device_address(device);
          printf("Device Found @ (Bus:Address) %d:%d\n",bus,address);
          printf("Vendor ID 0x0%x\n",desc.idVendor);

          printf("Product ID 0x0%x\n\n",desc.idProduct);

          
          /* Recherche de notre périphérique et sauvegarde dans 'found' */
          if(desc.idVendor == VENDOR_ID && desc.idProduct == PRODUCT_ID){
          	found = device;
          	printf("\nPériphérique trouvé @ (Bus:Adresse) %d:%d\n", bus, address);     //test si le "found" reste le meme
          	break;
          }
      }
      if (found == NULL) printf("Périphérique non trouvé\n");
      libusb_free_device_list(list,1);
  }
  
  
  void config_periph(char tab_PA[TAB_PA_SIZE]){
  
  	/* Récupération de la 1ère configuration du périphérique (indice 0) */
      struct libusb_config_descriptor *config_desc=NULL;
      int status = libusb_get_config_descriptor(found,0,&config_desc); //config d'indice 0

      printf("La valeur de la configuration d'indice 0 est %d\n",config_desc->bConfigurationValue);

      
      int interface;
      
      /* Si le noyau est passé avant nous,
          On le détache pour chaque alternative d'interface numéro 0 */
      for(int indice_intf=0;indice_intf < config_desc->bNumInterfaces ;indice_intf++){        
          
          interface=config_desc->interface[indice_intf].altsetting[0].bInterfaceNumber;
          
          if(libusb_kernel_driver_active(handle,interface)){
          	int status=libusb_detach_kernel_driver(handle,interface);
          	if(status!=0){ perror("libusb_detach_kernel_driver"); exit(-1); } //erreur si status!=0
          }
      	//printf("indice intf trouvée %d\n",interface);
      }
   
          
      /* Utilisation de la configuration */
      int configuration=config_desc->bConfigurationValue;
      

      //printf("valeur config %d\n", configuration); // Affichage valeur de la configuration

      status=libusb_set_configuration(handle,configuration);
      if(status!=0){ perror("libusb_set_configuration"); exit(-1); }
          
          
      /* Appropriation de toutes les interfaces */
      int num_intf;
      for(int indice_intf=0;indice_intf < config_desc->bNumInterfaces ;indice_intf++){
      	num_intf = config_desc->interface[indice_intf].altsetting[0].bInterfaceNumber;
      	
      	status=libusb_claim_interface(handle,indice_intf);   
      	if(status!=0){ perror("libusb_claim_interface"); exit(-1); }

      	printf("\tInterface d'indice %d et de numéro %d réclamée\n",indice_intf,num_intf);

      
  
  
  		/* Parcours des points d'accès (Endpoint) pour chaque interface*/
  		for(int num_PA=0;num_PA<config_desc->interface[indice_intf].altsetting[0].bNumEndpoints ;num_PA++){
  		
  			int type_PA = config_desc->interface[indice_intf].altsetting[0].endpoint[num_PA].bmAttributes;
  			uint8_t adresse_PA = config_desc->interface[indice_intf].altsetting[0].endpoint[num_PA].bEndpointAddress;

              printf("\t\tPoint d'accès trouvé. Adresse : %d\n",adresse_PA);

              
          	/* Regarde si le point d'accès est de type interruption.
          	Si oui, on le sauvegarde. */
          	int dernier_PA=-1;
          	if((type_PA & 0b11)==LIBUSB_TRANSFER_TYPE_INTERRUPT){
  				//struct EP ep1;
              	dernier_PA++;
              	tab_PA[dernier_PA] = adresse_PA;

              	printf("\t\tPoint d'accès numéro %d sauvegardé. Adresse : %d\n", dernier_PA, adresse_PA);

  			
  				/*
  				ep1.ep=config_desc->interface[indice_intf].altsetting[0].endpoint->bEndpointAddress;
  				if (indice_intf==0){
  					tab_pa.tableau[indice_intf]->ep=ep1.ep;
              		tab_pa.tableau[indice_intf]->io=1;
  					tab_pa.dernier++;
            		}
  				else{               
       	    		tab_pa.tableau[indice_intf]->ep=ep1.ep;
            			tab_pa.tableau[indice_intf]->io=0;
            			tab_pa.dernier++;
           			if (num_ep >2)break;	//entrée => io=0
           	
            		 // Le if et else ci-dessus doivent pouvoir être simplifiés.
            		*/
            	}
          }
      }
  }
  
  
  /* Libération des interfaces de la configuration active */
  void liberer_interfaces(){ 
      
      /* Récupération de la configuration active */
      
      struct libusb_config_descriptor* config_desc;
      int status =libusb_get_active_config_descriptor(found,&config_desc); 
      if(status!=0){perror("libusb_get_active_config_descriptor");exit(-1);}
      
      /* On parcourt toutes les interfaces*/
      int num_intf;
      for(int indice_intf=0;indice_intf < config_desc->bNumInterfaces ;indice_intf++){
      	num_intf=config_desc->interface[indice_intf].altsetting[0].bInterfaceNumber;
      	
      	/* Libération de l'interface num_intf*/
          status=libusb_release_interface(handle,num_intf);
          if(status!=0){ perror("libusb_release_interface"); exit(-1); }  
          

          printf("\tL'interface numéro %d, d'indice %d a été libérée.\n", num_intf,indice_intf);          

  	}
  }
  
  
  /* Envoie un caractère (de commande de LED) sur le port USB */
  void send_data(unsigned char tab_PA[TAB_PA_SIZE], unsigned char data){
  
  	unsigned char PA = tab_PA[0]; //LEDs sur le premier point d'accès

  	int transferred = 1; 	//nombre d'octets transférés

  	unsigned int timeout = 1000;	//temps avant un timeout

  	int status = libusb_interrupt_transfer(handle, PA, &data, sizeof(data), &transferred, timeout);

  	if(status!=0){perror("libusb_interrupt_transfer");exit(-1);}
  }
  
  
  /* Lis le contenu des points d'accès de l'interface IN (boutons et joystick) */
  void receive_data(unsigned char tab_PA[TAB_PA_SIZE], unsigned char *boutons, unsigned char *joystick_x, unsigned char *joystick_y){
  
  	/* Lecture du point d'accès des boutons */
  	unsigned char PA = tab_PA[1]; //LEDs sur le premier point d'accès

  	int transferred = 1; 	//nombre d'octets transférés

  	unsigned int timeout = 1000;	//temps avant un timeout
  	

  	int status = libusb_interrupt_transfer(handle, PA, boutons, sizeof(boutons), &transferred, timeout);

  	if(status!=0){perror("libusb_interrupt_transfer");exit(-1);}
  	
  	/* Lecture du point d'accès du joystick */

  	unsigned char *joystick_xy=NULL; //stocke la donnée du point d'accès (1 octet pour chaque axe)

  
  	PA = tab_PA[2]; //LEDs sur le premier point d'accès

  	transferred = 2; 	//nombre d'octets transférés

  	timeout = 1000;	//temps avant un timeout
  	

  	status = libusb_interrupt_transfer(handle, PA, joystick_xy, sizeof(joystick_xy), &transferred, timeout);

  	if(status!=0){perror("libusb_interrupt_transfer");exit(-1);}
  	
  	//TODO Pas sûr !!!

  	if (joystick_xy !=NULL){
  		*joystick_x = joystick_xy[0];	//On sépare la data de chaque axe
  		*joystick_y = joystick_xy[1];
  	}

  }
  
  
  
  int main(){
      //init_tableau(); // initialisation tableau point d'accès endpoint
      
      /* Initialisation de la bibliothèque libusb-1.0 */
      
      int status=libusb_init(&context);
      if(status!=0) {perror("libusb_init"); exit(-1);}
      //fin inititialisation
      
      /* Enumération des périphériques USB */
      enum_periph();
      
      /* Ouverture de notre périphérique 'found' */
      int status_ouv=libusb_open(found,&handle);
      if(status_ouv!=0){ perror("libusb_open"); exit(-1); }
      
      /* Configuration du périphérique et sauvegarde des points d'accès */
      char tab_PA[TAB_PA_SIZE];
      config_periph(tab_PA);
      

      unsigned char *boutons, *boutons_anc = NULL;
      unsigned char *joystick_x, *joystick_x_anc = NULL;
      unsigned char *joystick_y, *joystick_y_anc = NULL;
      unsigned char caractere;

      /*

      //boucle while(pas d'arrêt), envoi et rcpt
      // "pas d'arrêt" = appui sur 's' par exemple

      	
      	if (appui sur une touche){
      		//récupération caractère
      		send_data(tab_PA, caractere);	//Envoi de la commande des leds
      	}
      	else {
      		receive_data(tab_PA, boutons, joystick_x, joystick_y); //Réception des boutons et joystick
      		if ((*boutons != *boutons_anc) || (joystick_x != joystick_x_anc) || (joystick_y != joystick_y_anc)) printf("Boutons : %c, Joystick_x : %c, Joystick_y :%c\n", *boutons, *joystick_x, *joystick_y);	//Affichage si changement
      		
      		*boutons_anc = *boutons;
      		*joystick_x_anc = *joystick_x;
      		*joystick_y_anc = *joystick_y;
      	}
      

      */

      
      /* Libération des interfaces*/
      liberer_interfaces();
      
  	/* Fermeture du périphérique */
      libusb_close(handle);
      
      
  
      
      libusb_exit(context); //fermeture de la bibliothèque
      return 0;
  }