#include "libusb_wrapper.h"

  void usbinit(libusb_context **context_ptr) {
      //libusb_context *context;
      int statusInit = libusb_init(context_ptr);
      if (statusInit != LIBUSB_SUCCESS) {
          perror("libusb_init");
          exit(-1);
      }

  }
  

  void usbclose(libusb_context *context) {
      libusb_exit(context);

  }
  

  void interfaceclaim(libusb_device_handle *handle, struct libusb_interface *interface){
      const struct libusb_interface_descriptor * interface_desc = &interface->altsetting[0]; //TODO enlever cette ligne, refactor

      if(interface_desc->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC){//ON PEUT VERIFIER LA CLASS
          printf("> vendor specific class\n");

      	int status=libusb_claim_interface(handle, interface_desc->bInterfaceNumber);
      	if(status!=0){ perror("libusb_claim_interface"); exit(-1); }
  	}

  }
  
  void interfaceclose(libusb_device_handle *handle, struct libusb_interface *interface){
      const struct libusb_interface_descriptor * interface_desc = &interface->altsetting[0];
      int status = libusb_release_interface(handle, interface_desc->bInterfaceNumber);
      if(status!=0){ perror("libusb_release_interface"); exit(-1); }
  }
  

  // Si le méchant noyau est passé avant vous :

  void getFromKernel(libusb_device_handle *handle, int interface) { //private method for now

      if (libusb_kernel_driver_active(handle, interface)) {
          int statusKDriver = libusb_detach_kernel_driver(handle, interface);
          if (statusKDriver != LIBUSB_SUCCESS) {
              perror("libusb_detach_kernel_driver");
              exit(-1);
          }
      }

  }
  

  ssize_t getListDevices(libusb_context *context, libusb_device ***list_ptr) {
      ssize_t count = libusb_get_device_list(context, list_ptr);
      if (count < 0) {
          perror("libusb_get_device_list");
          exit(-1);
      }
      return count;
  }
  

  void* _enumerateDevices(libusb_context *context, void (*func)(libusb_device *device)){
      libusb_device **list;
      ssize_t count = getListDevices(context, &list);
  
      ssize_t i = 0;
      for (i = 0; i < count; i++) {
          libusb_device *device = list[i];
  
          func(device);
      }
  
      libusb_free_device_list(list, 1);
  
      return NULL; //DBGONLY TEMP
  }
  

  //print readable string, not asked for tutoring
  void _printConfig(libusb_device *device) {//private method
      // Ouverture du périphérique
      libusb_device_handle *handle;
      int statusDevice = libusb_open(device, &handle);
      if (statusDevice != LIBUSB_SUCCESS) {
          perror("libusb_open");
          //return; //exit(-1);
      }
  
      int MAXLEN_DESCRIPTOR_STRING = 200;
      uint8_t desc_idx = 2;
      //uint16_t langid = 16;
      unsigned char data[200];
  
      // TEST 16
      for (desc_idx = 0; desc_idx < 16; desc_idx++) {
          int statusAscii = libusb_get_string_descriptor_ascii(
                  handle, desc_idx, data, MAXLEN_DESCRIPTOR_STRING);
          if (statusAscii == -9) // TEST seems to be LIBUSB_ERROR
              break;
          printf(" - Descriptor string : %s ; %i\n", data, statusAscii);
      }
  
      libusb_close(handle);

  }
  

  void _displayOneDevice(libusb_device *device){
      struct libusb_device_descriptor desc;

      int status = libusb_get_device_descriptor(device, &desc);
      if (status != LIBUSB_SUCCESS){
          printf("Cannot get device desc : %s\n", libusb_error_name(status)); //DBGONLY
          perror("libusb_open");
          return;
      }

      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", desc.idProduct);

      //displayDeviceEndpoints(device); //Not really work on Axel@Alptop
  }

  void displayDevices(libusb_context *context) {
      _enumerateDevices(context, _displayOneDevice);
  }

  void _displayOneDeviceMore(libusb_device *device){
      _displayOneDevice(device);
      _printConfig(device);
  }
  
  void displayDevicesMore(libusb_context *context) {
      _enumerateDevices(context, _displayOneDeviceMore);
  }
  

  //get device from iteration (and not from not recommanded function :
  //ugly using global vars ?? Cannot communicate between getFirstDeviceFromID and _getFirstDeviceFromID
  int g_vid;
  int g_pid;
  libusb_device *g_device = NULL;
  void _getFirstDeviceFromID(libusb_device *device) {
      struct libusb_device_descriptor desc;

      int status = libusb_get_device_descriptor(device, &desc);
      if (status != LIBUSB_SUCCESS){
          printf("Cannot get device desc : %s\n", libusb_error_name(status)); //DBGONLY
          perror("libusb_open");
          return;
      }

      if(desc.idVendor == g_vid && desc.idProduct == g_pid){
          g_device = device;
      }
  }
  
  void getFirstDeviceFromID(libusb_context *context, int vid, int pid, libusb_device **device) {
      g_vid = vid; //pass parameters for enumeration
      g_pid = pid; //idem
      _enumerateDevices(context, _getFirstDeviceFromID);

      *device = g_device; //get return from enumeration

  }
  
  //void getDevicesFromID(vid, pid) //return array

  void displayDeviceEndpoints(libusb_device_handle* handle) {
      //recover pointer from handle
      libusb_device *device;
      device = libusb_get_device(handle);

      // lectures des configs => on prend la première configuration pour l'instant
      /*int configuration = 0; // valueof("bConfigurationValue");

      int statusConfig = libusb_set_configuration(handle, configuration);

      if (statusConfig != LIBUSB_SUCCESS) {
          perror("libusb_set_configuration");
          return;

      }*/

      // 4.2 configuration du périph usb
      struct libusb_config_descriptor *config;

      int statusFetchConfig = libusb_get_active_config_descriptor(device, &config);
      if (statusFetchConfig != LIBUSB_SUCCESS) {
          perror("libusb_get_active_config_descriptor");
          return;

      }

  
      //caractéristiques globales

      printf("Config.bConfigurationValue : %d\n", config->bConfigurationValue);

      printf("Config/ bLength:%d\nbDescriptorType:%d\nbNumInterfaces:%d\n",

             config->bLength, config->bDescriptorType, config->bNumInterfaces);
  

      //itération des interfaces
      printf("Itération de l'interface\n");
      for (int indexInterface = 0; indexInterface < config->bNumInterfaces; indexInterface++) {
          printf("-indexInterface=%d\n", indexInterface);
          printf("-Altsetting=%d\n", config->interface[indexInterface].num_altsetting);
  
          const struct libusb_interface * interface = &config->interface[indexInterface];
  
  
          //if 1 setting (or more)
          if(interface->num_altsetting != 0) {
              const struct libusb_interface_descriptor * interface_desc = &interface->altsetting[0];
  
              printf("--bNumEndpoints=%d\n", interface_desc->bNumEndpoints);
              printf("--bDescriptorType=%d\n", interface_desc->bDescriptorType);
  
              for(int indexEndpoints = 0; indexEndpoints < interface_desc->bNumEndpoints ; indexEndpoints++){
                  const struct libusb_endpoint_descriptor * endpoint_desc = &interface_desc->endpoint[indexEndpoints];
                  printf("---bDescriptorType=%d\n", endpoint_desc->bDescriptorType);
                  printf("---bEndpointAddress=%d\n", endpoint_desc->bEndpointAddress);
  
                  if(endpoint_desc->extra != NULL)
                      printf("---extra: %s\n", endpoint_desc->extra);
                  if(endpoint_desc->bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT)//TODO AJOUT MASQUE ? (voir doc)
                      printf("---is of type INTERRUPT\n");

              }
          }
  
  
  
          //Affichez l’indice et le numéro de chaque interface détectée et réclamée. Affichez aussi les points d’accès trouvés en précisant ceux sauvés.
  
  /*
          //int interface=valueof("bInterfaceNumber");
          int status=libusb_claim_interface(handle,interface->bInterfaceNumber);
          if(status!=0){ perror("libusb_claim_interface"); exit(-1); }
  
          status=libusb_release_interface(handle,interface->bInterfaceNumber);
          if(status!=0){ perror("libusb_release_interface"); exit(-1); }
  
          //claim_interface(.., config interface altsetting bInterfaceNumber
          //config interface altsetting endpoint bmAttributes == LIBUSB_TRANSFER_TYPE_INTERRUPT
          //add des enpoint unint8_t*/
  
  
          //DESCRIPTOR.C /.H :décommenter
  
  
          //IL FAUT RELEASE UNIQUEMENT LES INTERFACES QUI NE SONT PAS DES HID

      }
  
      printf("\n");

      libusb_close(handle);

  }

  
  void getOurInterfaces(libusb_device *device,
                        struct libusb_interface **int_hidjoy,
                        struct libusb_interface **int_leds,
                        struct libusb_interface **int_vibrators
  ) {

      struct libusb_config_descriptor *config;
      int statusFetchConfig = libusb_get_active_config_descriptor(device, &config);
      if (statusFetchConfig != LIBUSB_SUCCESS) {
          perror("libusb_get_active_config_descriptor");
          return;
      }

      //itération des interfaces

      for (int indexInterface = 0; indexInterface < config->bNumInterfaces; indexInterface++) {

          const struct libusb_interface * interface = &config->interface[indexInterface];

  
          //todo use le descriptor pour avoir bInterfaceNumber?
          if(indexInterface==0){

              *int_hidjoy = (struct libusb_interface *)interface;

          }else if(indexInterface==1){

              *int_leds = (struct libusb_interface *)interface;

          }else if(indexInterface==2){

              *int_vibrators = (struct libusb_interface *)interface;

          }
  
          //#define pour les indices correspondants aux interfaces
          //variables globales
      }
  

  }
  
  char getOnlyEndpoint(struct libusb_interface * interface){
  
      const struct libusb_interface_descriptor * interface_desc = &interface->altsetting[0];
  

      const struct libusb_endpoint_descriptor * endpoint_desc = &interface_desc->endpoint[0];
  
      if(endpoint_desc->bmAttributes != LIBUSB_TRANSFER_TYPE_INTERRUPT)//ON PEUT VERIFIER LE TRANSFER TYPE
          printf("> is NOT of type INTERRUPT\n");
  
      return (char)endpoint_desc->bEndpointAddress;

  }