#include <errno.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>  // for assert()
#include "stdafx.h"
#include <libusb.h>
void print_devs(libusb_device **devs);
libusb_device* verify_device(libusb_device **devs);

#include <iostream>

int test2();
int do_exit = 0;
using namespace std;

 
BOOL WINAPI ConsoleHandler(
    DWORD dwCtrlType   //  control signal type
);

BOOL WINAPI ConsoleHandler(DWORD CEvent)
{
    char mesg[128];

    switch(CEvent)
    {
    case CTRL_C_EVENT:
        MessageBox(NULL,
            _T("CTRL+C received!"),_T("CEvent"),MB_OK);
		do_exit = true;
        break;
    case CTRL_BREAK_EVENT:
        MessageBox(NULL,
            _T("CTRL+BREAK received!"),_T("CEvent"),MB_OK);
        break;
    case CTRL_CLOSE_EVENT:
        MessageBox(NULL,
            _T("Program being closed!"),_T("CEvent"),MB_OK);
        break;
    case CTRL_LOGOFF_EVENT:
        MessageBox(NULL,
            _T("User is logging off!"),_T("CEvent"),MB_OK);
        break;
    case CTRL_SHUTDOWN_EVENT:
        MessageBox(NULL,
            _T("User is logging off!"),_T("CEvent"),MB_OK);
        break;

    }
    return TRUE;
}

int main() {
	//Handle Control+C
	if (SetConsoleCtrlHandler( (PHANDLER_ROUTINE)ConsoleHandler,TRUE)==FALSE)
    {
        printf("Unable to install handler!\n");
        return -1;
    }
	test2();
    return 0;

}

// OUT-going transfers (OUT from host PC to USB-device)
struct libusb_transfer *transfer_command_out     = NULL;  // find version 

// IN-coming transfers (IN to host PC from USB-device)
struct libusb_transfer *transfer_response_in  = NULL;

extern "C" void LIBUSB_CALL receive(struct libusb_transfer *transfer);
extern "C" void LIBUSB_CALL cb_command_out(struct libusb_transfer *transfer);

extern "C" void sighandler(int signum);


// Setup Endpoints - The endpoints (2,4) are particular to the USB-connected device
#define EP_COMMAND    (0x03 | LIBUSB_ENDPOINT_OUT) // OUT of PC to USB-device //DEVICE_SPECIFIC
#define EP_RESPONSE   (0x83 | LIBUSB_ENDPOINT_IN ) // IN  PC from  USB-device //DEVICE_SPECIFIC

unsigned char buffer[1024] = {0};

int device_num = 1;

