/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2017-11-16     ZYH          first version
 */
//#include <rthw.h>
//#include <rtdevice.h>
#include <include/rttusb_device.h>
#include "winusb.h"
#include "hal/isp_tunning.h"
#include "dev/audio/ausys_debug.h"
#include "dev/audio/ausys.h"
#include "dev/audio/ausys_da.h"
#include "dev/audio/components/eq/aueq.h"
#include "hal/isp.h"


#ifdef RT_USB_DEVICE_WINUSB

#if ISP_TUNNING_EN
extern struct isp_tunnning_dev *isp_tunning;
#endif

struct winusb_device
{
    struct rt_device parent;
    udevice_t device;
    void (*cmd_handler)(rt_uint8_t *buffer,rt_size_t size);
    void (*rx_handler)(rt_uint8_t *buffer,rt_size_t size);
    void (*tx_handler)(rt_uint8_t *buffer,rt_size_t size);
    rt_uint8_t cmd_buff[256 + USB_RX_BUFF_RESERVE_SIZE]  rt_align(4);
    rt_uint8_t dat_buff[1024 + USB_RX_BUFF_RESERVE_SIZE] rt_align(4);
    uep_t ep_out;
    uep_t ep_in;
    void *user_data;
};
#define WINUSB_INTF_STR_INDEX 13
typedef struct winusb_device * winusb_device_t;

rt_align(4)
static struct udevice_descriptor dev_desc =
{
    USB_DESC_LENGTH_DEVICE,     //bLength;
    USB_DESC_TYPE_DEVICE,       //type;
    USB_BCD_VERSION,            //bcdUSB;
    0xFF,                       //bDeviceClass;
    0xFF,                       //bDeviceSubClass;
    0xFF,                       //bDeviceProtocol;
    0x40,                       //bMaxPacketSize0;
    _VENDOR_ID,                 //idVendor;
    _PRODUCT_ID,                //idProduct;
    USB_BCD_DEVICE,             //bcdDevice;
    USB_STRING_MANU_INDEX,      //iManufacturer;
    USB_STRING_PRODUCT_INDEX,   //iProduct;
    USB_STRING_SERIAL_INDEX,    //iSerialNumber;
    USB_DYNAMIC,                //bNumConfigurations;
};

//FS and HS needed
rt_align(4)
static struct usb_qualifier_descriptor dev_qualifier =
{
    sizeof(dev_qualifier),          //bLength
    USB_DESC_TYPE_DEVICEQUALIFIER,  //bDescriptorType
    0x0200,                         //bcdUSB
    0xFF,                           //bDeviceClass
    0x00,                           //bDeviceSubClass
    0x00,                           //bDeviceProtocol
    64,                             //bMaxPacketSize0
    0x01,                           //bNumConfigurations
    0,
};

rt_align(4)
struct winusb_descriptor _winusb_desc =
{
#ifdef RT_USB_DEVICE_COMPOSITE
    /* Interface Association Descriptor */
    {
        USB_DESC_LENGTH_IAD,
        USB_DESC_TYPE_IAD,
        USB_DYNAMIC,
        0x01,
        0xFF,
        0x00,
        0x00,
        0x00,
    },
#endif
    /*interface descriptor*/
    {
        USB_DESC_LENGTH_INTERFACE,  //bLength;
        USB_DESC_TYPE_INTERFACE,    //type;
        USB_DYNAMIC,                //bInterfaceNumber;
        0x00,                       //bAlternateSetting;
        0x02,                       //bNumEndpoints
        0xFF,                       //bInterfaceClass;
        0xFF,                       //bInterfaceSubClass;
        0xFF,                       //bInterfaceProtocol;
#ifdef RT_USB_DEVICE_COMPOSITE
        WINUSB_INTF_STR_INDEX,
#else
        0x00,                       //iInterface;
#endif
    },
    /*endpoint descriptor*/
    {
        USB_DESC_LENGTH_ENDPOINT,
        USB_DESC_TYPE_ENDPOINT,
        USB_DYNAMIC | USB_DIR_OUT,
        USB_EP_ATTR_BULK,
        USB_DYNAMIC,
        0x00,
    },
    /*endpoint descriptor*/
    {
        USB_DESC_LENGTH_ENDPOINT,
        USB_DESC_TYPE_ENDPOINT,
        USB_DYNAMIC | USB_DIR_IN,
        USB_EP_ATTR_BULK,
        USB_DYNAMIC,
        0x00,
    },
};

