#pragma once

#include "bk_dm_bluetooth_types.h"

#ifdef __cplusplus
extern "C" {
#endif


/// subclass of hid device
#define BK_HID_CLASS_UNKNOWN      (0x00<<2)           /*!< unknown HID device subclass */
#define BK_HID_CLASS_JOS          (0x01<<2)           /*!< joystick */
#define BK_HID_CLASS_GPD          (0x02<<2)           /*!< game pad */
#define BK_HID_CLASS_RMC          (0x03<<2)           /*!< remote control */
#define BK_HID_CLASS_SED          (0x04<<2)           /*!< sensing device */
#define BK_HID_CLASS_DGT          (0x05<<2)           /*!< digitizer tablet */
#define BK_HID_CLASS_CDR          (0x06<<2)           /*!< card reader */
#define BK_HID_CLASS_KBD          (0x10<<2)           /*!< keyboard */
#define BK_HID_CLASS_MIC          (0x20<<2)           /*!< pointing device */
#define BK_HID_CLASS_COM          (0x30<<2)           /*!< combo keyboard/pointing */

/**
 * @brief HIDD handshake result code
 */
typedef enum {
    BK_HID_PAR_HANDSHAKE_RSP_SUCCESS = 0,                 /*!< successful */
    BK_HID_PAR_HANDSHAKE_RSP_NOT_READY = 1,               /*!< not ready, device is too busy to accept data */
    BK_HID_PAR_HANDSHAKE_RSP_ERR_INVALID_REP_ID = 2,      /*!< invalid report ID */
    BK_HID_PAR_HANDSHAKE_RSP_ERR_UNSUPPORTED_REQ = 3,     /*!< device does not support the request */
    BK_HID_PAR_HANDSHAKE_RSP_ERR_INVALID_PARAM = 4,       /*!< parameter value is out of range or inappropriate */
    BK_HID_PAR_HANDSHAKE_RSP_ERR_UNKNOWN = 14,            /*!< device could not identify the error condition */
    BK_HID_PAR_HANDSHAKE_RSP_ERR_FATAL = 15,              /*!< restart is essential to resume functionality */
} bk_hidd_handshake_error_t;

/**
 * @brief HIDD message types
 */
typedef enum {
    BK_HIDD_MESSAGE_TYPE_HANDSHAKE = 0,                     /*!< handshake type */
    BK_HIDD_MESSAGE_TYPE_HID_CONTROL,                       /*!< hid control type */
    BK_HIDD_MESSAGE_TYPE_GET_REPORT = 4,                    /*!< get report */
    BK_HIDD_MESSAGE_TYPE_SET_REPORT,                        /*!< set report */
    BK_HIDD_MESSAGE_TYPE_GET_PROTOCOL,                      /*!< get protocol */
    BK_HIDD_MESSAGE_TYPE_SET_PROTOCOL,                      /*!< set protocol */
    BK_HIDD_MESSAGE_TYPE_GET_IDLE,                          /*!< get idle [DEPRECATED] */
    BK_HIDD_MESSAGE_TYPE_SET_IDLE,                          /*!< set idle [DEPRECATED] */
    BK_HIDD_MESSAGE_TYPE_DATA,                              /*!< data intr */
} bk_hidd_message_type_t;

/**
 * @brief HIDD report types
 */
typedef enum {
    BK_HIDD_REPORT_TYPE_RESERVED,                   /*!< reserved*/
    BK_HIDD_REPORT_TYPE_INPUT,                      /*!< input report */
    BK_HIDD_REPORT_TYPE_OUTPUT,                     /*!< output report */
    BK_HIDD_REPORT_TYPE_FEATURE,                    /*!< feature report */
} bk_hidd_report_type_t;

/**
 * @brief HIDD control operation
 */
typedef enum {
    BK_HIDD_CTRL_OP_NOP,                            /*!< no operation */
    BK_HIDD_CTRL_OP_HARD_RESET,                     /*!< hadr reset */
    BK_HIDD_CTRL_OP_SOFT_RESET,                     /*!< soft reset */
    BK_HIDD_CTRL_OP_SUSPEND,                        /*!< suspend */
    BK_HIDD_CTRL_OP_EXIT_SUSPEND,                   /*!< exit suspend */
} bk_hidd_ctrl_op_t;


/**
 * @brief HIDD connection state
 */
typedef enum {
    BK_HIDD_CONN_STATE_CONNECTED,                   /*!< HID connection established */
    BK_HIDD_CONN_STATE_CONNECTING,                  /*!< connection to remote Bluetooth device */
    BK_HIDD_CONN_STATE_DISCONNECTED,                /*!< connection released */
    BK_HIDD_CONN_STATE_DISCONNECTING,               /*!< disconnecting to remote Bluetooth device*/
    BK_HIDD_CONN_STATE_UNKNOWN,                     /*!< unknown connection state */
} bk_hidd_connection_state_t;

/**
 * @brief HID device protocol modes
 */
typedef enum {
    BK_HIDD_REPORT_MODE = 0x00,                     /*!< Report Protocol Mode */
    BK_HIDD_BOOT_MODE = 0x01,                       /*!< Boot Protocol Mode */
    BK_HIDD_UNSUPPORTED_MODE = 0xff,                /*!< unsupported */
} bk_hidd_protocol_mode_t;

/**
 * @brief HID Boot Protocol report IDs
 */
typedef enum {
    BK_HIDD_BOOT_REPORT_ID_KEYBOARD = 1,            /*!< report ID of Boot Protocol keyboard report */
    BK_HIDD_BOOT_REPORT_ID_MOUSE = 2,               /*!< report ID of Boot Protocol mouse report */
} bk_hidd_boot_report_id_t;

/**
 * @brief HID Boot Protocol report size including report ID
 */
enum {
    BK_HIDD_BOOT_REPORT_SIZE_KEYBOARD = 9,          /*!< report size of Boot Protocol keyboard report */
    BK_HIDD_BOOT_REPORT_SIZE_MOUSE = 4,             /*!< report size of Boot Protocol mouse report */
};

/**
 * @brief HID device characteristics for SDP server
 */
typedef struct {
    char *name;                                     /*!< service name */
    char *description;                              /*!< service description */
    char *provider;                                 /*!< provider name */
    uint8_t *subclass;                              /*!< HID device subclass */
    uint8_t *desc_list;                             /*!< HID descriptor list */
    int desc_list_len;                              /*!< size in bytes of HID descriptor list */
} bk_hidd_app_param_t;

/**
 * @brief HIDD Quality of Service parameters negotiated over L2CAP
 */
typedef struct {
    uint8_t service_type;                            /*!< the level of service, 0 indicates no traffic */
    uint32_t token_rate;                             /*!< token rate in bytes per second, 0 indicates "don't care" */
    uint32_t token_bucket_size;                      /*!< limit on the burstness of the application data */
    uint32_t peak_bandwidth;                         /*!< bytes per second, value 0 indicates "don't care" */
    uint32_t access_latency;                         /*!< maximum acceptable delay in microseconds */
    uint32_t delay_variation;                        /*!< the difference in microseconds between the max and min delay */
} bk_hidd_qos_param_t;

/**
 * @brief HID device callback function events
 */
typedef enum {
    BK_HIDD_INIT_EVT = 0,       /*!< When HID device is initialized, the event comes */
    BK_HIDD_DEINIT_EVT,         /*!< When HID device is deinitialized, the event comes */
    BK_HIDD_REGISTER_APP_EVT,   /*!< When HID device application registered, the event comes */
    BK_HIDD_UNREGISTER_APP_EVT, /*!< When HID device application unregistered, the event comes */
    BK_HIDD_OPEN_EVT,           /*!< When HID device connection to host opened, the event comes */
    BK_HIDD_CLOSE_EVT,          /*!< When HID device connection to host closed, the event comes */
    BK_HIDD_SEND_REPORT_EVT,    /*!< When HID device send report to lower layer, the event comes */
    BK_HIDD_REPORT_ERR_EVT,     /*!< When HID device report handshanke error to lower layer, the event comes */
    BK_HIDD_GET_REPORT_EVT,     /*!< When HID device receives GET_REPORT request from host, the event comes */
    BK_HIDD_SET_REPORT_EVT,     /*!< When HID device receives SET_REPORT request from host, the event comes */
    BK_HIDD_GET_PROTOCOL_EVT,   /*!< When HID device receives GET_PROTOCOL request from host, the event comes */
    BK_HIDD_SET_PROTOCOL_EVT,   /*!< When HID device receives SET_PROTOCOL request from host, the event comes */
    BK_HIDD_GET_IDLE_EVT,       /*!< When HID device receives GET_IDLE request from host, the event comes */
    BK_HIDD_SET_IDLE_EVT,       /*!< When HID device receives SET_IDLE request from host, the event comes */
    BK_HIDD_INTR_DATA_EVT,      /*!< When HID device receives DATA from host on intr, the event comes */
    BK_HIDD_CONTROL_EVT,        /*!< When HID device receives HID_CONTROL from host, the event comes */
    BK_HIDD_VC_UNPLUG_EVT,      /*!< When HID device initiates Virtual Cable Unplug, the event comes */
    BK_HIDD_API_ERR_EVT         /*!< When HID device has API error, the event comes */
} bk_hidd_cb_event_t;

typedef enum {
    BK_HIDD_SUCCESS,
    BK_HIDD_ERROR,         /*!< general BK HD error */
    BK_HIDD_NO_RES,        /*!< out of system resources */
    BK_HIDD_BUSY,          /*!< Temporarily can not handle this request. */
    BK_HIDD_NO_DATA,       /*!< No data. */
    BK_HIDD_NEED_INIT,     /*!< HIDD module shall init first */
    BK_HIDD_NEED_DEINIT,   /*!< HIDD module shall deinit first */
    BK_HIDD_NEED_REG,      /*!< HIDD module shall register first */
    BK_HIDD_NEED_DEREG,    /*!< HIDD module shall deregister first */
    BK_HIDD_NO_CONNECTION, /*!< connection may have been closed */
    BK_HIDD_NO_ACL_LINK,   /*!< Baseband acl link not exist */
    BK_HIDD_FAIL,          /*!< HIDD Fail */
} bk_hidd_status_t;

/**
 * @brief HID device callback parameters union
 */
typedef union {
    /**
     * @brief BK_HIDD_INIT_EVT
     */
    struct hidd_init_evt_param {
        bk_hidd_status_t status; /*!< operation status */
    } init;                       /*!< HIDD callback param of BK_HIDD_INIT_EVT */

    /**
     * @brief BK_HIDD_DEINIT_EVT
     */
    struct hidd_deinit_evt_param {
        bk_hidd_status_t status; /*!< operation status */
    } deinit;                     /*!< HIDD callback param of BK_HIDD_DEINIT_EVT */

    /**
     * @brief BK_HIDD_REGISTER_APP_EVT
     */
    struct hidd_register_app_evt_param {
        bk_hidd_status_t status; /*!< operation status */
        bool in_use;              /*!< indicate whether use virtual cable plug host address */
        bk_bd_addr_t bd_addr;    /*!< host address */
    } register_app;               /*!< HIDD callback param of BK_HIDD_REGISTER_APP_EVT */

    /**
     * @brief BK_HIDD_UNREGISTER_APP_EVT
     */
    struct hidd_unregister_app_evt_param {
        bk_hidd_status_t status; /*!< operation status         */
    } unregister_app;             /*!< HIDD callback param of BK_HIDD_UNREGISTER_APP_EVT */

    /**
     * @brief BK_HIDD_OPEN_EVT
     */
    struct hidd_open_evt_param {
        bk_hidd_status_t status;                /*!< operation status         */
        bk_hidd_connection_state_t conn_status; /*!< connection status */
        bk_bd_addr_t bd_addr;                   /*!< host address */
    } open;                                      /*!< HIDD callback param of BK_HIDD_OPEN_EVT */

    /**
     * @brief BK_HIDD_CLOSE_EVT
     */
    struct hidd_close_evt_param {
        bk_hidd_status_t status;                /*!< operation status         */
        bk_hidd_connection_state_t conn_status; /*!< connection status        */
    } close;                                     /*!< HIDD callback param of BK_HIDD_CLOSE_EVT */

    /**
     * @brief BK_HIDD_SEND_REPORT_EVT
     */
    struct hidd_send_report_evt_param {
        bk_hidd_status_t status;                /*!< operation status         */
        uint8_t report_id;                      /*!< report id         */
    } send_report;                              /*!< HIDD callback param of BK_HIDD_SEND_REPORT_EVT */

    /**
     * @brief BK_HIDD_REPORT_ERR_EVT
     */
    struct hidd_report_err_evt_param {
        bk_hidd_status_t status; /*!< operation status         */
        uint8_t reason;           /*!< lower layer failed reason(ref hiddefs.h)           */
    } report_err;                 /*!< HIDD callback param of BK_HIDD_REPORT_ERR_EVT */

    /**
     * @brief BK_HIDD_GET_REPORT_EVT
     */
    struct hidd_get_report_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type        */
        bk_hidd_report_type_t report_type;      /*!< report type        */
        uint8_t report_id;                      /*!< report id         */
        uint16_t buffer_size;                   /*!< buffer size         */
    } get_report;                               /*!< HIDD callback param of BK_HIDD_GET_REPORT_EVT */

    /**
     * @brief BK_HIDD_SET_REPORT_EVT
     */
    struct hidd_set_report_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type        */
        bk_hidd_report_type_t report_type;      /*!< report type        */
        uint8_t report_id;                      /*!< report id         */
        uint16_t len;                           /*!< set_report data length         */
        uint8_t *data;                          /*!< set_report data pointer         */
    } set_report;                               /*!< HIDD callback param of BK_HIDD_SET_REPORT_EVT */

    /**
     * @brief BK_HIDD_SET_PROTOCOL_EVT
     */
    struct hidd_set_protocol_evt_param {
        bk_hidd_protocol_mode_t protocol_mode; /*!< protocol mode        */
    } set_protocol;                             /*!< HIDD callback param of BK_HIDD_SET_PROTOCOL_EVT */

    /**
     * @brief BK_HIDD_GET_PROTOCOL_EVT
     */
    struct hidd_get_protocol_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type        */
    } get_protocol;                             /*!< HIDD callback param of BK_HIDD_GET_PROTOCOL_EVT */

     /**
     * @brief BK_HIDD_GET_IDLE_EVT
     */
    struct hidd_get_idle_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type        */
    } get_idle;                             /*!< HIDD callback param of BK_HIDD_GET_IDLE_EVT */


     /**
     * @brief BK_HIDD_SET_IDLE_EVT
     */
    struct hidd_set_idle_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type       */
        uint8_t idle;                           /*!< idle rate          */
    } set_idle;                                 /*!< HIDD callback param of BK_HIDD_SET_IDLE_EVT */

    /**
     * @brief BK_HIDD_INTR_DATA_EVT
     */
    struct hidd_intr_data_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type        */
        bk_hidd_report_type_t report_type;      /*!< report type        */
        uint8_t report_id;                      /*!< interrupt channel report id         */
        uint16_t len;                           /*!< interrupt channel report data length         */
        uint8_t *data;                          /*!< interrupt channel report data pointer         */
    } intr_data;                                /*!< HIDD callback param of BK_HIDD_INTR_DATA_EVT */

    /**
     * @brief BK_HIDD_CTRL_OP_EVT
     */
    struct hidd_ctrl_op_evt_param {
        bk_hidd_message_type_t message_type;    /*!< message type        */
        bk_hidd_ctrl_op_t op;                   /*!< ctral operation     */
    } ctrl_op;                                  /*!< HIDD callback param of BK_HIDD_INTR_DATA_EVT */
    
    /**
     * @brief BK_HIDD_VC_UNPLUG_EVT
     */
    struct hidd_vc_unplug_param {
        bk_hidd_status_t status;                /*!< operation status         */
        bk_hidd_connection_state_t conn_status; /*!< connection status        */
    } vc_unplug;                                 /*!< HIDD callback param of BK_HIDD_VC_UNPLUG_EVT */
} bk_hidd_cb_param_t;

