#include <stdio.h>
#include <stdlib.h>


#include "version_choose.h"
#include "JZsdkLib.h"
#include "./JZsdk_usb_bulk.h"


#ifdef USB_CONFIG_STATUS_ON
    #include <libusb-1.0/libusb.h>
#endif

#define LINUX_USB_BULK_TRANSFER_TIMEOUT_MS    (50)
#define LINUX_USB_BULK_TRANSFER_WAIT_FOREVER  (-1)

typedef struct JZsdk_T_HalUsbBulkObj{

    
#ifdef USB_CONFIG_STATUS_ON
    libusb_device_handle *handle;  //usb的权柄
#endif

    unsigned int interfaceNum;      //接口编号
    int isUsbHost;

    unsigned int pid;       //pid号码 用于标识产商
    unsigned int vid;       //vid号码 用于标识设备名

    unsigned int PointIn;   //读取输入引脚
    unsigned int PointOut;  //写入输出引脚

}JZsdk_T_HalUsbBulkObj;

T_JZsdkReturnCode JZsdk_HalUsbBulk_Init(void **index, int interfaceNum, int isUsbHost,
                                            unsigned int pid, unsigned int vid, unsigned int PointIn, unsigned int PointOut)
{
#ifdef USB_CONFIG_STATUS_ON
    //创建一个usb信息结构体
    struct JZsdk_T_HalUsbBulkObj *UsbBulkObj = NULL;

    //为usb信息结构体注册内存
    UsbBulkObj = (struct JZsdk_T_HalUsbBulkObj *)malloc(sizeof(struct JZsdk_T_HalUsbBulkObj));  
    if (UsbBulkObj == NULL) {  
        JZSDK_LOG_ERROR("HalUsbBulk注册失败");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_INVALID_PARAMETER;  
    }  

    UsbBulkObj->handle = NULL;
    UsbBulkObj->interfaceNum = interfaceNum;
    UsbBulkObj->isUsbHost = isUsbHost;
    UsbBulkObj->pid = pid;
    UsbBulkObj->vid = vid;
    UsbBulkObj->PointIn = PointIn;
    UsbBulkObj->PointOut = PointOut;

    int ret;

    ret = libusb_init(NULL);
    if (ret < 0) {
        JZSDK_LOG_ERROR("init usb bulk failed, errno = %d", ret);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

    UsbBulkObj->handle = libusb_open_device_with_vid_pid(NULL, UsbBulkObj->vid, UsbBulkObj->pid);  
    if(UsbBulkObj->handle == NULL) {  
        JZSDK_LOG_ERROR("Open Device Error\n");  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;    
    }  

    // ret = libusb_detach_kernel_driver(UsbBulkObj->handle, UsbBulkObj->interfaceNum);  
    // if (ret < 0)
    // {
    //     printf("销毁usb任务失败\n");
    // }
    
    ret = libusb_claim_interface(UsbBulkObj->handle, UsbBulkObj->interfaceNum);  
    if(ret < 0) {  
        JZSDK_LOG_ERROR("Cannot Claim Interface\n");  
        libusb_close(UsbBulkObj->handle);  
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;  
    }  

    JZSDK_LOG_INFO("USB 初始化完成\n");

    *index = (void *)UsbBulkObj;
#endif
    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode JZsdk_HalUsbBulk_DeInit(void **index)
{
    // struct libusb_device_handle *handle = NULL;
    // int32_t ret;
    // T_DjiOsalHandler *osalHandler = DjiPlatform_GetOsalHandler();

    // if (usbBulkHandle == NULL) {
    //     return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
    // }

    // handle = ((T_HalUsbBulkObj *) usbBulkHandle)->handle;


    //     ret = libusb_release_interface(handle, ((T_HalUsbBulkObj *) usbBulkHandle)->usbBulkInfo.channelInfo.interfaceNum);
    //     if(ret != 0) {
    //         USER_LOG_ERROR("release usb bulk interface failed, errno = %d", ret);
    //         return DJI_ERROR_SYSTEM_MODULE_CODE_SYSTEM_ERROR;
    //     }
    //     osalHandler->TaskSleepMs(100);
    //     libusb_exit(NULL);


    // free(usbBulkHandle);

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode JZsdk_HalUsbBulk_WriteData(void **index ,const unsigned char *buf, unsigned int len, unsigned int *realLen)
{
    struct JZsdk_T_HalUsbBulkObj *UsbBulkObj = (struct JZsdk_T_HalUsbBulkObj *) *index;

    int ret;
    int actualLen = 0;
#ifdef USB_CONFIG_STATUS_ON 
    ret = libusb_bulk_transfer(UsbBulkObj->handle, UsbBulkObj->PointOut,
                            (unsigned char *) buf, len, &actualLen, LINUX_USB_BULK_TRANSFER_TIMEOUT_MS);
    if (ret < 0) {
        JZSDK_LOG_ERROR("Write usb bulk data failed, errno = %d", ret);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
#endif

    *realLen = actualLen;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

T_JZsdkReturnCode JZsdk_HalUsbBulk_ReadData(void **index ,unsigned char *buf, unsigned int len,unsigned int *realLen)
{
    struct JZsdk_T_HalUsbBulkObj *UsbBulkObj = (struct JZsdk_T_HalUsbBulkObj *) *index;

    int ret;
    int actualLen = 0;

#ifdef USB_CONFIG_STATUS_ON
    ret = libusb_bulk_transfer(UsbBulkObj->handle, UsbBulkObj->PointIn,
                            buf, len, &actualLen, LINUX_USB_BULK_TRANSFER_WAIT_FOREVER);
    if (ret < 0) {
        JZSDK_LOG_ERROR("Read usb bulk data failed, errno = %d", ret);
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }
#endif
    *realLen = actualLen;

    return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

// T_DjiReturnCode HalUsbBulk_GetDeviceInfo(T_DjiHalUsbBulkDeviceInfo *deviceInfo)
// {
//     //attention: this interface only be called in usb device mode.
//     deviceInfo->vid = LINUX_USB_VID;
//     deviceInfo->pid = LINUX_USB_PID;

//     // This bulk channel is used to obtain DJI camera video stream and push 3rd-party camera video stream.
//     deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_0].interfaceNum = LINUX_USB_BULK1_INTERFACE_NUM;
//     deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_0].endPointIn = LINUX_USB_BULK1_END_POINT_IN;
//     deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_0].endPointOut = LINUX_USB_BULK1_END_POINT_OUT;

//     // This bulk channel is used to obtain DJI perception image and download camera media file.
//     deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_1].interfaceNum = LINUX_USB_BULK2_INTERFACE_NUM;
//     deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_1].endPointIn = LINUX_USB_BULK2_END_POINT_IN;
//     deviceInfo->channelInfo[DJI_HAL_USB_BULK_NUM_1].endPointOut = LINUX_USB_BULK2_END_POINT_OUT;

//     return DJI_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
// }

// int JZ_HalUsbBulk_GetDeviceInfo() {  
//     libusb_device **devs; // 指针的指针，用于存储设备列表  
//     libusb_context *ctx = NULL; // libusb上下文  
//     libusb_device_handle *dev_handle; // 设备句柄  
//     int r; // 用于存储返回值  
//     ssize_t cnt; // 设备数量  
//     libusb_device_descriptor desc; // 设备描述符  
//     libusb_config_descriptor *config_desc; // 配置描述符  
//     const libusb_interface *intf; // 接口  
//     const libusb_interface_descriptor *intf_desc; // 接口描述符  
//     int i, j;  
  
//     // 初始化libusb库  
//     r = libusb_init(&ctx);  
//     if(r < 0) {  
//         printf("初始化libusb失败\n");  
//         return 1;  
//     }  
  
//     libusb_set_debug(ctx, 3); // 设置调试级别  
  
//     // 获取USB设备列表  
//     cnt = libusb_get_device_list(ctx, &devs);  
//     if(cnt < 0) {  
//         printf("获取设备列表失败\n");  
//         libusb_exit(ctx);  
//         return 1;  
//     }  
  
//     // 遍历设备列表  
//     printf("找到了 %zd 个设备\n", cnt);  
//     for (i = 0; i < cnt; i++) {  
//         dev_handle = libusb_open_device_with_vid_pid(ctx, VENDOR_ID, PRODUCT_ID); // 使用厂商ID和产品ID打开设备  
//         if (dev_handle == NULL) {  
//             printf("无法打开设备\n");  
//             continue;  
//         }  
  
//         // 获取设备描述符  
//         r = libusb_get_device_descriptor(devs[i], &desc);  
//         if (r < 0) {  
//             printf("获取设备描述符失败\n");  
//             libusb_close(dev_handle);  
//             continue;  
//         }  
  
//         printf("设备描述符：\n");  
//         printf("  厂商ID: 0x%04x\n", desc.idVendor);  
//         printf("  产品ID: 0x%04x\n", desc.idProduct);  
  
//         // 获取活动配置的描述符  
//         r = libusb_get_active_config_descriptor(devs[i], &config_desc);  
//         if (r < 0) {  
//             printf("获取配置描述符失败\n");  
//             libusb_close(dev_handle);  
//             continue;  
//         }  
  
//         // 遍历配置中的接口  
//         for (j = 0; j < config_desc->bNumInterfaces; j++) {  
//             intf = &config_desc->interface[j];  
//             printf("接口编号: %d\n", intf->bInterfaceNumber);  
  
//             // 遍历接口中的设置  
//             for (int k = 0; k < intf->num_altsetting; k++) {  
//                 intf_desc = &intf->altsetting[k];  
//                 // 这里可以进一步处理接口描述符的信息，比如端点等  
//                 printf("  设置编号: %d\n", intf_desc->bAlternateSetting);  
//                 // ...  
//             }  
//         }  
  
//         libusb_free_config_descriptor(config_desc); // 释放配置描述符  
//         libusb_close(dev_handle); // 关闭设备句柄  
//     }  
  
//     libusb_free_device_list(devs, 1); // 释放设备列表  
//     libusb_exit(ctx); // 退出libusb库  
  
//     return 0;  
// }