rt_align(4)
const static char* _ustring[] =
{
    "Language",
    "RT-Thread Team.",
    "RTT Win USB",
    "32021919830108",
    "Configuration",
    "Interface",
    USB_STRING_OS//must be
};

rt_align(4)
const char winusb_device_interface_guids[142] = {
  ///////////////////////////////////////
  /// WCID property descriptor
  ///////////////////////////////////////
  0x8e, 0x00, 0x00, 0x00,                           /* dwLength */
  0x00, 0x01,                                       /* bcdVersion */
  0x05, 0x00,                                       /* wIndex */
  0x01, 0x00,                                       /* wCount */
  
  ///////////////////////////////////////
  /// registry propter descriptor
  ///////////////////////////////////////
  0x84, 0x00, 0x00, 0x00,                           /* dwSize */
  0x01, 0x00, 0x00, 0x00,                           /* dwPropertyDataType */
  0x28, 0x00,                                       /* wPropertyNameLength */
  /* DeviceInterfaceGUID */
  'D', 0x00, 'e', 0x00, 'v', 0x00, 'i', 0x00,       /* wcName_20 */
  'c', 0x00, 'e', 0x00, 'I', 0x00, 'n', 0x00,       /* wcName_20 */
  't', 0x00, 'e', 0x00, 'r', 0x00, 'f', 0x00,       /* wcName_20 */
  'a', 0x00, 'c', 0x00, 'e', 0x00, 'G', 0x00,       /* wcName_20 */
  'U', 0x00, 'I', 0x00, 'D', 0x00, 0x00, 0x00,      /* wcName_20 */
  0x4e, 0x00, 0x00, 0x00,                           /* dwPropertyDataLength */
  /* {1D4B2365-4749-48EA-B38A-7C6FDDDD7E26} */
  '{', 0x00, '1', 0x00, 'D', 0x00, '4', 0x00,       /* wcData_39 */
  'B', 0x00, '2', 0x00, '3', 0x00, '6', 0x00,       /* wcData_39 */
  '5', 0x00, '-', 0x00, '4', 0x00, '7', 0x00,       /* wcData_39 */
  '4', 0x00, '9', 0x00, '-', 0x00, '4', 0x00,       /* wcData_39 */
  '8', 0x00, 'E', 0x00, 'A', 0x00, '-', 0x00,       /* wcData_39 */
  'B', 0x00, '3', 0x00, '8', 0x00, 'A', 0x00,       /* wcData_39 */
  '-', 0x00, '7', 0x00, 'C', 0x00, '6', 0x00,       /* wcData_39 */
  'F', 0x00, 'D', 0x00, 'D', 0x00, 'D', 0x00,       /* wcData_39 */
  'D', 0x00, '7', 0x00, 'E', 0x00, '2', 0x00,       /* wcData_39 */
  '6', 0x00, '}', 0x00, 0x00, 0x00,                 /* wcData_39 */
};

rt_align(4)
struct usb_os_proerty winusb_proerty[] =
{
    USB_OS_PROPERTY_DESC(USB_OS_PROPERTY_TYPE_REG_SZ,"DeviceInterfaceGUID",winusb_device_interface_guids),
};

rt_align(4)
struct usb_os_function_comp_id_descriptor winusb_func_comp_id_desc =
{
    .bFirstInterfaceNumber = USB_DYNAMIC,
    .reserved1          = 0x01,
    .compatibleID       = {'W', 'I', 'N', 'U', 'S', 'B', 0x00, 0x00},
    .subCompatibleID    = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
    .reserved2          = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
};


