#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);
}

// 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);
}


//void getFirstDeviceFromID(vid, pid)


//void getDevicesFromID(vid, pid)


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


    // lectures des configs?
/*    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;
    }
    printf("Config.bConfigurationValue : %d\n", config->bConfigurationValue);
    printf("Config/ bLength:%d;bDescriptorType:%d;bNumInterfaces:%d",
           config->bLength, config->bDescriptorType, config->bNumInterfaces);


        // itération de l'interface
    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");

            }
        }


    }

    printf("\n");

    libusb_close(handle);

}