#include <stdio.h>
#include <string.h>
#include <usb.h>
#include <errno.h>

// Mattel, Inc.
#define DAACS_IDVENDOR 0x0813

// Digital Arts & Crafts Studio
#define DAACS_IDPRODUCT 0x1006

// bConfigurationValue 1
#define DAACS_CONFIGURATION 1

// bInterfaceNumber 0
#define DAACS_INTERFACE 0

// How many ms to wait before timeout during interrupt read?
#define DAACS_READ_TIMEOUT 1000


int main(int argc, char * argv[])
{
  struct usb_bus * busses;
  struct usb_bus * bus;
  struct usb_device * daacs_dev;
  usb_dev_handle * daacs_dev_handle;
  int i, j, k, l;
  int daacs_input_ep;
  int daacs_packetsize;
  char * packet;
  int ret;
  int done;

  usb_init();
  usb_set_debug(2);
  usb_find_busses();
  usb_find_devices();

  busses = usb_get_busses();

  daacs_dev = NULL;

  for (bus = busses; bus != NULL; bus = bus->next)
  {
    struct usb_device * dev;

    for (dev = bus->devices; dev != NULL; dev = dev->next)
    {
      if (dev->descriptor.idVendor == DAACS_IDVENDOR && // Mattel, Inc.
	  dev->descriptor.idProduct == DAACS_IDPRODUCT) // Digital Arts & Crafts Studio
      {
        daacs_dev = dev;
      }
    }
  }

  if (daacs_dev == NULL)
  {
    fprintf(stderr, "Could not find DAACS on any USB bus; is it plugged in?\n");
    return(1);
  }

  daacs_dev_handle = usb_open(daacs_dev);
  printf("DAACS Device Found @ Address: %s\n", daacs_dev->filename);

  ret = usb_claim_interface(daacs_dev_handle, DAACS_INTERFACE);

  if (ret != 0)
  {
    if (LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP)
    {
      int retries = 3;

      do
      {
        ret = usb_detach_kernel_driver_np(daacs_dev_handle, DAACS_INTERFACE);
        retries--;
      }
      while (ret < 0 && retries > 0);

      if (ret < 0)
      {
        fprintf(stderr, "Could not detach kernel driver: %d %s\n", ret, usb_strerror());
        return(1);
      } 

      ret = usb_claim_interface(daacs_dev_handle, DAACS_INTERFACE);
      if (ret < 0)
      {
        fprintf(stderr, "Could not claim interface: %s\n", usb_strerror());
        return(1);
      }
    } 
  }

  ret = usb_set_altinterface(daacs_dev_handle, DAACS_INTERFACE);
  if (ret < 0)
  {
    fprintf(stderr, "Could not set alt. interface: %s\n", usb_strerror());
    // return(1);
  } 

  if (daacs_dev->config == NULL)
  {
    fprintf(stderr, "Could not retrieve descriptors\n");
    return(1);
  }

  daacs_input_ep = -1;
  daacs_packetsize = 0;

  /* print configuration: */
  printf("\nDevice has %d configurations:\n",
         daacs_dev->descriptor.bNumConfigurations);

  for (i = 0; i < daacs_dev->descriptor.bNumConfigurations; i++) 
  {
    printf("- Configuration %d has %d interfaces:\n", i,
           daacs_dev->config[i].bNumInterfaces);

    for (j = 0; j < daacs_dev->config[i].bNumInterfaces; j++)
    {
      printf("  - Config %d, interface %d has %d alt. settings:\n", i, j,
             daacs_dev->config[i].interface[j].num_altsetting);

      for (k = 0; k < daacs_dev->config[i].interface[j].num_altsetting; k++)
      {
        printf("    - Config %d, intf %d, alt.set %d has %d endpoints:\n",
               i, j, k,
               daacs_dev->config[i].interface[j].altsetting[k].bNumEndpoints);

        for (l = 0;
             l < daacs_dev->config[i].interface[j].altsetting[k].bNumEndpoints;
             l++)
        {
          struct usb_endpoint_descriptor * endpoint;

          endpoint =
            &(daacs_dev->config[i].interface[j].altsetting[k].endpoint[l]);

          printf("      - bLength: %d\n", endpoint->bLength);
          printf("      - bDescriptorType: %d\n", endpoint->bDescriptorType);
          printf("      - bEndpointAddress: 0x%02x\n",
		 endpoint->bEndpointAddress);
          printf("      - bmAttributes: 0x%02x\n", endpoint->bmAttributes);
          printf("      - wMaxPacketSize: %d\n", endpoint->wMaxPacketSize);
          printf("      - bInterval: %d\n", endpoint->bInterval);
          printf("      - bRefresh: %d\n", endpoint->bRefresh);
          printf("      - bSynchAddress: %d\n", endpoint->bSynchAddress);

          if (endpoint->bmAttributes == 0x03 && // bits 0&1 on means interrupt
	      (endpoint->bEndpointAddress & 0x80) != 0) // bit 7 on means Input
	  {
            daacs_input_ep = endpoint->bEndpointAddress;
            daacs_packetsize = endpoint->wMaxPacketSize;
          }
        }
      }
    }
  }

  printf("\n");

  if (daacs_input_ep == -1 || daacs_packetsize == 0)
  {
    fprintf(stderr, "Didn't find input endpoint\n");
    return(1);
  }

  packet = (char *) malloc(daacs_packetsize);

  done = 0;

  do
  {
    ret = usb_interrupt_read(daacs_dev_handle, daacs_input_ep,
			     packet, daacs_packetsize,
			     DAACS_READ_TIMEOUT);

    if (ret == -ETIMEDOUT)
      printf("Timeout\n");
    else if (ret < 0)
    {
      fprintf(stderr, "Error %d reading interrupt: %s\n", ret, usb_strerror());
      done = 1;
    }
    else
    {
      for (i = 0; i < daacs_packetsize; i++)
      {
        printf("%02x ", packet[i]);
      }
      printf("\n");
    }
  }
  while (!done);

  /* ... */

  usb_close(daacs_dev_handle);
  

  return(0);
}