static rt_err_t _ep_out_handler(ufunction_t func, rt_size_t size)
{
    winusb_device_t winusb_device = (winusb_device_t)func->user_data;
    LOG_D("%s %x %d\r\n", __FUNCTION__, winusb_device->ep_out->buffer, size);
	
   /* example write back recieve data */
   rt_ssize_t win_usb_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
   win_usb_write(&winusb_device->parent, 0, winusb_device->ep_out->buffer, size);

#ifdef HG_EQ_APP_CMD_PARSE 
#define AUSYS_DA_CMD_EQ             (0x01)
#define AUSYS_DA_CMD_SAMPLE_RATE    (0x02)
#define AUSYS_DA_CMD_VOLUME         (0x03)
#define AUSYS_DA_CMD_TEST_OPEN      (0x04)
#define AUSYS_DA_CMD_TEST_CLOSE     (0x05)
#define AUSYS_DA_CMD_TEST_SINE      (0x06)


    uint32 cmd = *(uint32 *)&winusb_device->ep_out->buffer[0];
    uint32 len = *(uint32 *)&winusb_device->ep_out->buffer[4];
    uint8  *p_content = &winusb_device->ep_out->buffer[4+4];

    struct aueq_device *p_dev = (struct aueq_device*)dev_get(HG_AUEQ_DEVID);
    uint32 sample_rate = *(uint32 *)p_content;
    uint32 percent_0to100 = *(uint32 *)p_content;
    uint32 cur_volume_0to100 = 0;


    switch (cmd) {
        case (AUSYS_DA_CMD_EQ):
            if (p_dev) {
                aueq_run(p_dev, (void *)p_content, len);
            } else {
                os_printf("eq dev is NULL\r\n");
            }
            break;
        case (AUSYS_DA_CMD_SAMPLE_RATE):
            ausys_da_change_sample_rate(sample_rate);
            break;
        case (AUSYS_DA_CMD_VOLUME):
            ausys_da_get_cur_volume((uint32 *)&cur_volume_0to100);
            os_printf("cur vol:%d\r\n", cur_volume_0to100);
            ausys_da_change_volume(percent_0to100);
            break;
        case (AUSYS_DA_CMD_TEST_OPEN):
            ausys_da_test_mode(AUSYS_DA_TEST_OPEN, 0, 0, 0);
            break;
        case (AUSYS_DA_CMD_TEST_CLOSE):
            ausys_da_test_mode(AUSYS_DA_TEST_CLOSE, 0, 0, 0);
            break;
        case (AUSYS_DA_CMD_TEST_SINE):
            ausys_da_test_mode(AUSYS_DA_TEST_PLAY_SINE, 0, 0, 0);
            break;
    }
#endif

    rt_ssize_t win_usb_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    win_usb_read(&winusb_device->parent, 0, winusb_device->ep_out->buffer, 512);
    
   if(winusb_device->rx_handler != RT_NULL)
   {
       winusb_device->rx_handler(winusb_device->ep_out->buffer, size);
   }


#if ISP_TUNNING_EN
    rt_ssize_t win_usb_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    uint16 head         = *(uint16 *)&winusb_device->ep_out->buffer[0];
	if (head == isp_tunning->tunning_head)
	{
        isp_tunning->cmd_head    = head;
        isp_tunning->cmd_num     = *(uint16 *)&winusb_device->ep_out->buffer[2];
        isp_tunning->cmd_channel = *(uint16 *)&winusb_device->ep_out->buffer[4];
        isp_tunning->p_data      =  (uint16 *)&winusb_device->ep_out->buffer[8];
        isp_tunning->p_winusb    = (rt_device_t)&winusb_device->parent;
        os_sema_up(&isp_tunning->usb_cmd_sema);
	}
    win_usb_read(&winusb_device->parent, 0, winusb_device->ep_out->buffer, 512);
#endif
    return RT_EOK;
}

