#include "usb_device.h"
#include <stdbool.h>
#include <stdatomic.h>

#ifndef USB_DEVICE_CDC_H
#define USB_DEVICE_CDC_H

#define USB_CLASS_CDC_CODE 0x02
#define USB_CLASS_DATA_CODE 0x0A
#define USB_SUBCLASS_CDC_ACM_CODE 0x02

/**
 * @var USB_CLASS_CDC_ACM
 * @brief Vtable of usb cdc acm class.
 * @see usb_cdc_acm_configure to call after usb_device_init call to configure all descriptors.
 * The usb cdc class is a standard usb class for communications and data transfer.
 * acm stands for Abstract Control Model. It is used mainly in older modems to convert uart
 * to usb. Here cdc acm is used since it is widely supported on computers, but there are no
 * supported cdc acm commands. AT commands are not handled.
 */
extern usb_class_vtable_t USB_CLASS_CDC_ACM;

typedef enum __attribute__((packed)) {
  SEND_ENCAPSULATED_COMMAND = 0,
  GET_ENCAPSULATED_RESPONSE = 1,
  /* SET_COMM_FEATURE = 2, */
  /* GET_COMM_FEATURE = 3, */
  /* CLEAR_COMM_FEATURE = 4, */
  /* SET_AUX_LINE_STATE = 0x10, */
  /* SET_HOOK_STATE = 0x11, */
  /* PULSE_SETUP = 0x12, */
  /* SEND_PULSE = 0x13, */
  /* SET_PULSE_TIME = 0x14, */
  /* RING_AUX_JACK = 0x15, */
  /* SET_LINE_CODING = 0x20, */
  /* GET_LINE_CODING = 0x21, */
} usb_cdc_request_code_type_t;

typedef enum __attribute__((packed)) {
  CS_INTERFACE = 0x24,
  CS_ENDPOINT = 0x25
} usb_cdc_functional_descriptor_type_t;

typedef enum __attribute__((packed)) {
  HEADER_FUNCTIONAL_DESCRIPTOR_FUNCTIONAL_DESCRIPTOR = 0x00,
  CALL_MANAGEMENT_FUNCTIONAL_FUNCTIONAL_DESCRIPTOR = 0x01,
  ABSTRACT_CONTROL_MANAGEMENT_FUNCTIONAL_DESCRIPTOR = 0x02,
  DIRECT_LINE_MANAGEMENT_FUNCTIONAL_DESCRIPTOR = 0x03,
  TELEPHONE_RINGER_FUNCTIONAL_DESCRIPTOR = 0x04,
  TELEPHONE_CALL_AND_LINE_STATE_REPORTING_CAPABILITIES_FUNCTIONAL_DESCRIPTOR = 0x05,
  UNION_FUNCTIONAL_DESCRIPTOR = 0x06,
  CONTRY_SELECTION_FUNCTIONAL_DESCRIPTOR = 0x07,
  TELEPHONE_OPERATIONAL_MODES_FUNCTIONAL_DESCRIPTOR = 0x08,
  USB_TERMINAL_FUNCTIONAL_DESCRIPTOR = 0x09,
  NETWORK_CHANNEL_FUNCTIONAL_DESCRIPTOR = 0x0A,
  PROTOCOL_UNIT_FUNCTIONAL_DESCRIPTOR = 0x0B,
  EXTENSION_UNIT_FUNCTIONAL_DESCRIPTOR = 0x0C,
  MULTI_CHANNEL_MANAGEMENT_FUNCTIONAL_DESCRIPTOR = 0x0D,
  CAPI_CONTROL_MANAGEMENT_FUNCTIONAL_DESCRIPTOR = 0x0E,
  ETHERNET_NETWORKING_FUNCTIONAL_DESCRIPTOR = 0x0F,
  ATM_NETWORKING_FUNCTIONAL_DESCRIPTOR = 0x10,
  WIRELESS_HANDSET_CONTROL_MODEL_FUNCTIONAL_DESCRIPTOR = 0x11,
} usb_cdc_functional_descriptor_subtype_t;

#pragma GCC diagnostic error "-Wpadded"
typedef struct __attribute__((packed)) {
  uint8_t bFunctionLength;
  usb_cdc_functional_descriptor_type_t bDescriptorType;
  usb_cdc_functional_descriptor_subtype_t bDescriptorSubType;
} usb_cdc_functional_descriptor_header_t;
_Static_assert(sizeof(usb_cdc_functional_descriptor_header_t) == 3, "Size check");

typedef struct __attribute__((packed)) {
  usb_cdc_functional_descriptor_header_t header;
  uint16_t bcdCDC;
} usb_cdc_header_functional_decriptor_t;
_Static_assert(sizeof(usb_cdc_header_functional_decriptor_t) == 5, "Size check");