/**
 * @brief           HID device callback function type.
 * @param           event: Event type
 * @param           param: Point to callback parameter, currently is union type
 */
typedef void (*bk_hd_cb_t)(bk_hidd_cb_event_t event, bk_hidd_cb_param_t *param);

/**
 * @brief           This function is called to init callbacks with HID device module.
 *
 * @param[in]       callback: pointer to the init callback function.
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_register_callback(bk_hd_cb_t callback);

/**
 * @brief           Initializes HIDD interface. This function should be called after bk_bluedroid_init() and
 *                  bk_bluedroid_enable() success, and should be called after bk_bt_hid_device_register_callback.
 *                  When the operation is complete, the callback function will be called with BK_HIDD_INIT_EVT.
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_init(void);

/**
 * @brief           De-initializes HIDD interface. This function should be called after bk_bluedroid_init() and
 *                  bk_bluedroid_enable() success, and should be called after bk_bt_hid_device_init(). When the
 *                  operation is complete, the callback function will be called with BK_HIDD_DEINIT_EVT.
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_deinit(void);

/**
 * @brief           Registers HIDD parameters with SDP and sets l2cap Quality of Service. This function should be
 *                  called after bk_bluetooth_init() success, and should be called after
 *                  bk_bt_hid_device_init(). When the operation is complete, the callback function will be called
 *                  with BK_HIDD_REGISTER_APP_EVT.
 *
 * @param[in]       app_param: HIDD parameters
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_register_app(bk_hidd_app_param_t *app_param);

/**
 * @brief           Removes HIDD parameters from SDP and resets l2cap Quality of Service. This function should be
 *                  called after bk_bluetooth_init() success, and should be called after
 *                  bk_bt_hid_device_init(). When the operation is complete, the callback function will be called
 *                  with BK_HIDD_UNREGISTER_APP_EVT.
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_unregister_app(void);

/**
 * @brief           Connects to the peer HID Host with virtual cable. This function should be called after
 *                  bk_bluetooth_init() success, and should be called after bk_bt_hid_device_init().
 *                  When the operation is complete, the callback function will be called with BK_HIDD_OPEN_EVT.
 *
 * @param[in]       bd_addr: Remote host bluetooth device address.
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_connect(bk_bd_addr_t bd_addr);

/**
 * @brief           Disconnects from the currently connected HID Host. This function should be called after
 *                  bk_bluetooth_init() success, and should be called after bk_bt_hid_device_init().
 *                  When the operation is complete, the callback function will be called with BK_HIDD_CLOSE_EVT.
 *
 * @note            The disconnect operation will not remove the virtually cabled device. If the connect request from the
 *                  different HID Host, it will reject the request.
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_disconnect(void);

/**
 * @brief           Sends HID report to the currently connected HID Host. This function should be called after
 *                  bk_bluetooth_init() success, and should be called after bk_bt_hid_device_init().
 *                  When the operation is complete, the callback function will be called with BK_HIDD_SEND_REPORT_EVT.
 *
 * @param[in]       len: length of report
 * @param[in]       data: report data
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_send_report(uint16_t len, uint8_t *data);

/**
 * @brief           Sends HID Handshake with error info for invalid set_report to the currently connected HID Host.
 *                  This function should be called after bk_bluetooth_init() success, and
 *                  should be called after bk_bt_hid_device_init(). When the operation is complete, the callback
 *                  function will be called with BK_HIDD_REPORT_ERR_EVT.
 *
 * @param[in]       message_type: type of hid message
 * @param[in]       res_status: response status
 * @param[in]       len: response data len 
 * @param[in]       data: response data
 *
 * @return
 *                  - BK_OK: success
 *                  - other: failed 
 */
bk_err_t bk_bt_hid_device_send_response(uint8_t message_type, uint8_t res_status, uint16_t len, uint8_t* data);

/**
 * @brief           Remove the virtually cabled device. This function should be called after bk_bluetooth_init()
 *                  success, and should be called after bk_bt_hid_device_init(). When the
 *                  operation is complete, the callback function will be called with BK_HIDD_VC_UNPLUG_EVT.
 *
 * @note            If the connection exists, then HID Device will send a `VIRTUAL_CABLE_UNPLUG` control command to
 *                  the peer HID Host, and the connection will be destroyed. If the connection does not exist, then HID
 *                  Device will only unplug on it's single side. Once the unplug operation is success, the related
 *                  pairing and bonding information will be removed, then the HID Device can accept connection request
 *                  from the different HID Host,
 *
 * @return          - BK_OK: success
 *                  - other: failed
 */
bk_err_t bk_bt_hid_device_virtual_cable_unplug(void);

#ifdef __cplusplus
}
#endif