static rt_err_t _ep_in_handler(ufunction_t func, rt_size_t size)
{
    winusb_device_t winusb_device = (winusb_device_t)func->user_data;
    
    LOG_D("%s %x %d\r\n", __FUNCTION__, winusb_device->ep_in->buffer, size);
    if(winusb_device->tx_handler != RT_NULL)
    {
        winusb_device->tx_handler( winusb_device->ep_in->buffer, size);
    }
#if ISP_TUNNING_EN
    os_sema_up(&isp_tunning->usb_write_sema);
#endif
    return RT_EOK;
}
static ufunction_t cmd_func = RT_NULL;
static rt_err_t _ep0_cmd_handler(udevice_t device, rt_size_t size)
{
    winusb_device_t winusb_device;

    if(cmd_func != RT_NULL)
    {
        winusb_device = (winusb_device_t)cmd_func->user_data;
        cmd_func = RT_NULL;
        if(winusb_device->cmd_handler != RT_NULL)
        {
            winusb_device->cmd_handler(winusb_device->cmd_buff,size);
        }
    }
    dcd_ep0_send_status(device->dcd);
    return RT_EOK;
}
static rt_err_t _ep0_cmd_read(ufunction_t func, ureq_t setup)
{
    winusb_device_t winusb_device = (winusb_device_t)func->user_data;
    cmd_func = func;
    rt_usbd_ep0_read(func->device,winusb_device->cmd_buff,setup->wLength,_ep0_cmd_handler);
    return RT_EOK;
}
static rt_err_t _interface_handler(ufunction_t func, ureq_t setup)
{
    switch(setup->bRequest)
    {
        os_printf("winusb bRequest:%x wIndex:%x \r\n",setup->bRequest,setup->wIndex);
    case 'A':
        switch(setup->wIndex)
        {
        case 0x05:
            usbd_os_proerty_descriptor_send(func,setup,winusb_proerty,sizeof(winusb_proerty)/sizeof(winusb_proerty[0]));
            break;
        }
        break;
    case 0x0A://customer
        _ep0_cmd_read(func, setup);
        break;
    }

    return RT_EOK;
}
static rt_err_t _function_enable(ufunction_t func)
{
    RT_ASSERT(func != RT_NULL);
    
    winusb_device_t winusb_device = (winusb_device_t)func->user_data;
    LOG_D("%s\r\n", __FUNCTION__);
	/* trig recieve data when function enable */
    rt_ssize_t win_usb_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
    win_usb_read(&winusb_device->parent, 0, winusb_device->dat_buff, 512);

    
    return RT_EOK;
}
static rt_err_t _function_disable(ufunction_t func)
{
    RT_ASSERT(func != RT_NULL);
    return RT_EOK;
}

static struct ufunction_ops ops =
{
    _function_enable,
    _function_disable,
    RT_NULL,
};

static rt_err_t _winusb_descriptor_config(winusb_desc_t winusb, rt_uint8_t cintf_nr, rt_uint8_t device_is_hs)
{
#ifdef RT_USB_DEVICE_COMPOSITE
    winusb->iad_desc.bFirstInterface = cintf_nr;
#endif
    winusb->ep_out_desc.wMaxPacketSize = device_is_hs ? 512 : 64;
    winusb->ep_in_desc.wMaxPacketSize = device_is_hs ? 512 : 64;
    winusb_func_comp_id_desc.bFirstInterfaceNumber = cintf_nr;
    return RT_EOK;
}

rt_ssize_t win_usb_read(rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size)
{
	/* read & write by class, actually, all class use the same udcd */
    winusb_device_t winusb_device = (winusb_device_t)dev;
    udevice_t  device = winusb_device->device;

    //if(device->state != USB_STATE_CONFIGURED)
    if(device == NULL)
    {
        return 0;
    }

    winusb_device->ep_out->buffer = buffer;
    winusb_device->ep_out->request.buffer = buffer;
    winusb_device->ep_out->request.size = size;
    winusb_device->ep_out->request.req_type = UIO_REQUEST_READ_BEST;
    rt_usbd_io_request(device,winusb_device->ep_out,&winusb_device->ep_out->request);
    return size;
}
rt_ssize_t win_usb_write(rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size)
{
    winusb_device_t winusb_device = (winusb_device_t)dev;
    udevice_t  device = winusb_device->device;

    if (device->state != USB_STATE_CONFIGURED)
    {
        return 0;
    }

    winusb_device->ep_in->buffer = (void *)buffer;
    winusb_device->ep_in->request.buffer = winusb_device->ep_in->buffer;
    winusb_device->ep_in->request.size = size;
    winusb_device->ep_in->request.req_type = UIO_REQUEST_WRITE;
    rt_usbd_io_request(device,winusb_device->ep_in,&winusb_device->ep_in->request);
    return size;
}
static rt_err_t  win_usb_control(rt_device_t dev, int cmd, void *args)
{
    //udcd_t udcd = (struct usb_device *)dev_get(HG_USB_DEV_CONTROLLER_DEVID);

    winusb_device_t winusb_device = (winusb_device_t)dev;
    //if(RT_DEVICE_CTRL_CONFIG == cmd)
    {
        winusb_device->cmd_handler = (void(*)(rt_uint8_t*,rt_size_t))args;
    }
    return RT_EOK;
}

