#define CDC_IN_FRAME_INTERVAL          5    /* Number of frames between IN transfers */
#define APP_RX_DATA_SIZE               2048 /* Total size of IN buffer: APP_RX_DATA_SIZE*8/MAX_BAUDARATE*1000 should be > CDC_IN_FRAME_INTERVAL */

#pragma once

#define USB_XCH_QUEUE_SIZE 0x3000//0xD00
#define USB_QUEUE_CELL_SIZE 64

class CUSB_Queue
{
public:
uint32_t m_Data[USB_XCH_QUEUE_SIZE >> 2];
volatile uint32_t m_Tail;
volatile uint32_t m_Head;
public:
volatile uint32_t m_NumEntries;
CUSB_Queue() : m_Tail(0), m_Head(0), m_NumEntries(0) {};

int32_t Queue_put(uint32_t *data);

__attribute__( ( always_inline ) )uint32_t *Queue_puti(void)
{
uint32_t res = 0;

if(m_NumEntries < (USB_XCH_QUEUE_SIZE >> 6))
{
res = (uint32_t)m_Data + m_Head;
m_Head = (m_Head + USB_QUEUE_CELL_SIZE) % USB_XCH_QUEUE_SIZE;
m_NumEntries++;
}
return (uint32_t *)res;
};

volatile int32_t Queue_get(uint32_t *inf);

__attribute__( ( always_inline ) )uint32_t *Queue_geti(void)
{
uint32_t res = 0;

if(m_NumEntries)
{
res = (uint32_t)m_Data + m_Tail;
m_Tail = (m_Tail + USB_QUEUE_CELL_SIZE) % USB_XCH_QUEUE_SIZE;
m_NumEntries--;
}
return (uint32_t *)res;
};

__attribute__( ( always_inline ) )void Queue_validate(void)
{
m_NumEntries++;
};

void Queue_Clear(void)
{
m_NumEntries = 0;
s_memset(m_Data, 0x05, USB_XCH_QUEUE_SIZE);
m_Tail = 0;
m_Head = 0;
};
};

extern CUSB_Queue USB_TxQueue;
extern CUSB_Queue USB_RxQueue;

//===========================

#include "usb_queue.h"


int32_t CUSB_Queue::Queue_put(uint32_t *inf)
{
int32_t i = 100000;
do
{
uint32_t *buffer = Queue_puti();
if(buffer)
{
s_memcpy(buffer, inf, USB_QUEUE_CELL_SIZE);
return NO_ERR;
}
i--;
}
while(i > 0);
return -1;
}

volatile int32_t CUSB_Queue::Queue_get(uint32_t *inf)
{
uint32_t *buffer = Queue_geti();

if(buffer)
{
s_memcpy(inf, buffer, USB_QUEUE_CELL_SIZE);
return NO_ERR;
}
return -1;
}


CUSB_Queue USB_TxQueue;
CUSB_Queue USB_RxQueue;

    while(1)
    {
        if (send_data_over_usb) {
        uint8_t i;
        for (i = 0; i < usb_tx_packets; i ++) {
            DWTreset;
            USB_DataTx(&sensors_data[usb_tx_packet_size / 2 * i], usb_tx_packet_size);
            while (tx_data_senging) {}
        }
        USB_DataTx(&sensors_data[usb_tx_packet_size / 2 * usb_tx_packets], usb_tx_tail);
        while (tx_data_senging) {}
        send_data_over_usb = 0;
        }
    }

void USB_DataTx(uint8_t* Buf, uint32_t Len)
{
    VCP_DataTx((uint8_t*)Buf, Len);
    tx_data_senging = 1;
}

static uint8_t  usbd_cdc_DataIn (void *pdev, uint8_t epnum)
{
  uint16_t USB_Tx_ptr;
  uint16_t USB_Tx_length;

  if (USB_Tx_State == 1)
  {
    if (APP_Rx_length == 0)
    {
      USB_Tx_State = 0;
      tx_data_senging = 0;
    }
    else
    {
      if (APP_Rx_length > CDC_DATA_IN_PACKET_SIZE){
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = CDC_DATA_IN_PACKET_SIZE;
        
        APP_Rx_ptr_out += CDC_DATA_IN_PACKET_SIZE;
        APP_Rx_length -= CDC_DATA_IN_PACKET_SIZE;    
      }
      else
      {
        USB_Tx_ptr = APP_Rx_ptr_out;
        USB_Tx_length = APP_Rx_length;
        
        APP_Rx_ptr_out += APP_Rx_length;
        APP_Rx_length = 0;
      }
      
      /* Prepare the available data buffer to be sent on IN endpoint */
      DCD_EP_Tx (pdev,
                 CDC_IN_EP,
                 (uint8_t*)&APP_Rx_Buffer[USB_Tx_ptr],
                 USB_Tx_length);
    }
  }  
  
  return USBD_OK;
}