// Copyright 2017-2019 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at

//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef _PROVISIONER_PROV_H_
#define _PROVISIONER_PROV_H_

#include "mesh_main.h"
#include "mesh_bearer_adapt.h"

#ifdef __cplusplus
extern "C" {
#endif

#if !CONFIG_BLE_MESH_PROVISIONER

#define CONFIG_BLE_MESH_PBA_SAME_TIME   0
#define CONFIG_BLE_MESH_PBG_SAME_TIME   0

#else

#if !defined(CONFIG_BLE_MESH_PB_ADV)
#define CONFIG_BLE_MESH_PBA_SAME_TIME   0
#endif /* !CONFIG_BLE_MESH_PB_ADV */

#if !defined(CONFIG_BLE_MESH_PB_GATT)
#define CONFIG_BLE_MESH_PBG_SAME_TIME   0
#endif /* !CONFIG_BLE_MESH_PB_GATT */

#endif /* !CONFIG_BLE_MESH_PROVISIONER */

#define RM_AFTER_PROV  BIT(0)
#define START_PROV_NOW BIT(1)
#define FLUSHABLE_DEV  BIT(2)

struct bt_mesh_unprov_dev_add {
    u8_t  addr[6];
    u8_t  addr_type;
    u8_t  uuid[16];
    u16_t oob_info;
    u8_t  bearer;
};

struct bt_mesh_device_delete {
    u8_t addr[6];
    u8_t addr_type;
    u8_t uuid[16];
};

#define NET_IDX_FLAG  BIT(0)
#define FLAGS_FLAG    BIT(1)
#define IV_INDEX_FLAG BIT(2)

struct bt_mesh_prov_data_info {
    union {
        u16_t net_idx;
        u8_t  flags;
        u32_t iv_index;
    };
    u8_t flag;
};

/* The following APIs are for primary provisioner internal use */

/**
 * @brief This function decrements the current PB-GATT count.
 *
 * @return None
 */
void bt_mesh_provisioner_pbg_count_dec(void);

/**
 * @brief This function clears the part of the link info of the proper device.
 *
 * @param[in] addr: Remote device address
 *
 * @return None
 */
void bt_mesh_provisioner_clear_link_info(const u8_t addr[6]);

/**
 * @brief This function handles the received PB-ADV PDUs.
 *
 * @param[in] buf: Pointer to the buffer containing generic provisioning PDUs
 *
 * @return Zero - success, otherwise - fail
 */
void bt_mesh_provisioner_pb_adv_recv(struct net_buf_simple *buf);

/**
 * @brief This function sends provisioning invite to start
 *        provisioning this unprovisioned device.
 *
 * @param[in] addr: Remote device address
 * @param[in] conn: Pointer to the bt_conn structure
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_prov_conn(const u8_t addr[6], struct bt_mesh_conn *conn);

/**
 * @brief This function sends provisioning invite to start
 *        provisioning this unprovisioned device.
 *
 * @param[in] conn: Pointer to the bt_conn structure
 * @param[in] addr: Address of the connected device
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_pb_gatt_open(struct bt_mesh_conn *conn, u8_t *addr);

/**
 * @brief This function resets the used information when
 *        related connection is terminated.
 *
 * @param[in] conn:   Pointer to the bt_conn structure
 * @param[in] reason: Connection terminated reason
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_pb_gatt_close(struct bt_mesh_conn *conn, u8_t reason);

/**
 * @brief This function handles the received PB-GATT provision
 *        PDUs.
 *
 * @param[in] conn: Pointer to the bt_conn structure
 * @param[in] buf:  Pointer to the buffer containing provision PDUs
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_pb_gatt_recv(struct bt_mesh_conn *conn, struct net_buf_simple *buf);

/**
 * @brief This function initializes provisioner's PB-GATT and PB-ADV
 *        related information.
 *
 * @param[in] prov_info: Pointer to the application-initialized provisioner info.
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_prov_init(const struct bt_mesh_prov *prov_info);

/**
 * @brief This function deinitializes provisioner's PB-GATT and PB-ADV
 *        related information.
 *
 * @param[in] erase: Indicate if erasing provisioning information from flash.
 * 
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_prov_deinit(bool erase);

/**
 * @brief This function parses the received unprovisioned device
 *        beacon advertising packets, and if checked, starts to provision this device
 *        using PB-ADV bearer.
 *
 * @param[in] buf:  Pointer to the buffer containing unprovisioned device beacon
 * @param[in] rssi: RSSI of the received unprovisioned device beacon
 *
 * @return None
 */
void bt_mesh_provisioner_unprov_beacon_recv(struct net_buf_simple *buf, s8_t rssi);

void bt_mesh_provisioner_prov_adv_ind_recv(struct net_buf_simple *buf, const bt_mesh_addr_t *addr, s8_t rssi);

/**
 * @brief This function gets the bt_mesh_prov pointer.
 *
 * @return bt_mesh_prov pointer(prov)
 */
const struct bt_mesh_prov *bt_mesh_provisioner_get_prov_info(void);

void bt_mesh_provisoner_restore_prov_info(u16_t primary_addr, u16_t alloc_addr);

/* The following APIs are for primary provisioner application use */

/** @brief Add unprovisioned device info to unprov_dev queue
 *
 *  @param[in] add_dev: Pointer to the structure containing the device information
 *  @param[in] flags:   Flags indicate several operations of the device information
 *                       - Remove device information from queue after it is provisioned (BIT0)
 *                       - Start provisioning as soon as device is added to queue (BIT1)
 *                       - Device can be flushed when device queue is full (BIT2)
 *
 *  @return Zero on success or (negative) error code otherwise.
 *
 *  @note  1. Currently address type only supports public address and static random address.
 *         2. If device UUID and/or device address and address type already exist in the
 *            device queue, but the bearer differs from the existing one, add operation
 *            will also be successful and it will update the provision bearer supported by
 *            the device.
 */
int bt_mesh_provisioner_add_unprov_dev(struct bt_mesh_unprov_dev_add *add_dev, u8_t flags);

/** @brief Provision an unprovisioned device with fixed unicast address.
 *
 *  @param[in] uuid:         Device UUID of the unprovisioned device
 *  @param[in] addr:         Device address of the unprovisioned device
 *  @param[in] addr_type:    Device address type of the unprovisioned device
 *  @param[in] bearer:       Provisioning bearer going to be used
 *  @param[in] oob_info:     OOB info of the unprovisioned device
 *  @param[in] unicast_addr: Unicast address going to be allocated for the unprovisioned device
 *
 *  @return Zero on success or (negative) error code otherwise.
 *
 *  @note  1. Currently address type only supports public address and static random address.
 *         2. Bearer must be equal to BLE_MESH_PROV_ADV or BLE_MESH_PROV_GATT
 */
int bt_mesh_provisioner_prov_device_with_addr(const u8_t uuid[16], const u8_t addr[6],
                                              u8_t addr_type, bt_mesh_prov_bearer_t bearer,
                                              u16_t oob_info, u16_t unicast_addr);

/** @brief Delete device from queue, reset current provisioning link and reset the node
 *
 *  @param[in] del_dev: Pointer to the structure containing the device information
 *
 *  @return Zero on success or (negative) error code otherwise.
 */
int bt_mesh_provisioner_delete_device(struct bt_mesh_device_delete *del_dev);

/**
 * @brief This function sets a part of the device UUID for comparison before
 *        starting to provision the device.
 *
 * @param[in] offset: offset of the device UUID to be compared
 * @param[in] length: length of the device UUID to be compared
 * @param[in] match:  value to be compared
 * @param[in] prov_flag: flags indicate if uuid_match advertising packets are received, after that
 *                       the device will be provisioned at once or reported to the application layer
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_dev_uuid_match(u8_t offset, u8_t length,
        const u8_t *match, bool prov_flag);

/** @brief Callback for provisioner receiving advertising packet from unprovisioned devices which are
 *  not in the unprovisioned device queue.
 *
 *  Report on the unprovisioned device beacon and mesh provisioning service advertising data to application layer
 *
 *  @param addr      Unprovisioned device address pointer
 *  @param addr_type Unprovisioned device address type
 *  @param dev_uuid  Unprovisioned device device UUID pointer
 *  @param bearer    Advertising packet received from PB-GATT or PB-ADV bearer
 *  @param adv_type  Adv packet type, currently this is not used and we can use bearer to device
 *                   the adv_type(ADV_IND or ADV_NONCONN_IND). This parameter will be used, when
 *                   scan response data will be supported.
 *  @param rssi      RSSI of the received advertising packet
 *
 */
typedef void (*unprov_adv_pkt_cb_t)(const u8_t addr[6], const u8_t addr_type,
                                    const u8_t adv_type, const u8_t dev_uuid[16],
                                    u16_t oob_info, bt_mesh_prov_bearer_t bearer, s8_t rssi);

/**
 * @brief This function registers the callback which notifies the application
 *        layer of the received mesh provisioning or unprovisioned device
 *        beacon advertizing packets (from devices not in the unprov device queue).
 *
 * @param[in] cb: Callback of the notifying adv pkts function
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_adv_pkt_cb_register(unprov_adv_pkt_cb_t cb);

/**
 * @brief This function changes net_idx or flags or iv_index used in provisioning data.
 *
 * @param[in] info: Pointer of structure containing net_idx or flags or iv_index
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_prov_data_info(struct bt_mesh_prov_data_info *info);

/**
 * @brief This function sets the provisioning information needed by Provisioner,
 *        including unicast address, IV Index, etc.
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_prov_info(void);

/**
 * @brief This function sets the provisioning bearer type used by Provisioner.
 *
 * @param[in] bearers: Provisioning bearer type
 * @param[in] clear:   Indicate if the corresponding bearer type will be cleared
 *
 * @return None
 */
void bt_mesh_provisioner_set_prov_bearer(bt_mesh_prov_bearer_t bearers, bool clear);

/**
 * @brief This function gets the provisioning bearer type used by Provisioner.
 *
 * @return Currently supported provisioning bearer type
 */
bt_mesh_prov_bearer_t bt_mesh_provisioner_get_prov_bearer(void);

/**
 * @brief This function sets the Static OOB value used by Provisioner.
 *
 * @param[in] value:  Static OOB value
 * @param[in] length: Static OOB value length
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_static_oob_value(const u8_t *value, u8_t length);

/**
 * @brief This function gets the unicast address of primary element of Provisioner.
 *
 * @return Unicast address of primary element of Provisioner.
 */
u16_t bt_mesh_provisioner_get_primary_elem_addr(void);

/**
 * @brief This function sets the unicast address of primary element of Provisioner.
 *
 * @param[in] addr: unicast address of primary element
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_primary_elem_addr(u16_t addr);

/**
 * @brief This function is used to update next allocated address by Provisioner.
 *
 * @note  This function is used for mesh internal test.
 *
 * @param[in] unicast_addr: unicast address of the node
 * @param[in] element_num:  element count of the node
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_test_provisioner_update_alloc_addr(u16_t unicast_addr, u16_t element_num);

/**
 * @brief This function is called to input number/string out-put by unprovisioned device.
 *
 * @param[in] idx       The provisioning link index
 * @param[in] val       Pointer of the input number/string
 * @param[in] num_flag  Flag indicates if it is a number or string
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_oob_input_data(const u8_t idx, const u8_t *val, bool num_flag);

/**
 * @brief This function is called to output number/string which will be input by unprovisioned device.
 *
 * @param[in] idx       The provisioning link index
 * @param[in] num       Pointer of the output number/string
 * @param[in] size      Size of the output number/string
 * @param[in] num_flag  Flag indicates if it is a number or string
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_set_oob_output_data(const u8_t idx, const u8_t *num, u8_t size, bool num_flag);

/**
 * @brief This function is called to read unprovisioned device's oob public key.
 *
 * @param[in] idx        The provisioning link index
 * @param[in] pub_key_x  Unprovisioned device's Public Key X
 * @param[in] pub_key_y  Unprovisioned device's Public Key Y
 *
 * @return Zero - success, otherwise - fail
 */
int bt_mesh_provisioner_read_oob_pub_key(const u8_t idx, const u8_t pub_key_x[32], const u8_t pub_key_y[32]);

/* The following APIs are for fast provisioning */

/**
 * @brief This function is called to set fast_prov_flag.
 *
 * @param[in] enable: Enable or disable fast provisioning
 *
 * @return None
 */
void bt_mesh_provisioner_fast_prov_enable(bool enable);

/**
 * @brief This function is called to set netkey index used for fast provisioning.
 *
 * @param[in] net_key: Netkey value
 * @param[in] net_idx: Netkey index
 *
 * @return status for set netkey index msg
 */
u8_t bt_mesh_provisioner_set_fast_prov_net_idx(const u8_t *net_key, u16_t net_idx);

/**
 * @brief This function is called to get netkey index used for fast provisioning.
 *
 * @return net_idx of fast provisioning
 */
u16_t bt_mesh_provisioner_get_fast_prov_net_idx(void);

/**
 * @brief This function is called to set unicast address range used for fast provisioning.
 *
 * @param[in] min: Minimum unicast address
 * @param[in] max: Maximum unicast address
 *
 * @return status for set unicast address range message
 */
u8_t bt_mesh_set_fast_prov_unicast_addr_range(u16_t min, u16_t max);

/**
 * @brief This function is called to set flags & iv_index used for fast provisioning.
 *
 * @param[in] flags:    Key refresh flag and iv update flag
 * @param[in] iv_index: IV index
 *
 * @return None
 */
void bt_mesh_set_fast_prov_flags_iv_index(u8_t flags, u32_t iv_index);

#ifdef __cplusplus
}
#endif

#endif /* _PROVISIONER_PROV_H_ */