uint32_t ant_coex_config_set_req_enc(uint8_t                      channel,
                                     ANT_BUFFER_PTR const * const p_coex_config,
                                     ANT_BUFFER_PTR const * const p_adv_coex_config,
                                     uint8_t * const              p_buf,
                                     uint32_t * const             p_buf_len)
{
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint8_t svc_number = SVC_ANT_COEX_CONFIG_SET;
    uint32_t err_code = NRF_SUCCESS;
    uint32_t buf_len = *p_buf_len;
    uint32_t index = 0;

    err_code = uint8_t_enc(&svc_number, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_t_enc(&channel, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    // Encode coex config buffer size
    uint8_t coex_config_buffer_size = p_coex_config -> ucBufferSize;
    err_code = uint8_t_enc(&coex_config_buffer_size, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    // Encode coex config buffer
    err_code = uint8_vector_enc(p_coex_config -> pucBuffer,
                                coex_config_buffer_size,
                                p_buf,
                                buf_len,
                                &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    // Encode advanced coex config buffer size
    uint8_t adv_coex_config_buffer_size = p_adv_coex_config -> ucBufferSize;
    err_code = uint8_t_enc(&adv_coex_config_buffer_size, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

     // Encode advanced coex config buffer
    err_code = uint8_vector_enc(p_adv_coex_config -> pucBuffer,
                                adv_coex_config_buffer_size,
                                p_buf,
                                buf_len,
                                &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    SER_ASSERT_LENGTH_LEQ(index, *p_buf_len);

    *p_buf_len = index;

    return err_code;
}
uint32_t ant_crypto_key_set_req_enc(uint8_t               key_num,
                                    uint8_t const * const p_key,
                                    uint8_t * const       p_buf,
                                    uint32_t * const      p_buf_len)
{
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint8_t svc_number = SVC_ANT_CRYPTO_KEY_SET;
    uint32_t err_code = NRF_SUCCESS;
    uint32_t buf_len = *p_buf_len;
    uint32_t index = 0;

    err_code = uint8_t_enc(&svc_number, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_t_enc(&key_num, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_vector_enc(p_key, SIZE_OF_ENCRYPTED_KEY, p_buf, buf_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    SER_ASSERT_LENGTH_LEQ(index, *p_buf_len);

    *p_buf_len = index;

    return err_code;
}
uint32_t ant_crypto_info_get_rsp_enc(uint32_t               return_code,
                                     uint8_t * const        p_buf,
                                     uint32_t * const       p_buf_len,
                                     uint8_t                type,
                                     uint8_t const * const  p_info)
{
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint32_t total_len = *p_buf_len;

    uint32_t err_code = ser_ble_cmd_rsp_status_code_enc(SVC_ANT_CRYPTO_INFO_GET, return_code,
                                                        p_buf, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    if (return_code != NRF_SUCCESS)
    {
        return NRF_SUCCESS;
    }

    err_code = uint8_t_enc(&type, p_buf, total_len, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    uint8_t crypto_info_size = (MESG_CONFIG_ENCRYPT_REQ_CONFIG_USER_DATA_SIZE -
                                MESG_CHANNEL_NUM_SIZE);

    err_code = uint8_vector_enc(p_info, crypto_info_size, p_buf, total_len, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    return NRF_SUCCESS;
}
uint32_t ant_coex_config_get_rsp_enc(uint32_t               return_code,
                                     uint8_t * const        p_buf,
                                     uint32_t * const       p_buf_len,
                                     ANT_BUFFER_PTR * const p_coex_config,
                                     ANT_BUFFER_PTR * const p_adv_coex_config)
{
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint32_t total_len = *p_buf_len;

    uint32_t err_code = ser_ble_cmd_rsp_status_code_enc(SVC_ANT_COEX_CONFIG_GET, return_code,
                                                        p_buf, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    if (return_code != NRF_SUCCESS)
    {
        return NRF_SUCCESS;
    }

    err_code = uint8_t_enc(&(p_coex_config->ucBufferSize), p_buf, total_len, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_vector_enc(p_coex_config->pucBuffer,
                                p_coex_config->ucBufferSize,
                                p_buf,
                                total_len,
                                p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_t_enc(&(p_adv_coex_config->ucBufferSize), p_buf, total_len, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_vector_enc(p_adv_coex_config->pucBuffer,
                                p_adv_coex_config->ucBufferSize,
                                p_buf,
                                total_len,
                                p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    return NRF_SUCCESS;
}
uint32_t ble_gap_evt_adv_report_enc(ble_evt_t const * const p_event,
                                    uint32_t                event_len,
                                    uint8_t * const         p_buf,
                                    uint32_t * const        p_buf_len)
{
    SER_ASSERT_NOT_NULL(p_event);
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint32_t       index      = 0;
    uint32_t       total_len  = *p_buf_len;
    uint32_t       err_code   = NRF_SUCCESS;
    uint8_t        byte;
    const uint16_t evt_header = BLE_GAP_EVT_ADV_REPORT;

    err_code = uint16_t_enc((void *)&evt_header, p_buf, total_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint16_t_enc((void *)&p_event->evt.gap_evt.conn_handle, p_buf, total_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = ble_gap_addr_enc((void *)&(p_event->evt.gap_evt.params.adv_report.peer_addr), p_buf, total_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_t_enc((void *)&(p_event->evt.gap_evt.params.adv_report.rssi), p_buf, total_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    byte = (p_event->evt.gap_evt.params.adv_report.scan_rsp) |
           ((p_event->evt.gap_evt.params.adv_report.type) << 0x01) |
           ((p_event->evt.gap_evt.params.adv_report.dlen) << 0x03);

    err_code = uint8_t_enc((void *)&(byte), p_buf, total_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    err_code = uint8_vector_enc(p_event->evt.gap_evt.params.adv_report.data, (uint16_t)p_event->evt.gap_evt.params.adv_report.dlen, p_buf, total_len, &index);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    *p_buf_len = index;

    return err_code;
}
uint32_t ant_version_get_rsp_enc(uint32_t              return_code,
                                 uint8_t * const       p_buf,
                                 uint32_t * const      p_buf_len,
                                 uint8_t const * const p_version)
{
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint32_t total_len = *p_buf_len;

    uint32_t err_code = ser_ble_cmd_rsp_status_code_enc(SVC_ANT_VERSION, return_code,
                                                        p_buf, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    if (return_code != NRF_SUCCESS)
    {
        return NRF_SUCCESS;
    }

    err_code = uint8_vector_enc(p_version, MESG_BUFFER_SIZE, p_buf, total_len, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    return NRF_SUCCESS;
}
uint32_t ant_capabilities_get_rsp_enc(uint32_t              return_code,
                                      uint8_t * const       p_buf,
                                      uint32_t * const      p_buf_len,
                                      uint8_t const * const p_capabilities)
{
    SER_ASSERT_NOT_NULL(p_buf);
    SER_ASSERT_NOT_NULL(p_buf_len);

    uint32_t total_len = *p_buf_len;

    uint32_t err_code = ser_ble_cmd_rsp_status_code_enc(SVC_ANT_CAPABILITIES, return_code,
                                                        p_buf, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    if (return_code != NRF_SUCCESS)
    {
        return NRF_SUCCESS;
    }

    err_code = uint8_vector_enc(p_capabilities, MESG_CAPABILITIES_SIZE, p_buf, total_len, p_buf_len);
    SER_ASSERT(err_code == NRF_SUCCESS, err_code);

    return NRF_SUCCESS;
}