#ifdef RT_USING_DEVICE_OPS
const static struct rt_device_ops winusb_device_ops =
{
    RT_NULL,
    RT_NULL,
    RT_NULL,
    win_usb_read,
    win_usb_write,
    win_usb_control,
};
#endif

static rt_err_t rt_usb_winusb_init(ufunction_t func)
{
//    rt_err_t ret;

    //winusb_device_t winusb_device   = (winusb_device_t)func->user_data;
//    struct usb_device *p_usb_d = (struct usb_device *)dev_get(HG_USB_DEV_CONTROLLER_DEVID);
//    ret = dev_register(HG_USB_DEV_CONTROLLER_DEVID, (struct dev_obj *)p_usb_d);

    return 0;
}

udevice_t g_winusb_device = NULL;

ufunction_t rt_usbd_function_winusb_create(udevice_t device)
{
    os_printf("%s %d\n",__FUNCTION__,__LINE__);   

    ufunction_t         func;
    winusb_device_t     winusb_device;

    uintf_t             winusb_intf;
    ualtsetting_t       winusb_setting;
    winusb_desc_t       winusb_desc;

    /* parameter check */
    RT_ASSERT(device != RT_NULL);
    g_winusb_device = device;
    /* set usb device string description */
#ifdef RT_USB_DEVICE_COMPOSITE
    rt_usbd_device_set_interface_string(device, WINUSB_INTF_STR_INDEX, _ustring[2]);
    rt_usbd_device_set_interface_string(device, USB_STRING_OS_INDEX, _ustring[6]);
#else
    rt_usbd_device_set_string(device, _ustring);
    rt_usbd_device_set_interface_string(device, USB_STRING_OS_INDEX, _ustring[6]);
#endif

    /* create a cdc function */
    func = rt_usbd_function_new(device, &dev_desc, &ops);
    rt_usbd_device_set_qualifier(device, &dev_qualifier);

    /* allocate memory for cdc vcom data */
    winusb_device = (winusb_device_t)rt_malloc(sizeof(struct winusb_device));
    if (winusb_device == NULL)
        return RT_NULL;
    rt_memset((void *)winusb_device, 0, sizeof(struct winusb_device));
    func->user_data = (void*)winusb_device;
    winusb_device->user_data = (void *)func;
    winusb_device->device = device;
    /* create an interface object */
    winusb_intf = rt_usbd_interface_new(device, _interface_handler);

    /* create an alternate setting object */
    winusb_setting = rt_usbd_altsetting_new(sizeof(struct winusb_descriptor));

    /* config desc in alternate setting */
    rt_usbd_altsetting_config_descriptor(winusb_setting, &_winusb_desc, (rt_off_t)&((winusb_desc_t)0)->intf_desc);

    /* configure the hid interface descriptor */
    _winusb_descriptor_config(winusb_setting->desc, winusb_intf->intf_num, device->dcd->device_is_hs);

    /* create endpoint */
    winusb_desc = (winusb_desc_t)winusb_setting->desc;
    winusb_device->ep_out = rt_usbd_endpoint_new(&winusb_desc->ep_out_desc, _ep_out_handler);
    winusb_device->ep_in  = rt_usbd_endpoint_new(&winusb_desc->ep_in_desc, _ep_in_handler);

    /* add the int out and int in endpoint to the alternate setting */
    rt_usbd_altsetting_add_endpoint(winusb_setting, winusb_device->ep_out);
    rt_usbd_altsetting_add_endpoint(winusb_setting, winusb_device->ep_in);

    /* add the alternate setting to the interface, then set default setting */
    rt_usbd_interface_add_altsetting(winusb_intf, winusb_setting);
    rt_usbd_set_altsetting(winusb_intf, 0);

    /* add the interface to the mass storage function */
    rt_usbd_function_add_interface(func, winusb_intf);

    rt_usbd_os_comp_id_desc_add_os_func_comp_id_desc(device->os_comp_id_desc, &winusb_func_comp_id_desc);
    /* initilize winusb */
    rt_usb_winusb_init(func);
    return func;
}

struct udclass winusb_class =
{
    .rt_usbd_function_create = rt_usbd_function_winusb_create
};

int rt_usbd_winusb_class_register(rt_uint32_t dev_id)
{
    rt_usbd_class_register(&winusb_class, dev_id);
    return 0;
}
INIT_PREV_EXPORT(rt_usbd_winusb_class_register);

#endif