#include <stdio.h>
#include "FinePix.h"

/* Describes the hardware. */
struct camera_hw {
        unsigned long /*__u16*/ vendor;
        unsigned long /*__u16*/ product;
        /* Offical name of the camera. */
        char name[32];
};

static struct camera_hw cam_supp[23] = {
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_4800_PID, "Fujifilm FinePix 4800"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A202_PID, "Fujifilm FinePix A202"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A203_PID, "Fujifilm FinePix A203"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A204_PID, "Fujifilm FinePix A204"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A205_PID, "Fujifilm FinePix A205"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A210_PID, "Fujifilm FinePix A210"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A303_PID, "Fujifilm FinePix A303"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_A310_PID, "Fujifilm FinePix A310"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_F401_PID, "Fujifilm FinePix F401"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_F402_PID, "Fujifilm FinePix F402"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_F410_PID, "Fujifilm FinePix F410"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_F601_PID, "Fujifilm FinePix F601"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_F700_PID, "Fujifilm FinePix F700"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_M603_PID, "Fujifilm FinePix M603"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_S3000_PID,
         "Fujifilm FinePix S3000"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_S304_PID, "Fujifilm FinePix S304"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_S5000_PID,
         "Fujifilm FinePix S5000"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_S602_PID, "Fujifilm FinePix S602"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_S7000_PID,
         "Fujifilm FinePix S7000"},

        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_X1_PID,
         "Fujifilm FinePix unknown model"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_X2_PID,
         "Fujifilm FinePix unknown model"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_X3_PID,
         "Fujifilm FinePix unknown model"},
        {USB_FUJIFILM_VENDOR_ID, USB_FINEPIX_X4_PID,
         "Fujifilm FinePix unknown model"},
};

FinePix::FinePix()
{
        fprintf(stderr, "FinePix::FinePix()\n");

        // Initially we don't have a camera device opened.
        camera = NULL;

        // Start the roster that will wait for FinePix USB devices.
        BUSBRoster::Start();
}

FinePix::~FinePix()
{
        fprintf(stderr, "FinePix: ~FinePix()\n");

        BUSBRoster::Stop();
}

status_t FinePix::InitCheck()
{
        fprintf(stderr, "FinePix: InitCheck()\n");

        if (camera != NULL)
                return B_NO_ERROR;
        else
                return B_ERROR;
}

int FinePix::SetupCam()
{
        int ret; // Return value
        
        fprintf(stderr, "FinePix: SetupCam()\n");
        
        /* Reset bulk in endpoint */                            
        camera->ControlTransfer (USB_REQTYPE_STANDARD | USB_REQTYPE_ENDPOINT_IN, 
                                                 USB_REQUEST_CLEAR_FEATURE, USB_FEATURE_ENDPOINT_HALT, 0, 0, NULL);
        
        /* Reset the camera *//* Init the device */

                unsigned char data[] = { 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00 };
                
                ret = camera->ControlTransfer(USB_REQTYPE_INTERFACE_OUT |USB_REQTYPE_CLASS ,
                                                                                 USB_REQUEST_GET_STATUS, 0x00, 0x00, 12, data);

                fprintf(stderr,"data: %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x\n", 
                                        data[0], data[1],data[2], data[3],data[4], data[5],
                                        data[6], data[7],data[8], data[9],data[10], data[11]);

                if (ret != 12) {
                        fprintf(stderr,"usb_control_msg failed (%d)\n", ret);
                        return 1;
                }
                
                unsigned char data3[MAX_BUFFER_SIZE]; 
                ret = bulk_in->BulkTransfer(data3, MAX_BUFFER_SIZE); 
                        fprintf(stderr,"BulkIn: %x, %x, %x, %x, %x, %x\n", 
                                        data3[0],data3[1],data3[2],data3[3],data3[4],data3[5]);
                
                if (ret < 0) {
                        fprintf(stderr,"failed to read the result (%d)\n", ret);
                        //return 1;
                }

        /* Again, reset bulk in endpoints */
        camera->ControlTransfer (USB_REQTYPE_STANDARD | USB_REQTYPE_ENDPOINT_IN, 
                                                 USB_REQUEST_CLEAR_FEATURE, USB_FEATURE_ENDPOINT_HALT, 0, 0, NULL);
        
        return 0;
}