int test2()
{
	libusb_device **devs;
	int r;

	libusb_context *ctx = NULL; //a libusb session

    ssize_t cnt; //holding number of devices in list

    r = libusb_init(&ctx); //initialize the library for the session we just declared

    if(r < 0) {

        cout<<"Init Error "<<r<<endl; //there was an error
        return 1;
    }

    libusb_set_debug(ctx, 3);

	cnt = libusb_get_device_list(ctx, &devs);
	if (cnt < 0)
		return (int) cnt;

	libusb_device *dev = verify_device(devs);

	struct libusb_device_descriptor desc;
	r = libusb_get_device_descriptor(dev, &desc);
	if (r < 0) {
		fprintf(stderr, "failed to get device descriptor");
		return -1;
	}

	libusb_config_descriptor *config;

    libusb_get_config_descriptor(dev, 0, &config);

    cout<<"Interfaces: "<<(int)config->bNumInterfaces;

    const libusb_interface *inter;
    const libusb_interface_descriptor *interdesc;
    const libusb_endpoint_descriptor *epdesc;
	/*
    for(int i=0; i<(int)config->bNumInterfaces; i++) {
        inter = &config->interface[i];
        cout<<"Number of alternate settings: "<<inter->num_altsetting<<" | ";

        for(int j=0; j<inter->num_altsetting; j++) {
            interdesc = &inter->altsetting[j];
            cout<<"Interface Number: "<<(int)interdesc->bInterfaceNumber<<" | ";
            cout<<"Number of endpoints: "<<(int)interdesc->bNumEndpoints<<" | ";

            for(int k=0; k<(int)interdesc->bNumEndpoints; k++) {
                epdesc = &interdesc->endpoint[k];
                cout<<"Descriptor Type: "<<(int)epdesc->bDescriptorType<<" | ";
                cout<<"EP Address: "<<(int)epdesc->bEndpointAddress<<" | ";
            }
        }
    }*/

    libusb_free_config_descriptor(config);
	
	printf("%04x:%04x (bus %d, device %d)\n",
		desc.idVendor, desc.idProduct,
		libusb_get_bus_number(dev), libusb_get_device_address(dev));

	libusb_device_handle *handle = NULL;

	r = libusb_open(dev, &handle);
	
	printf("libusb_open = %d\n", r); 

	r = libusb_kernel_driver_active(handle, device_num); 
    printf("libusb_kernel_driver_active = %d\n", r); 
	if (r == 1) { 
		r = libusb_detach_kernel_driver(handle, device_num); 
		printf("libusb_detach_kernel_driver = %d\n", r); 
    }

	r = libusb_claim_interface(handle, device_num);
	if (r < 0) {
		fprintf(stderr, "usb_claim_interface error %d\n", r);
		return -1;
	}
	
	const int length = 1;
	unsigned char buf[length] = {0};
	buf[0] = 'a';

	transfer_response_in  = libusb_alloc_transfer(0);
	libusb_fill_bulk_transfer( transfer_response_in, handle, EP_RESPONSE, 
		buffer,  1024,  // Note: version_string is where input data written.
		receive, NULL, 0); // no user data
	r = libusb_submit_transfer(transfer_response_in);
	printf("return value from libusb_submit_transfer(for transfer_response_in)= %d\n", r);

		// Define transfer of data OUT (OUT to USB-device from host PC) 
	transfer_command_out = libusb_alloc_transfer(0);

	libusb_fill_bulk_transfer(transfer_command_out, handle, EP_COMMAND,
		buf, length,  // version request command, command length
		cb_command_out, NULL, 0); // callback function, NO callback data
	r = libusb_submit_transfer(transfer_command_out);
	printf("return value from libusb_submit_transfer(for transfer_command_out)=%d\n", r);

	while (!do_exit) {
		struct timeval tv;
		tv.tv_sec  = 0;     // seconds
		tv.tv_usec = 100;   // milliseconds  ( .1 sec)
		//libusb_handle_events(ctx);
		libusb_handle_events_timeout(ctx, &tv);
	}

	libusb_release_interface(handle, device_num);
	libusb_close(handle);
	libusb_free_device_list(devs, 0);
	libusb_exit(ctx);

	printf("Exit 0");
	return 0;
}

extern "C" void LIBUSB_CALL receive(struct libusb_transfer *transfer)
{	int i;
	fprintf(stderr, "cb_response_in: status =%d, actual_length=%d\n", 
		transfer->status, transfer->actual_length);
	for (i=0; i < transfer->actual_length; i++){ 
		printf("buffer[%d]=%x \n", i, buffer[i] );
	}
	return; 
}

//This is called after command for version is received.
//   - This is ONLY a mechanism to indicate the that version command has been received by libusb.
//     It does NOT signal that the version_string is ready. 
//     It does NOT say when the version will be ready.
extern "C" void LIBUSB_CALL cb_command_out(struct libusb_transfer *transfer)
{
	fprintf(stderr, "cb_command_out: status =%d, actual_length=%d\n", 
		transfer->status, transfer->actual_length);
	return; 
}

libusb_device* verify_device(libusb_device **devs)
{
	libusb_device *dev;
	int i = 0;
	while ((dev = devs[i++]) != NULL) {
		struct libusb_device_descriptor desc;
		int r = libusb_get_device_descriptor(dev, &desc);
		if (r < 0) {
			fprintf(stderr, "failed to get device descriptor");
			return NULL;
		}
		if(desc.idVendor == 0x04D8 && desc.idProduct == 0x00DF)
		{
			puts("Found our Device!");
			return dev;
		}
	}
	return NULL;
}

void print_devs(libusb_device **devs)
{
	libusb_device *dev;
	int i = 0;

	while ((dev = devs[i++]) != NULL) {
		struct libusb_device_descriptor desc;
		int r = libusb_get_device_descriptor(dev, &desc);
		if (r < 0) {
			fprintf(stderr, "failed to get device descriptor");
			return;
		}

		printf("%04x:%04x (bus %d, device %d)\n",
			desc.idVendor, desc.idProduct,
			libusb_get_bus_number(dev), libusb_get_device_address(dev));
	}
}