typedef struct {
  usb_cdc_functional_descriptor_header_t header;
  uint8_t bmCapabilities;
} usb_cdc_acm_functional_decriptor_t;
_Static_assert(sizeof(usb_cdc_acm_functional_decriptor_t) == 4, "Size check");

typedef struct {
  usb_cdc_functional_descriptor_header_t header;
  uint8_t bControlInterface;
  uint8_t bSubordinateInterface0;
} usb_cdc_union_functional_decriptor_t;
_Static_assert(sizeof(usb_cdc_union_functional_decriptor_t) == 5, "Size check");

typedef struct {
  usb_cdc_functional_descriptor_header_t header;
  uint8_t bmCapabilities;
  uint8_t bDataInterface;
} usb_cdc_call_management_functional_decriptor_t;
_Static_assert(sizeof(usb_cdc_call_management_functional_decriptor_t) == 5, "Size check");

typedef uint16_t (*cdc_receive_callback_t)(usb_device_t* device, uint8_t* data, uint16_t count);
typedef uint8_t* (*cdc_receive_location_callback_t)(usb_device_t* device, uint16_t count);

/* typedef enum { */
/*   CDC_STATE_NONE, */
/*   CDC_STATE_GOT_DATA, */
/*   CDC_STATE_FULL_FIFO, */
/* } cdc_rx_state_t; */

typedef enum {
  CDC_TX_STATE_NONE,
  CDC_TX_STATE_SENDING,
  CDC_TX_STATE_,
} cdc_tx_state_t;

#pragma GCC diagnostic ignored "-Wpadded"
typedef struct {
  usb_class_header_t header;
  uint8_t functional_descriptors_count;
  usb_cdc_functional_descriptor_header_t** functional_descriptors;

  cdc_receive_callback_t receive_callback;
  cdc_receive_location_callback_t receive_location_callback;

  // Internal state.
  queue_t* rx_buffer;

  cdc_tx_state_t tx_state;

  uint8_t got_setup;

  bool endpoint_nak;
  uint32_t lost_data;
  bool reenabled_endpoint;
} usb_device_cdc_t;

/**
 * @brief Configures cdc acm descriptors
 * @details All the descriptors for cdc acm device are initialized here.
 * That means that after call to this function, usb_device_setup can be safely
 * called, and all setup commands handled.
 * @param[in,out] device The usb device.
 * @param[in] rx_queue_size The size, in bytes, of the rx queue. When the queue is full, data cannot be received. There should not be any data lost, but it's not a 100% guarantee for now.
 */
void cdc_acm_configure(usb_device_t *device, uint16_t rx_queue_size);

/**
 * @brief Sets a callback that will be called when data are received, with the data.
 * @details The callback bypasses the need for a queue. Instead of putting the data to queue, the callback is first called with the data. The callback will return number of bytes it could read. The rest will be put to the queue.
 * @param[in,out] device The device.
 * @param[in] callback The new callback.
 */
void cdc_data_set_receive_callback(usb_device_t *device,
                                   cdc_receive_callback_t callback);

/**
 * @brief Sets a callback that will be called when data are received, to allow forwarding the data to custom buffer.
 * @details The callback bypasses the need for queue or putting the data to temporary buffer by putting the data where application wants them right away.
 * @param[in,out] device The device.
 * @param[in] callback The new callback.
 */
void cdc_data_set_receive_location_callback(usb_device_t *device,
                                            cdc_receive_location_callback_t callback);

/**
 * @brief Sends data, waiting for all of them to be sent.
 * @param[in,out] device The usb device, using cdc class.
 * @param[out] data The data to send to the host.
 * @param[in] size The size of the data.
 * @return The number of bytes sent. -1 on error.
 */
int32_t cdc_data_send_blocking(usb_device_t *device, uint8_t *data, uint16_t size);

/**
 * @brief Sends data, not waiting for them to be sent.
 * @param[in,out] device The usb device, using cdc class.
 * @param[out] data The data to send to the host.
 * @param[in] size The size of the data.
 * @return The number of bytes sent. -1 on error.
 */
int32_t cdc_data_send(usb_device_t* device, uint8_t* data, uint16_t size);

/**
 * @brief Reads data from the receive queue.
 * @param[in,out] device The device
 * @param[out] buffer Pointer to buffer to save data to.
 * @param[in] max_size The size of the buffer
 * @return Description
 */
uint16_t cdc_data_receive(usb_device_t* device, uint8_t* buffer, uint16_t max_size);

/* bool cdc_got_params(usb_device_t* device); */

#endif // USB_DEVICE_CDC_H