int FinePix::GetPic(uint8 *frame, int &total_size)
{
        fprintf(stderr, "FinePix: GetPic()\n");
        int ret; // Return value
        
        /* Request a frame */
        fprintf(stderr,"request a frame\n");
        
        unsigned char data2[] = { 0xd3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 };

        ret = camera->ControlTransfer(USB_REQTYPE_INTERFACE_OUT |USB_REQTYPE_CLASS ,
                                                                         USB_REQUEST_GET_STATUS, 0x00, 0x00, 12, data2);
                
        fprintf(stderr,"data: %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x\n", 
                                data2[0], data2[1],data2[2], data2[3],data2[4], data2[5],
                                data2[6], data2[7],data2[8], data2[9],data2[10], data2[11]);

        if (ret != 12) 
        {
                fprintf(stderr,"usb_control_msg failed (%d)\n", ret);
                return 1;
        }
        
        /* Read the frame */
        int offset = 0;
        total_size = 0;

        do 
        {
                fprintf(stderr,"reading part of the frame\n");

                ret = bulk_in->BulkTransfer(&frame[offset], MAX_BUFFER_SIZE); 
                                        
                fprintf(stderr,"frame: %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x\n", 
                        frame[offset+0], frame[offset+1],frame[offset+2], frame[offset+3],
                        frame[offset+4], frame[offset+5],frame[offset+6], frame[offset+7],
                        frame[offset+8], frame[offset+9],frame[offset+10], frame[offset+11]);                   
                        
                if (ret < 0) { //this doesn't help, if we have an error we hang at the transfer
                        fprintf(stderr,"failed to read (%d)\n", ret);

                        return 1;
                }

                offset += ret;
                total_size += ret;

                if (ret != MAX_BUFFER_SIZE) // not a full buffer, must be end of frame
                        break;                  
        } while(1);

        fprintf(stderr,"this frame was %d bytes\n", total_size);
                        
        return 0;
}

status_t FinePix::DeviceAdded(BUSBDevice *dev)
{
        fprintf(stderr, "FinePix: DeviceAdded()\n");

        // Waits for FinePix devices.  When one is attached, configure it,
        // so that we are ready to use it.

        if (camera != NULL)
                return B_ERROR;
                
        int myCam = -1;
        // Find the device in our hardware list
        if (dev->VendorID() == USB_FUJIFILM_VENDOR_ID) 
        {
                for (int j = 0; j < 23; j++) //TODO use a cleaner way to check j < cam_supp.count
                { 
                        if (cam_supp[j].product == dev->ProductID()) 
                        {
                                myCam = j;
                                break;
                        }
                }
        }
        
        if (myCam >= 0)
        {
                fprintf(stderr, "Found cam: ");
                fprintf(stderr, cam_supp[myCam].name);
                fprintf(stderr, "\n");
                
                if (dev->SetConfiguration(dev->ConfigurationAt(0)) == 0)
                {
                        camera = dev;
                        
                        //set endpoint
                        bulk_in = 0;

                        int num_epoints = camera->ActiveConfiguration()->InterfaceAt(0)->CountEndpoints();
                        
                        fprintf(stderr, "CountEndpoints: %d\n", num_epoints);
                        
                        for (int i = 0; i < num_epoints; i++) 
                        {
                                if (camera->ActiveConfiguration()->InterfaceAt(0)->EndpointAt(i)->IsBulk())
                                        if (camera->ActiveConfiguration()->InterfaceAt(0)->EndpointAt(i)->IsInput())
                                                bulk_in = camera->ActiveConfiguration()->InterfaceAt(0)->EndpointAt(i);
                        }

                        if (bulk_in == 0) 
                        {
                                fprintf(stderr, "bad endpoint");
                                return B_ERROR;
                        }
                        
                        fprintf(stderr, "Successfully set configuration!\n");
                        
                        return B_OK;
                }
                else 
                        return B_ERROR;
        }
        else
                return B_ERROR;
}

void FinePix::DeviceRemoved(BUSBDevice *dev)
{
        fprintf(stderr, "FinePix: DeviceRemoved()\n");

        // If they remove our device, then we can't use it anymore.
        if (dev == camera)
                camera = NULL;
}